Attachment #134529 for bug #262160

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.emf.ecore.EFactory;

/**
 * PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.
 */
public class EMFUpdateListStrategy extends UpdateListStrategy {
	/**
	 * A list update strategy with default update policy
	 * {@link UpdateListStrategy#POLICY_UPDATE} and default converters and
	 * validators
	 */
	public EMFUpdateListStrategy() {
		this(true, POLICY_UPDATE);
	}

	/**
	 * A list update strategy with a specific update policy but with default
	 * converters and validators
	 * 
	 * @param updatePolicy
	 *            the policy
	 */
	public EMFUpdateListStrategy(int updatePolicy) {
		this(true, updatePolicy);
	}

	/**
	 * A list update strategy with a specific update policy and with the
	 * possibility to turn of default converters and validators
	 * 
	 * @param provideDefaults
	 *            <code>false</code> to turn of default converters and
	 *            validators
	 * @param updatePolicy
	 *            the policy
	 */
	public EMFUpdateListStrategy(boolean provideDefaults, int updatePolicy) {
		super(provideDefaults, updatePolicy);
	}

	@Override
	protected IConverter createConverter(Object fromType, Object toType) {
		if (fromType == String.class) {
			if (toType instanceof EAttribute) {
				final EAttribute eAttribute = (EAttribute) toType;
				final EDataType eDataType = eAttribute.getEAttributeType();
				final EFactory eFactory = eDataType.getEPackage()
						.getEFactoryInstance();
				return new Converter(fromType, toType) {
					public Object convert(Object fromObject) {
						return eFactory.createFromString(eDataType,
								(String) fromObject);
					}
				};
			}
		} else if (toType == String.class) {
			if (fromType instanceof EAttribute) {
				final EAttribute eAttribute = (EAttribute) fromType;
				final EDataType eDataType = eAttribute.getEAttributeType();
				final EFactory eFactory = eDataType.getEPackage()
						.getEFactoryInstance();
				return new Converter(fromType, toType) {
					public Object convert(Object fromObject) {
						return eFactory.convertToString(eDataType, fromObject);
					}
				};
			}
		}
		return super.createConverter(fromType, toType);
	}
}




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

/**
 * PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.
 */
public class EMFDataBindingContext extends DataBindingContext {
	/**
	 * Create a new databinding context which uses the default realm for
	 * validation
	 */
	public EMFDataBindingContext() {
		this(Realm.getDefault());
	}

	/**
	 * Create a databinding context which uses an explicit realm for
	 * synchronisation
	 * 
	 * @param validationRealm
	 *            the realm to use
	 */
	public EMFDataBindingContext(Realm validationRealm) {
		super(validationRealm);
	}

	@Override
	protected UpdateValueStrategy createModelToTargetUpdateValueStrategy(
			IObservableValue fromValue, IObservableValue toValue) {
		return new EMFUpdateValueStrategy();
	}

	@Override
	protected UpdateValueStrategy createTargetToModelUpdateValueStrategy(
			IObservableValue fromValue, IObservableValue toValue) {
		return new EMFUpdateValueStrategy();
	}
}




import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.
 */
public class EObjectObservableValue extends AbstractObservableValue implements
		IObserving {
	/**
	 * The object instance
	 */
	protected EObject eObject;
	/**
	 * The feature
	 */
	protected EStructuralFeature eStructuralFeature;
	/**
	 * The listener
	 */
	protected Adapter listener;

	/**
	 * Observe a feature of the instance using the default realm
	 * 
	 * @param eObject
	 *            the object
	 * @param eStructuralFeature
	 *            the feature
	 */
	public EObjectObservableValue(EObject eObject,
			EStructuralFeature eStructuralFeature) {
		this(Realm.getDefault(), eObject, eStructuralFeature);
	}

	/**
	 * Observe a feature of the instance using the realm
	 * 
	 * @param realm
	 * 
	 * @param eObject
	 *            the object
	 * @param eStructuralFeature
	 *            the feature
	 */
	public EObjectObservableValue(Realm realm, EObject eObject,
			EStructuralFeature eStructuralFeature) {
		super(realm);
		this.eObject = eObject;
		this.eStructuralFeature = eStructuralFeature;
	}

	@Override
	public synchronized void dispose() {
		if (listener != null) {
			eObject.eAdapters().remove(listener);
			listener = null;
		}
		eObject = null;
		eStructuralFeature = null;
		super.dispose();
	}

	public Object getObserved() {
		return eObject;
	}

	@Override
	protected void firstListenerAdded() {
		listener = new AdapterImpl() {
			@Override
			public void notifyChanged(Notification notification) {
				if (eStructuralFeature == notification.getFeature()
						&& !notification.isTouch()) {
					final ValueDiff diff = Diffs.createValueDiff(notification
							.getOldValue(), notification.getNewValue());
					getRealm().exec(new Runnable() {
						public void run() {
							fireValueChange(diff);
						}
					});
				}
			}
		};
		eObject.eAdapters().add(listener);
	}

	@Override
	protected void lastListenerRemoved() {
		eObject.eAdapters().remove(listener);
		listener = null;
	}

	@Override
	protected Object doGetValue() {
		return eObject.eGet(eStructuralFeature);
	}

	@Override
	protected void doSetValue(Object value) {
		eObject.eSet(eStructuralFeature, value);
	}

	public Object getValueType() {
		return eStructuralFeature;
	}

	@Override
	public String toString() {
		StringBuilder result = new StringBuilder(getClass().getName());
		result.append('@');
		result.append(Integer.toHexString(hashCode()));

		result.append(" (eObject:");
		result.append(eObject);
		result.append(")");

		result.append(" (eStructuralFeature: ");
		result.append(eStructuralFeature);
		result.append(")");

		try {
			Object value = eObject.eGet(eStructuralFeature, false);
			result.append(" (value: ");
			result.append(value);
			result.append(")");
		} catch (Exception exception) {
			// Ignore.
		}

		return result.toString();
	}
}

Lines 26-33 Link Here

(-)src/org/eclipse/emf/databinding/EMFObservables.java (+16 lines)
26	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;	26	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
27	import org.eclipse.core.databinding.observable.set.IObservableSet;	27	import org.eclipse.core.databinding.observable.set.IObservableSet;
28	import org.eclipse.core.databinding.observable.value.IObservableValue;	28	import org.eclipse.core.databinding.observable.value.IObservableValue;
		29	import org.eclipse.emf.common.notify.NotifyingList;
		30	import org.eclipse.emf.databinding.internal.EWritableList;
29	import org.eclipse.emf.ecore.EObject;	31	import org.eclipse.emf.ecore.EObject;
30	import org.eclipse.emf.ecore.EStructuralFeature;	32	import org.eclipse.emf.ecore.EStructuralFeature;
		33	import org.eclipse.emf.ecore.resource.Resource;
31		34
32	/**	35	/**
33	* PROVISIONAL	36	* PROVISIONAL
Lines 191-194 Link Here
191	}	194	}
192	};	195	};
193	}	196	}
		197
		198	/**
		199	* Returns an observable for the resource contents (
		200	* {@link Resource#getContents()})
		201	*
		202	* @param resource
		203	* the resources the content should be observed
		204	* @return an observable list
		205	*/
		206	public static IObservableList observeResourceContents(Resource resource) {
		207	return new EWritableList<EObject>((NotifyingList<EObject>) resource.getContents());
		208	}
		209
194	}	210	}




import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.
 */
public class EObjectObservableList extends ObservableList implements
		IObserving, InternalRawEList {
	/**
	 * The object owning the feature
	 */
	protected EObject eObject;
	/**
	 * The structural feature
	 */
	protected EStructuralFeature eStructuralFeature;
	/**
	 * The listener attached
	 */
	protected Adapter listener;

	/**
	 * Observe a list feature using a default realm
	 * 
	 * @param eObject
	 *            the object instance
	 * @param eStructuralFeature
	 *            the feature
	 */
	public EObjectObservableList(EObject eObject,
			EStructuralFeature eStructuralFeature) {
		this(Realm.getDefault(), eObject, eStructuralFeature);
	}

	/**
	 * Observe a list feature using a custom realm
	 * 
	 * @param realm
	 *            the realm
	 * 
	 * @param eObject
	 *            the object instance
	 * @param eStructuralFeature
	 *            the feature
	 */
	public EObjectObservableList(Realm realm, EObject eObject,
			EStructuralFeature eStructuralFeature) {
		super(realm, (EList<?>) eObject.eGet(eStructuralFeature),
				eStructuralFeature);
		this.eObject = eObject;
		this.eStructuralFeature = eStructuralFeature;
	}

	@Override
	protected void firstListenerAdded() {
		listener = new AdapterImpl() {
			@Override
			public void notifyChanged(Notification notification) {
				if (eStructuralFeature == notification.getFeature()
						&& !notification.isTouch()) {
					final ListDiff diff;
					switch (notification.getEventType()) {
					case Notification.ADD: {
						diff = Diffs.createListDiff(Diffs.createListDiffEntry(
								notification.getPosition(), true, notification
										.getNewValue()));
						break;
					}
					case Notification.ADD_MANY: {
						Collection<?> newValues = (Collection<?>) notification
								.getNewValue();
						ListDiffEntry[] listDiffEntries = new ListDiffEntry[newValues
								.size()];
						int position = notification.getPosition();
						int index = 0;
						for (Object newValue : newValues) {
							listDiffEntries[index++] = Diffs
									.createListDiffEntry(position++, true,
											newValue);
						}
						diff = Diffs.createListDiff(listDiffEntries);
						break;
					}
					case Notification.REMOVE: {
						diff = Diffs.createListDiff(Diffs.createListDiffEntry(
								notification.getPosition(), false, notification
										.getOldValue()));
						break;
					}
					case Notification.REMOVE_MANY: {
						Collection<?> oldValues = (Collection<?>) notification
								.getOldValue();
						ListDiffEntry[] listDiffEntries = new ListDiffEntry[oldValues
								.size()];
						int position = notification.getPosition();
						int index = 0;
						for (Object oldValue : oldValues) {
							listDiffEntries[index++] = Diffs
									.createListDiffEntry(position++, false,
											oldValue);
						}
						diff = Diffs.createListDiff(listDiffEntries);
						break;
					}
					case Notification.SET:
					case Notification.RESOLVE: {
						ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
						listDiffEntries[0] = Diffs.createListDiffEntry(
								notification.getPosition(), false, notification
										.getOldValue());
						listDiffEntries[1] = Diffs.createListDiffEntry(
								notification.getPosition(), true, notification
										.getNewValue());
						diff = Diffs.createListDiff(listDiffEntries);
						break;
					}
					case Notification.MOVE: {
						Object movedValue = notification.getNewValue();
						ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
						listDiffEntries[0] = Diffs.createListDiffEntry(
								(Integer) notification.getOldValue(), false,
								movedValue);
						listDiffEntries[1] = Diffs.createListDiffEntry(
								notification.getPosition(), true, movedValue);
						diff = Diffs.createListDiff(listDiffEntries);
						break;
					}
					case Notification.UNSET: {
						// This just represents going back to the unset state,
						// but that doesn't affect the contents of the list.
						//
						return;
					}
					default: {
						throw new RuntimeException("unhandled case");
					}
					}
					getRealm().exec(new Runnable() {
						public void run() {
							fireListChange(diff);
						}
					});
				}
			}
		};
		eObject.eAdapters().add(listener);
	}

	@Override
	protected void lastListenerRemoved() {
		eObject.eAdapters().remove(listener);
		listener = null;
	}

	@Override
	public synchronized void dispose() {
		if (listener != null) {
			eObject.eAdapters().remove(listener);
			listener = null;
		}
		eObject = null;
		eStructuralFeature = null;
		super.dispose();
	}

	/**
	 * @return the wrapped list
	 */
	@SuppressWarnings("unchecked")
	protected final List<Object> wrappedList() {
		return wrappedList;
	}

	public Object getObserved() {
		return eObject;
	}

	@Override
	public boolean add(Object object) {
		checkRealm();
		return wrappedList().add(object);
	}

	@Override
	public void add(int index, Object object) {
		checkRealm();
		wrappedList().add(index, object);
	}

	@SuppressWarnings("unchecked")
	@Override
	public boolean addAll(Collection collection) {
		checkRealm();
		return wrappedList().addAll(collection);
	}

	@SuppressWarnings("unchecked")
	@Override
	public boolean addAll(int index, Collection collection) {
		checkRealm();
		return wrappedList().addAll(index, collection);
	}

	@Override
	public Object set(int index, Object element) {
		checkRealm();
		return wrappedList().set(index, element);
	}

	@Override
	public Object remove(int index) {
		checkRealm();
		return wrappedList.remove(index);
	}

	@Override
	public boolean remove(Object element) {
		checkRealm();
		return wrappedList.remove(element);
	}

	@SuppressWarnings("unchecked")
	@Override
	public boolean removeAll(Collection collection) {
		checkRealm();
		return wrappedList().removeAll(collection);
	}

	@SuppressWarnings("unchecked")
	@Override
	public boolean retainAll(Collection collection) {
		checkRealm();
		return wrappedList().retainAll(collection);
	}

	@Override
	public void clear() {
		checkRealm();
		wrappedList.clear();
	}

	@Override
	public Object move(int newPosition, int oldPosition) {
		checkRealm();
		return ((EList<?>) wrappedList).move(newPosition, oldPosition);
	}

	public void move(int newPosition, Object object) {
		move(newPosition, indexOf(object));
	}

	@Override
	public String toString() {
		StringBuilder result = new StringBuilder(getClass().getName());
		result.append('@');
		result.append(Integer.toHexString(hashCode()));

		result.append(" (eObject:");
		result.append(eObject);
		result.append(")");

		result.append(" (eStructuralFeature: ");
		result.append(eStructuralFeature);
		result.append(")");

		result.append(" (wrappedList: ");
		result.append(wrappedList);
		result.append(")");

		return result.toString();
	}
}

@SuppressWarnings("unchecked")
interface InternalRawEList extends EList {
	// This is only at avoid needing an @SuppressWarnings("unchecked") on the
	// EMFObservableList
}




import org.eclipse.emf.ecore.util.ExtendedMetaData;

/**
 * PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.
 */
public class EObjectObservableMap extends ComputedObservableMap {
	/**
	 * The feature to observe
	 */
	protected EStructuralFeature eStructuralFeature;

	private Adapter elementListener = new AdapterImpl() {
		@Override
		public void notifyChanged(Notification notification) {
			if (eStructuralFeature == notification.getFeature()
					&& !notification.isTouch()) {
				// TODO
				// This assumes we only get a SET notification, which isn't a
				// good assumption.
				//
				final MapDiff diff = Diffs.createMapDiffSingleChange(
						notification.getNotifier(), notification.getOldValue(),
						notification.getNewValue());
				getRealm().exec(new Runnable() {
					public void run() {
						fireMapChange(diff);
					}
				});
			}
		}
	};

	/**
	 * Create a new observable for the set of features
	 * 
	 * @param objects
	 *            the objects to observe
	 * @param feature
	 *            the feature
	 */
	public EObjectObservableMap(IObservableSet objects,
			EStructuralFeature feature) {
		super(objects);
		this.eStructuralFeature = feature;
	}

	@Override
	protected void hookListener(Object domainElement) {
		((EObject) domainElement).eAdapters().add(elementListener);
	}

	@Override
	protected void unhookListener(Object domainElement) {
		((EObject) domainElement).eAdapters().remove(elementListener);
	}

	@Override
	protected Object doGet(Object key) {
		EObject eObject = (EObject) key;
		return ExtendedMetaData.INSTANCE.getAffiliation(eObject.eClass(),
				eStructuralFeature) == null ? null : eObject
				.eGet(eStructuralFeature);
	}

	@Override
	protected Object doPut(Object key, Object value) {
		EObject eObject = (EObject) key;
		Object result = eObject.eGet(eStructuralFeature);
		eObject.eSet(eStructuralFeature, value);
		return result;
	}
}




import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.databinding.UpdateListStrategy;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.conversion.Converter;
import org.eclipse.core.databinding.conversion.IConverter;

import org.eclipse.emf.ecore.EFactory;

/**
 * PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.
 */
public class EMFUpdateValueStrategy extends UpdateValueStrategy {
	/**
	 * A value update strategy with default update policy
	 * {@link UpdateListStrategy#POLICY_UPDATE} and default converters and
	 * validators
	 */
	public EMFUpdateValueStrategy() {
		this(true, POLICY_UPDATE);
	}

	/**
	 * A list value strategy with a specific update policy but with default
	 * converters and validators
	 * 
	 * @param updatePolicy
	 *            the policy
	 */
	public EMFUpdateValueStrategy(int updatePolicy) {
		this(true, updatePolicy);
	}

	/**
	 * A list value strategy with a specific update policy and with the
	 * possibility to turn of default converters and validators
	 * 
	 * @param provideDefaults
	 *            <code>false</code> to turn of default converters and
	 *            validators
	 * @param updatePolicy
	 *            the policy
	 */
	public EMFUpdateValueStrategy(boolean provideDefaults, int updatePolicy) {
		super(provideDefaults, updatePolicy);
	}

	@Override
	protected IConverter createConverter(Object fromType, Object toType) {
		if (fromType == String.class) {
			if (toType instanceof EAttribute) {
				final EAttribute eAttribute = (EAttribute) toType;
				final EDataType eDataType = eAttribute.getEAttributeType();
				final EFactory eFactory = eDataType.getEPackage()
						.getEFactoryInstance();
				return new Converter(fromType, toType) {
					public Object convert(Object fromObject) {
						String value = fromObject == null ? null : fromObject
								.toString();
						if (eAttribute.isMany()) {
							List<Object> result = new ArrayList<Object>();
							if (value != null) {
								for (String element : value.split(" ")) {
									result.add(eFactory.createFromString(
											eDataType, element));
								}
							}
							return result;
						} else {
							return eFactory.createFromString(eDataType, value);
						}
					}
				};
			}
		} else if (toType == String.class) {
			if (fromType instanceof EAttribute) {
				final EAttribute eAttribute = (EAttribute) fromType;
				final EDataType eDataType = eAttribute.getEAttributeType();
				final EFactory eFactory = eDataType.getEPackage()
						.getEFactoryInstance();
				return new Converter(fromType, toType) {
					public Object convert(Object fromObject) {
						if (eAttribute.isMany()) {
							StringBuilder result = new StringBuilder();
							for (Object value : (List<?>) fromObject) {
								if (result.length() == 0) {
									result.append(' ');
								}
								result.append(eFactory.convertToString(
										eDataType, value));
							}
							return result.toString();
						} else {
							return eFactory.convertToString(eDataType,
									fromObject);
						}
					}
				};
			}
		}
		return super.createConverter(fromType, toType);
	}
              }
            }
          };
      }
    }
    return super.createConverter(fromType, toType);
  }
}

Lines 8-16 Link Here

(-)META-INF/MANIFEST.MF (-2 / +4 lines)
8	Bundle-Vendor: %providerName	8	Bundle-Vendor: %providerName
9	Bundle-Localization: plugin	9	Bundle-Localization: plugin
10	Bundle-RequiredExecutionEnvironment: J2SE-1.5	10	Bundle-RequiredExecutionEnvironment: J2SE-1.5
11	Export-Package: org.eclipse.emf.databinding	11	Export-Package: org.eclipse.emf.databinding,
		12	org.eclipse.emf.databinding.internal;x-friends:="org.eclipse.emf.databinding.edit"
12	Require-Bundle: org.eclipse.core.runtime,	13	Require-Bundle: org.eclipse.core.runtime,
13	org.eclipse.emf.ecore;visibility:=reexport,	14	org.eclipse.emf.ecore;visibility:=reexport,
14	org.eclipse.core.databinding;visibility:=reexport	15	org.eclipse.core.databinding;visibility:=reexport,
		16	org.eclipse.core.databinding.property;bundle-version="1.2.0"
15	Eclipse-LazyStart: true	17	Eclipse-LazyStart: true
16	Bundle-ActivationPolicy: lazy	18	Bundle-ActivationPolicy: lazy

Lines 1-8 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-1 / +18 lines)
1	#Thu Mar 19 06:34:41 EDT 2009	1	#Mon May 04 17:54:25 CEST 2009
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
		5	org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
5	org.eclipse.jdt.core.compiler.compliance=1.5	6	org.eclipse.jdt.core.compiler.compliance=1.5
		7	org.eclipse.jdt.core.compiler.debug.lineNumber=generate
		8	org.eclipse.jdt.core.compiler.debug.localVariable=generate
		9	org.eclipse.jdt.core.compiler.debug.sourceFile=generate
		10	org.eclipse.jdt.core.compiler.doc.comment.support=enabled
6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error	11	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error	12	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
		13	org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
		14	org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
		15	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
		16	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=enabled
		17	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
		18	org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
		19	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
		20	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
		21	org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=return_tag
		22	org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
		23	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
		24	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
8	org.eclipse.jdt.core.compiler.source=1.5	25	org.eclipse.jdt.core.compiler.source=1.5




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

package org.eclipse.emf.databinding;

import java.util.Map;

import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * An {@link IMapProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.2
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFMapProperty extends IEMFProperty, IMapProperty {

	/**
	 * Returns a master-detail combination of this property and the specified
	 * nested value feature.
	 * 
	 * @param featurePath
	 *            the nested value feature to observe
	 * @return a master-detail combination of this property and the specified
	 *         nested value feature.
	 * @see #values(IEMFValueProperty)
	 */
	public IEMFMapProperty values(FeaturePath featurePath);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value feature.
	 * 
	 * @param feature
	 *            the value feature to observe
	 * @return a master-detail combination of this property and the specified
	 *         nested value feature.
	 * @see #values(IEMFValueProperty)
	 */
	public IEMFMapProperty values(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property. The returned property will observe the specified value
	 * property for all {@link Map#values() values} observed by this map
	 * property, mapping from this map property's {@link Map#keySet() key set}
	 * to the specified value property's value for each element in the master
	 * property's {@link Map#values() values} collection.
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 */
	public IEMFMapProperty values(IEMFValueProperty property);
}
Index: src/org/eclipse/emf/databinding/internal/EMFPropertyHelper.java

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

package org.eclipse.emf.databinding.internal;

import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * @since 1.2
 * 
 */
public class EMFPropertyHelper {


	/**
	 * @param eStructuralFeature
	 * @return String description of property descriptor
	 */
	public static String propertyName(EStructuralFeature eStructuralFeature) {
		return eStructuralFeature.getEContainingClass().getName()
				+ "." + eStructuralFeature.getName() + ""; //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * @param eStructuralFeature
	 * @return class name excluding package
	 */
	public static String shortClassName(EStructuralFeature eStructuralFeature) {
		return eStructuralFeature.getEType().getName();
	}
}
Index: src/org/eclipse/emf/databinding/internal/EWritableList.java

/**
 * <copyright>
 *
 * Copyright (c) 2007 BestSolution.at 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:
 * Tom Schindl<tom.schindl@bestsolution.at> - Initial API and implementation
 *
 * </copyright>
 *
 * $Id: $
 */
package org.eclipse.emf.databinding.internal;

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.AbstractObservableList;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.NotifyingList;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.ecore.resource.Resource;

/**
 * Writable list which can be used to observe an {@link NotifyingList}
 * 
 * @param <Type>
 */
public class EWritableList<Type> extends AbstractObservableList implements
		IObservableList {
	private NotifyingList<Type> wrappedList;
	private Object elementType;
	private boolean stale = false;

	private class Listener extends AdapterImpl {
		private Object feature;

		public Listener(Object feature) {
			this.feature = feature;
		}

		@Override
		public void notifyChanged(Notification msg) {

			if (feature == null
					&& msg.getFeature() == null
					&& msg.getFeatureID(Resource.class) != Resource.RESOURCE__CONTENTS) {
				return;
			}

			if (feature == msg.getFeature() && !msg.isTouch()) {
				final ListDiff diff;
				switch (msg.getEventType()) {
				case Notification.ADD: {
					diff = Diffs.createListDiff(Diffs.createListDiffEntry(msg
							.getPosition(), true, msg.getNewValue()));
					// fireListChange(diff);
					break;
				}
				case Notification.ADD_MANY: {
					Collection<?> newValues = (Collection<?>) msg.getNewValue();
					ListDiffEntry[] listDiffEntries = new ListDiffEntry[newValues
							.size()];
					int position = msg.getPosition();
					int index = 0;
					for (Object newValue : newValues) {
						listDiffEntries[index++] = Diffs.createListDiffEntry(
								position++, true, newValue);
					}
					diff = Diffs.createListDiff(listDiffEntries);
					// fireListChange(diff);
					break;
				}
				case Notification.REMOVE: {
					diff = Diffs.createListDiff(Diffs.createListDiffEntry(msg
							.getPosition(), false, msg.getOldValue()));
					// fireListChange(diff);
					break;
				}
				case Notification.REMOVE_MANY: {
					Collection<?> oldValues = (Collection<?>) msg.getOldValue();
					ListDiffEntry[] listDiffEntries = new ListDiffEntry[oldValues
							.size()];
					int position = msg.getPosition();
					int index = 0;
					for (Object oldValue : oldValues) {
						listDiffEntries[index++] = Diffs.createListDiffEntry(
								position++, false, oldValue);
					}
					diff = Diffs.createListDiff(listDiffEntries);
					// fireListChange(diff);
					break;
				}
				case Notification.MOVE: {
					Object movedValue = msg.getNewValue();
					ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
					listDiffEntries[0] = Diffs.createListDiffEntry(
							(Integer) msg.getOldValue(), false, movedValue);
					listDiffEntries[1] = Diffs.createListDiffEntry(msg
							.getPosition(), true, movedValue);
					diff = Diffs.createListDiff(listDiffEntries);
					// fireListChange(diff);
					break;
				}
				case Notification.UNSET: {
					// This just represents going back to the unset state, but
					// that doesn't affect the contents of the list.
					//
					return;
				}
				default: {
					throw new RuntimeException("unhandled case");
				}
				}

				getRealm().exec(new Runnable() {
					public void run() {
						fireListChange(diff);
					}
				});

				// System.err.println("CHANGE: " +
				// diff.getDifferences()[0].getElement());

				// fireListChange(diff);
				// listener.handlePropertyChange(new SimplePropertyEvent(msg
				// .getNotifier(), EMFListProperty.this, diff));
			}
		}

	}

	private Adapter listener;

	/**
	 * New writable list wrapping the {@link NotifyingList}
	 * 
	 * @param wrappedList
	 *            the wrapped list
	 */
	public EWritableList(NotifyingList<Type> wrappedList) {
		this(Realm.getDefault(), wrappedList);
	}

	/**
	 * New writable list wrapping the {@link NotifyingList} and using the
	 * {@link Realm}
	 * 
	 * @param realm
	 *            the realm
	 * @param wrappedList
	 *            the wrapped list
	 */
	public EWritableList(Realm realm, NotifyingList<Type> wrappedList) {
		this(realm, wrappedList, null);
	}

	/**
	 * New writable list wrapping the {@link NotifyingList}
	 * 
	 * @param realm
	 *            the realm
	 * @param wrappedList
	 *            the wrapped list
	 * @param elementType
	 *            the element type
	 */
	public EWritableList(Realm realm, NotifyingList<Type> wrappedList,
			Class<Type> elementType) {
		super(realm);
		this.wrappedList = wrappedList;
		this.elementType = elementType;
	}
	
	@Override
	protected void firstListenerAdded() {
		if (wrappedList.getNotifier() instanceof Notifier) {
			Notifier notifier = (Notifier) wrappedList.getNotifier();
			listener = new Listener(wrappedList.getFeature());
			notifier.eAdapters().add(listener);
		} else {
			throw new IllegalArgumentException(
					"Wrapped list must have a notifier attached!");
		}
	}
	
	@Override
	protected void lastListenerRemoved() {
		if (wrappedList.getNotifier() instanceof Notifier) {
			Notifier notifier = (Notifier) wrappedList.getNotifier();
			listener = new Listener(wrappedList.getFeature());
			notifier.eAdapters().remove(listener);
		} else {
			throw new IllegalArgumentException(
					"Wrapped list must have a notifier attached!");
		}
	}

	@Override
	public synchronized void dispose() {
		super.dispose();
	}

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

	@SuppressWarnings("unchecked")
	public boolean add(Object o) {
		checkRealm();
		return wrappedList.add((Type) o);
	}

	@SuppressWarnings("unchecked")
	public boolean addAll(Collection c) {
		checkRealm();
		return wrappedList.addAll(c);
	}

	@SuppressWarnings("unchecked")
	public boolean addAll(int index, Collection c) {
		checkRealm();
		return wrappedList.addAll(index, c);
	}

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

	@SuppressWarnings("unchecked")
	public boolean containsAll(Collection c) {
		getterCalled();
		return wrappedList.containsAll(c);
	}

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

	public Object getElementType() {
		checkRealm();
		return elementType;
	}

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

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

	public Iterator<Type> iterator() {
		getterCalled();
		return wrappedList.iterator();
	}

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

	public ListIterator<Type> listIterator() {
		getterCalled();
		return wrappedList.listIterator();
	}

	public ListIterator<Type> listIterator(int index) {
		getterCalled();
		return wrappedList.listIterator(index);
	}

	public Object move(int oldIndex, int newIndex) {
		checkRealm();
		return wrappedList.move(oldIndex, newIndex);
	}

	public boolean remove(Object o) {
		checkRealm();
		return wrappedList.remove(o);
	}

	public Object remove(int index) {
		checkRealm();
		return wrappedList.remove(index);
	}

	@SuppressWarnings("unchecked")
	public boolean removeAll(Collection c) {
		checkRealm();
		return wrappedList.removeAll(c);
	}

	@SuppressWarnings("unchecked")
	public boolean retainAll(Collection c) {
		checkRealm();
		return wrappedList.retainAll(c);
	}

	@SuppressWarnings("unchecked")
	public Object set(int index, Object element) {
		checkRealm();
		return wrappedList.set(index, (Type) element);
	}

	public int doGetSize() {
		getterCalled();
		return wrappedList.size();
	}

	public List<Type> subList(int fromIndex, int toIndex) {
		getterCalled();
		return wrappedList.subList(fromIndex, toIndex);
	}

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

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

	@SuppressWarnings("unchecked")
	public void add(int index, Object element) {
		checkRealm();
		wrappedList.add(index, (Type) element);
	}

	public void clear() {
		checkRealm();
		wrappedList.clear();
	}

	public boolean isStale() {
		getterCalled();
		return stale;
	}

	// public void setStale(boolean stale) {
	// checkRealm();
	//
	// boolean wasStale = this.stale;
	// this.stale = stale;
	// if (!wasStale && stale) {
	// fireStale();
	// }
	// }
}




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

package org.eclipse.emf.databinding.internal;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.list.ListProperty;
import org.eclipse.emf.databinding.EMFProperties;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.IEMFListProperty;
import org.eclipse.emf.databinding.IEMFValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * 
 */
public class EMFListPropertyDecorator extends ListProperty implements
		IEMFListProperty {
	private final IListProperty delegate;
	private final EStructuralFeature eStructuralFeature;
	
	/**
	 * @param delegate
	 * @param eStructuralFeature
	 */
	public EMFListPropertyDecorator(IListProperty delegate,
			EStructuralFeature eStructuralFeature) {
		this.delegate = delegate;
		this.eStructuralFeature = eStructuralFeature;
	}

	public Object getElementType() {
		return delegate.getElementType();
	}
	
	public IEMFListProperty values(EStructuralFeature feature) {
		return values(FeaturePath.fromList(feature));
	}

	public IEMFListProperty values(FeaturePath featurePath) {
		return values(EMFProperties.value(featurePath));
	}

	public IEMFListProperty values(IEMFValueProperty property) {
		return new EMFListPropertyDecorator(super.values(property), property
				.getStructuralFeature());
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}

	public IObservableList observe(Object source) {
		return new EMFObservableListDecorator(delegate.observe(source),
				eStructuralFeature);
	}

	public IObservableList observe(Realm realm, Object source) {
		return new EMFObservableListDecorator(delegate.observe(realm, source),
				eStructuralFeature);
	}

	public IObservableFactory listFactory() {
		return delegate.listFactory();
	}

	public IObservableFactory listFactory(Realm realm) {
		return delegate.listFactory(realm);
	}

	public IObservableList observeDetail(IObservableValue master) {
		return new EMFObservableListDecorator(delegate.observeDetail(master),
				eStructuralFeature);
	}

	public String toString() {
		return delegate.toString();
	}
}
Index: src/org/eclipse/emf/databinding/internal/EMFObservableListDecorator.java

/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds 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:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bugs 208858, 246625
 ******************************************************************************/

package org.eclipse.emf.databinding.internal;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.list.DecoratingObservableList;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.emf.databinding.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * {@link IEMFObservable} decorator for an {@link IObservableList}.
 * 
 * @since 3.3
 */
public class EMFObservableListDecorator extends DecoratingObservableList
		implements IEMFObservable {
	private EStructuralFeature eStructuralFeature;

	/**
	 * @param decorated
	 * @param eStructuralFeature
	 */
	public EMFObservableListDecorator(IObservableList decorated,
			EStructuralFeature eStructuralFeature) {
		super(decorated, true);
		this.eStructuralFeature = eStructuralFeature;
	}

	public synchronized void dispose() {
		this.eStructuralFeature = null;
		super.dispose();
	}

	public Object getObserved() {
		IObservable decorated = getDecorated();
		if (decorated instanceof IObserving)
			return ((IObserving) decorated).getObserved();
		return null;
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}
}
Index: src/org/eclipse/emf/databinding/internal/Util.java

/*******************************************************************************
 * Copyright (c) 2006 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.emf.databinding.internal;

/**
 * @since 3.3
 * 
 */
public class Util {

	/**
	 * Checks whether the two objects are <code>null</code> -- allowing for
	 * <code>null</code>.
	 * 
	 * @param left
	 *            The left object to compare; may be <code>null</code>.
	 * @param right
	 *            The right object to compare; may be <code>null</code>.
	 * @return <code>true</code> if the two objects are equivalent;
	 *         <code>false</code> otherwise.
	 */
	public static final boolean equals(final Object left, final Object right) {
		return left == null ? right == null : ((right != null) && left
				.equals(right));
	}
}
Index: src/org/eclipse/emf/databinding/internal/EMFValuePropertyDecorator.java

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

package org.eclipse.emf.databinding.internal;

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.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.ValueProperty;
import org.eclipse.emf.databinding.EMFProperties;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.IEMFListProperty;
import org.eclipse.emf.databinding.IEMFMapProperty;
import org.eclipse.emf.databinding.IEMFValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * @since 3.3
 * 
 */
public class EMFValuePropertyDecorator extends ValueProperty implements
		IEMFValueProperty {
	private final IValueProperty delegate;
	private final EStructuralFeature eStructuralFeature;

	/**
	 * @param delegate
	 * @param eStructuralFeature
	 */
	public EMFValuePropertyDecorator(IValueProperty delegate,
			EStructuralFeature eStructuralFeature) {
		this.delegate = delegate;
		this.eStructuralFeature = eStructuralFeature;
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}

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

	public IEMFValueProperty value(EStructuralFeature feature) {
		return value(FeaturePath.fromList(feature));
	}
	
	public IEMFValueProperty value(FeaturePath featurePath) {
		return value(EMFProperties.value(featurePath));
	}
	
	public IEMFValueProperty value(IEMFValueProperty property) {
		return new EMFValuePropertyDecorator(super.value(property), property
				.getStructuralFeature());
	}
	
	public IEMFListProperty list(EStructuralFeature feature) {
		return list(EMFProperties.list(feature));
	}

	public IEMFListProperty list(IEMFListProperty property) {
		return new EMFListPropertyDecorator(super.list(property), property
				.getStructuralFeature());
	}

	public IEMFMapProperty map(EStructuralFeature feature) {
		return map(EMFProperties.map(feature));
	}

	public IEMFMapProperty map(IEMFMapProperty property) {
		return new EMFMapPropertyDecorator(super.map(property), property
				.getStructuralFeature());
	}

	public IObservableValue observe(Object source) {
		return new EMFObservableValueDecorator(delegate.observe(source),
				eStructuralFeature);
	}

	public IObservableValue observe(Realm realm, Object source) {
		return new EMFObservableValueDecorator(delegate.observe(realm, source),
				eStructuralFeature);
	}

	public IObservableFactory valueFactory() {
		return delegate.valueFactory();
	}

	public IObservableFactory valueFactory(Realm realm) {
		return delegate.valueFactory(realm);
	}

	public IObservableValue observeDetail(IObservableValue master) {
		return new EMFObservableValueDecorator(delegate.observeDetail(master),
				eStructuralFeature);
	}

	public IObservableList observeDetail(IObservableList master) {
		return new EMFObservableListDecorator(delegate.observeDetail(master),
				eStructuralFeature);
	}

	public IObservableMap observeDetail(IObservableSet master) {
		return new EMFObservableMapDecorator(delegate.observeDetail(master),
				eStructuralFeature);
	}

	public IObservableMap observeDetail(IObservableMap master) {
		return new EMFObservableMapDecorator(delegate.observeDetail(master),
				eStructuralFeature);
	}

	public String toString() {
		return delegate.toString();
	}
}
Index: src/org/eclipse/emf/databinding/internal/EMFObservableMapDecorator.java

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

package org.eclipse.emf.databinding.internal;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.map.DecoratingObservableMap;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.emf.databinding.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * {@link IEMFObservable} decorator for an {@link IObservableMap}.
 * 
 * @since 3.3
 */
public class EMFObservableMapDecorator extends DecoratingObservableMap
		implements IEMFObservable {
	private EStructuralFeature eStructuralFeature;

	/**
	 * @param decorated
	 * @param eStructuralFeature
	 */
	public EMFObservableMapDecorator(IObservableMap decorated,
			EStructuralFeature eStructuralFeature) {
		super(decorated, true);
		this.eStructuralFeature = eStructuralFeature;
	}

	public synchronized void dispose() {
		this.eStructuralFeature = null;
		super.dispose();
	}

	public Object getObserved() {
		IObservable decorated = getDecorated();
		if (decorated instanceof IObserving)
			return ((IObserving) decorated).getObserved();
		return null;
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}
}
Index: src/org/eclipse/emf/databinding/internal/EMFListProperty.java

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

package org.eclipse.emf.databinding.internal;

import java.util.List;

import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.list.SimpleListProperty;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * 
 */
public class EMFListProperty extends SimpleListProperty {
	private EStructuralFeature eStructuralFeature;

	/**
	 * @param eStructuralFeature
	 */
	public EMFListProperty(EStructuralFeature eStructuralFeature) {
		this.eStructuralFeature = eStructuralFeature;
	}
	
	/**
	 * @return the feature
	 */
	protected EStructuralFeature getFeature() {
		return eStructuralFeature;
	}

	public Object getElementType() {
		return eStructuralFeature;
	}

	protected List<?> doGetList(Object source) {
		EObject eObj = (EObject) source;
		return (List<?>) eObj.eGet(eStructuralFeature);
	}

	@SuppressWarnings("unchecked")
	protected void doSetList(Object source, List list, ListDiff diff) {
		List<?> currentList = doGetList(source);
		diff.applyTo(currentList);
	}

	public INativePropertyListener adaptListener(
			final ISimplePropertyListener listener) {
		return new EMFPropertyListener.EMFListPropertyListener() {

			@Override
			protected EStructuralFeature getFeature() {
				return eStructuralFeature;
			}

			@Override
			protected ISimplePropertyListener getListener() {
				return listener;
			}

			@Override
			protected IProperty getOwner() {
				return EMFListProperty.this;
			}
		};
	}

	public String toString() {
		String s = EMFPropertyHelper.propertyName(eStructuralFeature) + "[]"; //$NON-NLS-1$
		s += "<" + EMFPropertyHelper.shortClassName(eStructuralFeature) + ">"; //$NON-NLS-1$//$NON-NLS-2$
		return s;
	}

}
Index: src/org/eclipse/emf/databinding/IEMFObservable.java

/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds 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:
 *     Brad Reynolds - initial API and implementation
 *     Brad Reynolds - bug 147515
 ******************************************************************************/

package org.eclipse.emf.databinding;

import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * Provides access to details of bean observables.
 * <p>
 * This interface is not meant to be implemented by clients.
 * </p>
 * 
 * @since 3.3
 */
public interface IEMFObservable extends IObserving {
	/**
	 * @return property descriptor of the property being observed,
	 *         <code>null</code> if the runtime time information was not
	 *         provided on construction of the observable
	 */
	public EStructuralFeature getStructuralFeature();
}
Index: src/org/eclipse/emf/databinding/IEMFValueProperty.java

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

package org.eclipse.emf.databinding;

import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * An {@link IValueProperty} extension interface with convenience methods for
 * creating nested features.
 * 
 * @since 1.2
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFValueProperty extends IEMFProperty, IValueProperty {
	/**
	 * Returns a master-detail combination of this property and the specified
	 * nested value feature.
	 * 
	 * @param featurePath
	 *            the nested value property to observe.
	 * @return a master-detail combination of this property and the specified
	 *         nested value feature.
	 * @see #value(IEMFValueProperty)
	 */
	public IEMFValueProperty value(FeaturePath featurePath);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value feature.
	 * 
	 * @param feature
	 *            the nested value property to observe.
	 * @return a master-detail combination of this property and the specified
	 *         value feature.
	 * @see #value(IEMFValueProperty)
	 */
	public IEMFValueProperty value(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property. The returned property will observe the specified detail
	 * value property for the value of the master value property.
	 * <p>
	 * Example:
	 * 
	 * <pre>
	 * // Observes the Node-typed &quot;parent&quot; property of a Node object
	 * IEMFValueProperty parent = EMFProperties.value(MyPackage.Literals.NODE_PARENT);
	 * // Observes the string-typed &quot;name&quot; property of a Node object
	 * IBeanValueProperty name = BeanProperties.value(MyPackage.Literals.NODE_NAME);
	 * // Observes the name of the parent of a Node object.
	 * IBeanValueProperty parentName = parent.value(name);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 */
	public IEMFValueProperty value(IEMFValueProperty property);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * list feature.
	 * 
	 * @param feature
	 *            the list feature to observe
	 * @return a master-detail combination of this property and the specified
	 *         list feature.
	 * @see #list(IEMFListProperty)
	 */
	public IEMFListProperty list(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * list property. The returned property will observe the specified list
	 * property for the value of the master property.
	 * <p>
	 * Example:
	 * 
	 * <pre>
	 * // Observes the Node-typed &quot;parent&quot; property of a Node object.
	 * IEMFValueProperty parent = EMFProperties.value(MyPackage.Literals.NODE_PARENT);
	 * // Observes the List-typed &quot;children&quot; property of a Node object
	 * // where the elements are Node objects
	 * IEMFListProperty children = EMFProperties.list(MyPackage.Literals.NODE_CHILDREN);
	 * // Observes the children of the parent (siblings) of a Node object.
	 * IBeanListProperty siblings = parent.list(children);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         list property.
	 */
	public IEMFListProperty list(IEMFListProperty property);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * map feature.
	 * 
	 * @param feature
	 *            the map property to observe
	 * @return a master-detail combination of this property and the specified
	 *         map feature.
	 * @see #map(IEMFMapProperty)
	 */
	public IEMFMapProperty map(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * map property. The returned property will observe the specified map
	 * property for the value of the master property.
	 * <p>
	 * Example:
	 * 
	 * <pre>
	 * // Observes the Contact-typed &quot;supervisor&quot; property of a
	 * // Contact class 
	 * IEMFValueProperty supervisor = EMFProperties.value(MyPackage.Literals.CONTACT_SUPERVISOR);
	 * // Observes the property &quot;phoneNumbers&quot; of a Contact object--a property mapping
	 * // from PhoneNumberType to PhoneNumber &quot;set-typed &quot;children&quot;,
	 * IEMFMapProperty phoneNumbers = EMFProperties.map(MyPackage.Literals.CONTACT_PHONENUMBERS);
	 * // Observes the phone numbers of a contact's supervisor:
	 * IEMFMapProperty supervisorPhoneNumbers = supervisor.map(phoneNumbers);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         map property.
	 */
	public IEMFMapProperty map(IEMFMapProperty property);
}
Index: src/org/eclipse/emf/databinding/internal/EMFValueProperty.java

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

package org.eclipse.emf.databinding.internal;

import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.value.SimpleValueProperty;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.util.ExtendedMetaData;

/**
 * @since 3.3
 * 
 */
public class EMFValueProperty extends SimpleValueProperty {
	private final EStructuralFeature eStructuralFeature;

	/**
	 * @param eStructuralFeature
	 */
	public EMFValueProperty(EStructuralFeature eStructuralFeature) {
		this.eStructuralFeature = eStructuralFeature;
	}

	public Object getValueType() {
		return eStructuralFeature;
	}
	
	/**
	 * @return the feature
	 */
	protected EStructuralFeature getFeature() {
		return eStructuralFeature;
	}

	protected Object doGetValue(Object source) {
		EObject eObj = (EObject) source;
		return ExtendedMetaData.INSTANCE.getAffiliation(eObj.eClass(), eStructuralFeature) == null ?
				        null : eObj.eGet(eStructuralFeature);
	}

	protected void doSetValue(Object source, Object value) {
		EObject eObject = (EObject) source;
		eObject.eSet(eStructuralFeature, value);
	}

	public INativePropertyListener adaptListener(
			final ISimplePropertyListener listener) {
		return new EMFPropertyListener.EMFValuePropertyListener(){
		
			@Override
			protected IProperty getOwner() {
				return EMFValueProperty.this;
			}
		
			@Override
			protected ISimplePropertyListener getListener() {
				return listener;
			}
		
			@Override
			protected EStructuralFeature getFeature() {
				return eStructuralFeature;
			}
		};
	}

	public String toString() {
		String s = EMFPropertyHelper.propertyName(eStructuralFeature);
		s += "<" + EMFPropertyHelper.shortClassName(eStructuralFeature) + ">"; //$NON-NLS-1$//$NON-NLS-2$
		return s;
	}
}
Index: src/org/eclipse/emf/databinding/internal/EMFObservableValueDecorator.java

/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds 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:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bug 246625
 ******************************************************************************/

package org.eclipse.emf.databinding.internal;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.value.DecoratingObservableValue;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.emf.databinding.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * {@link IEMFObservable} decorator for an {@link IObservableValue}.
 * 
 * @since 3.3
 */
public class EMFObservableValueDecorator extends DecoratingObservableValue
		implements IEMFObservable {
	private EStructuralFeature eStructuralFeature;

	/**
	 * @param decorated
	 * @param eStructuralFeature
	 */
	public EMFObservableValueDecorator(IObservableValue decorated,
			EStructuralFeature eStructuralFeature) {
		super(decorated, true);
		this.eStructuralFeature = eStructuralFeature;
	}

	public synchronized void dispose() {
		this.eStructuralFeature = null;
		super.dispose();
	}

	public Object getObserved() {
		IObservable decorated = getDecorated();
		if (decorated instanceof IObserving)
			return ((IObserving) decorated).getObserved();
		return null;
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}
}
Index: src/org/eclipse/emf/databinding/EMFProperties.java

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

package org.eclipse.emf.databinding;

import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.emf.databinding.internal.EMFListProperty;
import org.eclipse.emf.databinding.internal.EMFListPropertyDecorator;
import org.eclipse.emf.databinding.internal.EMFMapProperty;
import org.eclipse.emf.databinding.internal.EMFMapPropertyDecorator;
import org.eclipse.emf.databinding.internal.EMFValueProperty;
import org.eclipse.emf.databinding.internal.EMFValuePropertyDecorator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * A factory to create property bound attributes for {@link EObject}
 * 
 * @since 1.2
 */
public class EMFProperties {
	/**
	 * Debug constant to turn on/off debugging
	 */
	public static final boolean DEBUG = false;

	/**
	 * Returns a value property for the given {@link EStructuralFeature}
	 * 
	 * @param feature
	 *            the feature instance the property is created for
	 * @return a value property for the given {@link EStructuralFeature}
	 */
	public static IEMFValueProperty value(EStructuralFeature feature) {
		return value(FeaturePath.fromList(feature));
	}

	/**
	 * Returns a value property for the given nested {@link EStructuralFeature}
	 * feature like the <code>name</code> of a <code>person</code>
	 * 
	 * @param featurePath
	 *            path to the feature
	 * @return a value property for the given {@link FeaturePath}
	 */
	public static IEMFValueProperty value(FeaturePath featurePath) {
		IValueProperty property;
		property = new EMFValueProperty(featurePath.getFeaturePath()[0]);

		IEMFValueProperty beanProperty = new EMFValuePropertyDecorator(
				property, featurePath.getFeaturePath()[0]);

		for (int i = 1; i < featurePath.getFeaturePath().length; i++) {
			beanProperty = beanProperty.value(featurePath.getFeaturePath()[i]);
		}

		return beanProperty;
	}

	/**
	 * Returns multiple value properties for the given
	 * {@link EStructuralFeature}s
	 * 
	 * @param features
	 *            the feature instances the properties are created for
	 * @return an array of properties for the given {@link EStructuralFeature}s
	 */
	public static IEMFValueProperty[] values(EStructuralFeature... features) {
		IEMFValueProperty[] properties = new IEMFValueProperty[features.length];
		for (int i = 0; i < properties.length; i++)
			properties[i] = value(features[i]);
		return properties;
	}

	/**
	 * Returns multiple value property for the given nested
	 * {@link EStructuralFeature} features like the <code>name</code> of a
	 * <code>person</code>
	 * 
	 * @param featurePaths
	 *            path to the feature
	 * @return an array of properties for the given {@link FeaturePath}s
	 */
	public static IEMFValueProperty[] values(FeaturePath... featurePaths) {
		IEMFValueProperty[] properties = new IEMFValueProperty[featurePaths.length];
		for (int i = 0; i < properties.length; i++)
			properties[i] = value(featurePaths[i]);
		return properties;
	}

	/**
	 * Returns a list property for the given {@link EStructuralFeature}
	 * 
	 * @param feature
	 *            the feature instance the property is created for
	 * @return a list property for the given {@link EStructuralFeature}
	 */
	public static IEMFListProperty list(EStructuralFeature feature) {
		IListProperty property;
		property = new EMFListProperty(feature);
		return new EMFListPropertyDecorator(property, feature);
	}

	/**
	 * Returns a map property for the given {@link EStructuralFeature}. Objects lacking the named property are treated the same as if the
	 * property always contains an empty map.
	 * 
	 * @param feature
	 *            the feature the property is created for
	 * @return a map property for the given {@link EStructuralFeature}
	 */
	public static IEMFMapProperty map(EStructuralFeature feature) {
		IMapProperty property;
		property = new EMFMapProperty(feature);
		return new EMFMapPropertyDecorator(property, feature);
	}
}
Index: src/org/eclipse/emf/databinding/FeaturePath.java

/*******************************************************************************
 * Copyright (c) 2009 BestSolution.at 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:
 *     Tom Schindl<tom.schindl@bestsolution.at> - initial API and implementation (bug 262160)
 ******************************************************************************/
package org.eclipse.emf.databinding;

import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * Encapsulate a path to features also known as nested feature like person.name
 */
public class FeaturePath {
	private EStructuralFeature[] featurePath;

	private FeaturePath(EStructuralFeature[] featurePath) {
		this.featurePath = featurePath;
	}

	/**
	 * @return the path to the feature from the local position
	 */
	public EStructuralFeature[] getFeaturePath() {
		return featurePath;
	}

	/**
	 * Create a feature path from the list of given features
	 * 
	 * @param featurePath
	 *            the list of feature to go from the local instance to the
	 *            requested instance
	 * @return the path constructed
	 */
	public static FeaturePath fromList(EStructuralFeature... featurePath) {
		return new FeaturePath(featurePath);
	}
}
Index: src/org/eclipse/emf/databinding/IEMFProperty.java

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

package org.eclipse.emf.databinding;

import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * An IProperty extension interface providing access to details of bean
 * properties.
 * 
 * @since 1.2
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFProperty extends IProperty {
	/**
	 * Returns the property descriptor of the bean property being observed. This
	 * method returns null in the case of anonymous properties.
	 * 
	 * @return the property descriptor of the bean property being observed
	 */
	public EStructuralFeature getStructuralFeature();
}
Index: src/org/eclipse/emf/databinding/IEMFListProperty.java

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

package org.eclipse.emf.databinding;

import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * An {@link IListProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.2
 */
public interface IEMFListProperty extends IEMFProperty, IListProperty {
	/**
	 * Returns a master-detail combination of this property and the specified
	 * value nested feature.
	 * 
	 * @param featurePath
	 *            the nested feature to observe
	 * @return a nested combination of this property and the specified nested
	 *         feature.
	 * @see #values(IEMFValueProperty)
	 */
	public IEMFListProperty values(FeaturePath featurePath);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property.
	 * 
	 * @param feature
	 *            the feature
	 * @return a nested combination of this property and the specified nested
	 *         feature.
	 */
	public IEMFListProperty values(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property. The returned property will observe the specified value
	 * property for all elements observed by this list property.
	 * <p>
	 * Example:
	 * 
	 * <pre>
	 * // Observes the list-typed &quot;children&quot; property of a Person object,
	 * // where the elements are Person objects
	 * IEMFListProperty children = EMFProperties
	 * 		.list(MyPackage.Literals.PERSON_CHILDREN);
	 * // Observes the string-typed &quot;name&quot; property of a Person object
	 * IEMFValueProperty name = EMFProperties.value(MyPackage.Literals.PERSON_NAME);
	 * // Observes the names of children of a Person object.
	 * IEMFListProperty childrenNames = children.values(name);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 */
	public IEMFListProperty values(IEMFValueProperty property);
}
Index: src/org/eclipse/emf/databinding/internal/EMFPropertyListener.java

package org.eclipse.emf.databinding.internal;

import java.util.Collection;
import java.util.Map;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * 
 */
public abstract class EMFPropertyListener extends AdapterImpl implements
		INativePropertyListener {

	public void addTo(Object source) {
		((EObject) source).eAdapters().add(this);
	}

	public void removeFrom(Object source) {
		((EObject) source).eAdapters().remove(this);
	}

	@Override
	public abstract void notifyChanged(Notification msg);

	/**
	 * @return the listener
	 */
	protected abstract ISimplePropertyListener getListener();

	/**
	 * @return the feature
	 */
	protected abstract EStructuralFeature getFeature();

	/**
	 * @return the owner property
	 */
	protected abstract IProperty getOwner();

	/**
	 * 
	 */
	public abstract static class EMFListPropertyListener extends
			EMFPropertyListener {
		@Override
		public void notifyChanged(Notification msg) {
			if (getFeature() == msg.getFeature() && !msg.isTouch()) {
				final ListDiff diff;
				switch (msg.getEventType()) {
				case Notification.ADD: {
					diff = Diffs.createListDiff(Diffs.createListDiffEntry(msg
							.getPosition(), true, msg.getNewValue()));
					break;
				}
				case Notification.ADD_MANY: {
					Collection<?> newValues = (Collection<?>) msg.getNewValue();
					ListDiffEntry[] listDiffEntries = new ListDiffEntry[newValues
							.size()];
					int position = msg.getPosition();
					int index = 0;
					for (Object newValue : newValues) {
						listDiffEntries[index++] = Diffs.createListDiffEntry(
								position++, true, newValue);
					}
					diff = Diffs.createListDiff(listDiffEntries);
					break;
				}
				case Notification.REMOVE: {
					diff = Diffs.createListDiff(Diffs.createListDiffEntry(msg
							.getPosition(), false, msg.getOldValue()));
					break;
				}
				case Notification.REMOVE_MANY: {
					Collection<?> oldValues = (Collection<?>) msg.getOldValue();
					ListDiffEntry[] listDiffEntries = new ListDiffEntry[oldValues
							.size()];
					int position = msg.getPosition();
					int index = 0;
					for (Object oldValue : oldValues) {
						listDiffEntries[index++] = Diffs.createListDiffEntry(
								position++, false, oldValue);
					}
					diff = Diffs.createListDiff(listDiffEntries);
					break;
				}
				case Notification.SET:
				case Notification.RESOLVE: {
					ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
					listDiffEntries[0] = Diffs.createListDiffEntry(msg
							.getPosition(), false, msg.getOldValue());
					listDiffEntries[1] = Diffs.createListDiffEntry(msg
							.getPosition(), true, msg.getNewValue());
					diff = Diffs.createListDiff(listDiffEntries);
					break;
				}
				case Notification.MOVE: {
					Object movedValue = msg.getNewValue();
					ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
					listDiffEntries[0] = Diffs.createListDiffEntry(
							(Integer) msg.getOldValue(), false, movedValue);
					listDiffEntries[1] = Diffs.createListDiffEntry(msg
							.getPosition(), true, movedValue);
					diff = Diffs.createListDiff(listDiffEntries);
					break;
				}
				case Notification.UNSET: {
					// This just represents going back to the unset state, but
					// that doesn't affect the contents of the list.
					//
					return;
				}
				default: {
					throw new RuntimeException("unhandled case");
				}
				}
				getListener().handleEvent(
						(new SimplePropertyEvent(SimplePropertyEvent.CHANGE,
								msg.getNotifier(), getOwner(), diff)));
			}
		}
	}

	/**
	 * 
	 */
	public abstract static class EMFMapPropertyListener extends
			EMFPropertyListener {
		@Override
		public void notifyChanged(Notification msg) {
			if (getFeature() == msg.getFeature() && !msg.isTouch()) {
				getListener().handleEvent(
						new SimplePropertyEvent(SimplePropertyEvent.CHANGE, msg
								.getNotifier(), getOwner(), Diffs
								.computeMapDiff((Map<?, ?>) msg.getOldValue(),
										(Map<?, ?>) msg.getNewValue())));
			}
		}
	}

	/**
	 * 
	 */
	public abstract static class EMFValuePropertyListener extends
			EMFPropertyListener {
		@Override
		public void notifyChanged(Notification msg) {
			if (getFeature() == msg.getFeature() && !msg.isTouch()) {
				getListener().handleEvent(
						new SimplePropertyEvent(SimplePropertyEvent.CHANGE, msg
								.getNotifier(), getOwner(), Diffs
								.createValueDiff(msg.getOldValue(), msg
										.getNewValue())));
			}
		}
	}
}
Index: src/org/eclipse/emf/databinding/internal/EMFMapPropertyDecorator.java

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

package org.eclipse.emf.databinding.internal;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.map.MapProperty;
import org.eclipse.emf.databinding.EMFProperties;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.IEMFMapProperty;
import org.eclipse.emf.databinding.IEMFValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * @since 3.3
 * 
 */
public class EMFMapPropertyDecorator extends MapProperty implements
		IEMFMapProperty {
	private final IMapProperty delegate;
	private final EStructuralFeature eStructuralFeature;

	/**
	 * @param delegate
	 * @param eStructuralFeature
	 */
	public EMFMapPropertyDecorator(IMapProperty delegate,
			EStructuralFeature eStructuralFeature) {
		this.delegate = delegate;
		this.eStructuralFeature = eStructuralFeature;
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}

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

	public Object getValueType() {
		return delegate.getValueType();
	}
	
	public IEMFMapProperty values(EStructuralFeature feature) {
		return values(FeaturePath.fromList(feature));
	}

	public IEMFMapProperty values(FeaturePath featurePath) {
		return values(EMFProperties.value(featurePath));
	}

	public IEMFMapProperty values(IEMFValueProperty property) {
		return new EMFMapPropertyDecorator(super.values(property), property
				.getStructuralFeature());
	}

	public IObservableMap observe(Object source) {
		return new EMFObservableMapDecorator(delegate.observe(source),
				eStructuralFeature);
	}

	public IObservableMap observe(Realm realm, Object source) {
		return new EMFObservableMapDecorator(delegate.observe(realm, source),
				eStructuralFeature);
	}

	public IObservableFactory mapFactory() {
		return delegate.mapFactory();
	}

	public IObservableFactory mapFactory(Realm realm) {
		return delegate.mapFactory(realm);
	}

	public IObservableMap observeDetail(IObservableValue master) {
		return new EMFObservableMapDecorator(delegate.observeDetail(master),
				eStructuralFeature);
	}

	public String toString() {
		return delegate.toString();
	}
}
Index: src/org/eclipse/emf/databinding/internal/EMFMapProperty.java

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

package org.eclipse.emf.databinding.internal;

import java.util.Map;

import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.map.SimpleMapProperty;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * 
 */
public class EMFMapProperty extends SimpleMapProperty {
	private EStructuralFeature eStructuralFeature;
	
	/**
	 * @param eStructuralFeature
	 */
	public EMFMapProperty(EStructuralFeature eStructuralFeature) {
		this.eStructuralFeature = eStructuralFeature;
	}

	/**
	 * @return the feature
	 */
	protected EStructuralFeature getFeature() {
		return eStructuralFeature;
	}
	
	public Object getKeyType() {
		final EClass eType = ( EClass ) this.eStructuralFeature.getEType();
		
		for ( final EStructuralFeature feature : eType.getEAllStructuralFeatures() ) {
			if ( feature.getName().equals("key") ) {
				return feature;
			}
		}
		
		return null;
	}
		
	public Object getValueType() {
		final EClass eType = ( EClass ) this.eStructuralFeature.getEType();
		
		for ( final EStructuralFeature feature : eType.getEAllStructuralFeatures() ) {
			if ( feature.getName().equals("value") ) {
				return feature;
			}
		}
		
		return null;
	}


	protected Map<?,?> doGetMap(Object source) {
		EObject eObj = (EObject) source;
	    return (Map<?, ?>) eObj.eGet(eStructuralFeature);
	}

	@SuppressWarnings("unchecked")
	protected void doSetMap(Object source, Map map, MapDiff diff) {
		EObject eObject = (EObject) source;
	    eObject.eSet(eStructuralFeature, map);
	}

	public INativePropertyListener adaptListener(
			final ISimplePropertyListener listener) {
		return new EMFPropertyListener.EMFMapPropertyListener(){
		
			@Override
			protected IProperty getOwner() {
				return EMFMapProperty.this;
			}
		
			@Override
			protected ISimplePropertyListener getListener() {
				return listener;
			}
		
			@Override
			protected EStructuralFeature getFeature() {
				return eStructuralFeature;
			}
		};
	}

	public String toString() {
		String s = EMFPropertyHelper.propertyName(eStructuralFeature) + "{:}"; //$NON-NLS-1$

		s += "<" + EMFPropertyHelper.shortClassName((EStructuralFeature) getKeyType()) + ", " //$NON-NLS-1$ //$NON-NLS-2$
			+ EMFPropertyHelper.shortClassName((EStructuralFeature) getValueType()) + ">"; //$NON-NLS-1$
		return s;
	}
}
#P org.eclipse.emf.databinding.edit

Lines 11-16 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
11	Export-Package: org.eclipse.emf.databinding.edit	11	Export-Package: org.eclipse.emf.databinding.edit
12	Require-Bundle: org.eclipse.core.runtime,	12	Require-Bundle: org.eclipse.core.runtime,
13	org.eclipse.emf.databinding;visibility:=reexport,	13	org.eclipse.emf.databinding;visibility:=reexport,
14	org.eclipse.emf.edit;visibility:=reexport	14	org.eclipse.emf.edit;visibility:=reexport,
		15	org.eclipse.core.databinding.property;bundle-version="1.2.0"
15	Eclipse-LazyStart: true	16	Eclipse-LazyStart: true
16	Bundle-ActivationPolicy: lazy	17	Bundle-ActivationPolicy: lazy




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

package org.eclipse.emf.databinding.edit.internal;

import java.util.Map;

import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.databinding.internal.EMFMapProperty;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * @since 3.3
 * 
 */
public class EMFEditMapProperty extends EMFMapProperty {
	private final EditingDomain editingDomain;
	
	public EMFEditMapProperty(EditingDomain editingDomain, EStructuralFeature eStructuralFeature) {
		super(eStructuralFeature);
		this.editingDomain = editingDomain;
	}

	@SuppressWarnings("unchecked")
	@Override
	protected void doSetMap(Object source, Map map, MapDiff diff) {
		EObject eObject = (EObject) source;
		Command command = SetCommand.create(editingDomain, eObject, getFeature(), map);
		editingDomain.getCommandStack().execute(command);
	}

}




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

package org.eclipse.emf.databinding.edit;

import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.IEMFProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * An {@link IListProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.2
 */
public interface IEMFEditListProperty extends IEMFProperty, IListProperty {
	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property.
	 * 
	 * @param propertyName
	 *            the value property to observe. May be nested e.g.
	 *            "parent.name"
	 * @return a nested combination of this property and the specified value
	 *         property.
	 * @see #values(IEMFEditValueProperty)
	 */
	public IEMFEditListProperty values(FeaturePath featurePath);
	
	public IEMFEditListProperty values(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property. The returned property will observe the specified value
	 * property for all elements observed by this list property.
	 * <p>
	 * Example:
	 * 
	 * <pre>
	 * // Observes the list-typed &quot;children&quot; property of a Person object,
	 * // where the elements are Person objects
	 * IBeanListProperty children = BeanProperties.list(Person.class, &quot;children&quot;,
	 * 		Person.class);
	 * // Observes the string-typed &quot;name&quot; property of a Person object
	 * IBeanValueProperty name = BeanProperties.value(Person.class, &quot;name&quot;);
	 * // Observes the names of children of a Person object.
	 * IBeanListProperty childrenNames = children.values(name);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 */
	public IEMFEditListProperty values(IEMFEditValueProperty property);
}
Index: src/org/eclipse/emf/databinding/edit/IEMFEditMapProperty.java

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

package org.eclipse.emf.databinding.edit;

import java.util.Map;

import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.IEMFProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * An {@link IMapProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.2
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFEditMapProperty extends IEMFProperty, IMapProperty {

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property.
	 * 
	 * @param propertyName
	 *            the value property to observe. May be nested e.g.
	 *            "parent.name"
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 * @see #values(IEMFEditValueProperty)
	 */
	public IEMFEditMapProperty values(FeaturePath featurePath);
	
	public IEMFEditMapProperty values(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property. The returned property will observe the specified value
	 * property for all {@link Map#values() values} observed by this map
	 * property, mapping from this map property's {@link Map#keySet() key set}
	 * to the specified value property's value for each element in the master
	 * property's {@link Map#values() values} collection.
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 */
	public IEMFEditMapProperty values(IEMFEditValueProperty property);
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditObservableMapDecorator.java

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

package org.eclipse.emf.databinding.edit.internal;

import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.emf.databinding.edit.IEMFEditObservable;
import org.eclipse.emf.databinding.internal.EMFObservableMapDecorator;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * {@link IEMFObservable} decorator for an {@link IObservableMap}.
 * 
 * @since 3.3
 */
public class EMFEditObservableMapDecorator extends EMFObservableMapDecorator
		implements IEMFEditObservable {
	private final EditingDomain editingDomain;
	
	/**
	 * @param decorated
	 * @param propertyDescriptor
	 */
	public EMFEditObservableMapDecorator(EditingDomain editingDomain, IObservableMap decorated,
			EStructuralFeature eStructuralFeature) {
		super(decorated, eStructuralFeature);
		this.editingDomain = editingDomain;
	}

	public EditingDomain getEditingDomain() {
		return editingDomain;
	}
}
Index: src/org/eclipse/emf/databinding/edit/IEMFEditObservable.java

/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds 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:
 *     Brad Reynolds - initial API and implementation
 *     Brad Reynolds - bug 147515
 ******************************************************************************/

package org.eclipse.emf.databinding.edit;

import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * Provides access to details of bean observables.
 * <p>
 * This interface is not meant to be implemented by clients.
 * </p>
 * 
 * @since 3.3
 */
public interface IEMFEditObservable extends IObserving {
	/**
	 * @return property descriptor of the property being observed,
	 *         <code>null</code> if the runtime time information was not
	 *         provided on construction of the observable
	 */
	public EStructuralFeature getStructuralFeature();
	
	public EditingDomain getEditingDomain();
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditListPropertyDecorator.java

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

package org.eclipse.emf.databinding.edit.internal;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.list.ListProperty;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.edit.EMFEditProperties;
import org.eclipse.emf.databinding.edit.IEMFEditListProperty;
import org.eclipse.emf.databinding.edit.IEMFEditValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * @since 3.3
 * 
 */
public class EMFEditListPropertyDecorator extends ListProperty implements
		IEMFEditListProperty {
	private final IListProperty delegate;
	private final EStructuralFeature eStructuralFeature;
	private final EditingDomain editingDomain;
	
	/**
	 * @param delegate
	 * @param propertyDescriptor
	 */
	public EMFEditListPropertyDecorator(EditingDomain editingDomain,IListProperty delegate,
			EStructuralFeature eStructuralFeature) {
		this.delegate = delegate;
		this.eStructuralFeature = eStructuralFeature;
		this.editingDomain = editingDomain;
	}

	public Object getElementType() {
		return delegate.getElementType();
	}
	
	public IEMFEditListProperty values(EStructuralFeature feature) {
		return values(FeaturePath.fromList(feature));
	}

	public IEMFEditListProperty values(FeaturePath featurePath) {
		return values(EMFEditProperties.value(editingDomain,featurePath));
	}

	public IEMFEditListProperty values(IEMFEditValueProperty property) {
		return new EMFEditListPropertyDecorator(editingDomain,super.values(property), property
				.getStructuralFeature());
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}

	public IObservableList observe(Object source) {
		return new EMFEditObservableListDecorator(editingDomain,delegate.observe(source),
				eStructuralFeature);
	}

	public IObservableList observe(Realm realm, Object source) {
		return new EMFEditObservableListDecorator(editingDomain,delegate.observe(realm, source),
				eStructuralFeature);
	}

	public IObservableFactory listFactory() {
		return delegate.listFactory();
	}

	public IObservableFactory listFactory(Realm realm) {
		return delegate.listFactory(realm);
	}

	public IObservableList observeDetail(IObservableValue master) {
		return new EMFEditObservableListDecorator(editingDomain,delegate.observeDetail(master),
				eStructuralFeature);
	}

	public String toString() {
		return delegate.toString();
	}
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditValuePropertyDecorator.java

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

package org.eclipse.emf.databinding.edit.internal;

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.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.ValueProperty;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.edit.EMFEditProperties;
import org.eclipse.emf.databinding.edit.IEMFEditListProperty;
import org.eclipse.emf.databinding.edit.IEMFEditMapProperty;
import org.eclipse.emf.databinding.edit.IEMFEditValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * @since 3.3
 * 
 */
public class EMFEditValuePropertyDecorator extends ValueProperty implements
		IEMFEditValueProperty {
	private final IValueProperty delegate;
	private final EStructuralFeature eStructuralFeature;
	private final EditingDomain editingDomain;

	/**
	 * @param delegate
	 * @param propertyDescriptor
	 */
	public EMFEditValuePropertyDecorator(EditingDomain editingDomain,IValueProperty delegate,
			EStructuralFeature eStructuralFeature) {
		this.delegate = delegate;
		this.eStructuralFeature = eStructuralFeature;
		this.editingDomain = editingDomain;
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}

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

	public IEMFEditValueProperty value(EStructuralFeature feature) {
		return value(FeaturePath.fromList(feature));
	}
	
	public IEMFEditValueProperty value(FeaturePath featurePath) {
		return value(EMFEditProperties.value(editingDomain,featurePath));
	}

	public IEMFEditValueProperty value(IEMFEditValueProperty property) {
		return new EMFEditValuePropertyDecorator(editingDomain,super.value(property), property
				.getStructuralFeature());
	}

	public IEMFEditListProperty list(EStructuralFeature feature) {
		return list(EMFEditProperties.list(editingDomain,feature));
	}

	public IEMFEditListProperty list(IEMFEditListProperty property) {
		return new EMFEditListPropertyDecorator(editingDomain,super.list(property), property
				.getStructuralFeature());
	}

	public IEMFEditMapProperty map(EStructuralFeature feature) {
		return map(feature, null, null);
	}

	public IEMFEditMapProperty map(EStructuralFeature feature, Class<?> keyType,
			Class<?> valueType) {
		return map(EMFEditProperties.map(editingDomain,feature, keyType,
				valueType));
	}

	public IEMFEditMapProperty map(IEMFEditMapProperty property) {
		return new EMFEditMapPropertyDecorator(editingDomain,super.map(property), property
				.getStructuralFeature());
	}

	public IObservableValue observe(Object source) {
		return new EMFEditObservableValueDecorator(editingDomain,delegate.observe(source),
				eStructuralFeature);
	}

	public IObservableValue observe(Realm realm, Object source) {
		return new EMFEditObservableValueDecorator(editingDomain,delegate.observe(realm, source),
				eStructuralFeature);
	}

	public IObservableFactory valueFactory() {
		return delegate.valueFactory();
	}

	public IObservableFactory valueFactory(Realm realm) {
		return delegate.valueFactory(realm);
	}

	public IObservableValue observeDetail(IObservableValue master) {
		return new EMFEditObservableValueDecorator(editingDomain,delegate.observeDetail(master),
				eStructuralFeature);
	}

	public IObservableList observeDetail(IObservableList master) {
		return new EMFEditObservableListDecorator(editingDomain,delegate.observeDetail(master),
				eStructuralFeature);
	}

	public IObservableMap observeDetail(IObservableSet master) {
		return new EMFEditObservableMapDecorator(editingDomain,delegate.observeDetail(master),
				eStructuralFeature);
	}

	public IObservableMap observeDetail(IObservableMap master) {
		return new EMFEditObservableMapDecorator(editingDomain,delegate.observeDetail(master),
				eStructuralFeature);
	}

	public String toString() {
		return delegate.toString();
	}
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditObservableValueDecorator.java

/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds 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:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bug 246625
 ******************************************************************************/

package org.eclipse.emf.databinding.edit.internal;

import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.emf.databinding.edit.IEMFEditObservable;
import org.eclipse.emf.databinding.internal.EMFObservableValueDecorator;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * {@link IEMFObservable} decorator for an {@link IObservableValue}.
 * 
 * @since 3.3
 */
public class EMFEditObservableValueDecorator extends EMFObservableValueDecorator
		implements IEMFEditObservable {
	private final EditingDomain editingDomain;
	
	/**
	 * @param decorated
	 * @param propertyDescriptor
	 */
	public EMFEditObservableValueDecorator(EditingDomain editingDomain,IObservableValue decorated,
			EStructuralFeature eStructuralFeature) {
		super(decorated, eStructuralFeature);
		this.editingDomain = editingDomain;
	}

	public EditingDomain getEditingDomain() {
		return editingDomain;
	}

}
Index: src/org/eclipse/emf/databinding/edit/IEMFEditProperty.java

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

package org.eclipse.emf.databinding.edit;

import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * An IProperty extension interface providing access to details of bean
 * properties.
 * 
 * @since 1.2
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFEditProperty extends IProperty {
	/**
	 * Returns the property descriptor of the bean property being observed. This
	 * method returns null in the case of anonymous properties.
	 * 
	 * @return the property descriptor of the bean property being observed
	 */
	public EStructuralFeature getStructuralFeature();
	
	public EditingDomain getEditingDomain();
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditObservableListDecorator.java

/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds 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:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bugs 208858, 246625
 ******************************************************************************/

package org.eclipse.emf.databinding.edit.internal;

import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.emf.databinding.edit.IEMFEditObservable;
import org.eclipse.emf.databinding.internal.EMFObservableListDecorator;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * {@link IEMFObservable} decorator for an {@link IObservableList}.
 * 
 * @since 3.3
 */
public class EMFEditObservableListDecorator extends EMFObservableListDecorator
		implements IEMFEditObservable {
	
	private final EditingDomain editingDomain;

	public EMFEditObservableListDecorator(EditingDomain editingDomain, IObservableList decorated,
			EStructuralFeature eStructuralFeature) {
		super(decorated, eStructuralFeature);
		this.editingDomain = editingDomain;
	}

	public EditingDomain getEditingDomain() {
		return editingDomain;
	}
	
	
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditMapPropertyDecorator.java

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

package org.eclipse.emf.databinding.edit.internal;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.map.MapProperty;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.edit.EMFEditProperties;
import org.eclipse.emf.databinding.edit.IEMFEditMapProperty;
import org.eclipse.emf.databinding.edit.IEMFEditValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * @since 3.3
 * 
 */
public class EMFEditMapPropertyDecorator extends MapProperty implements
		IEMFEditMapProperty {
	private final IMapProperty delegate;
	private final EStructuralFeature eStructuralFeature;
	private final EditingDomain editingDomain;

	/**
	 * @param delegate
	 * @param propertyDescriptor
	 */
	public EMFEditMapPropertyDecorator(EditingDomain editingDomain,IMapProperty delegate,
			EStructuralFeature eStructuralFeature) {
		this.delegate = delegate;
		this.eStructuralFeature = eStructuralFeature;
		this.editingDomain = editingDomain;
	}

	public EStructuralFeature getStructuralFeature() {
		return eStructuralFeature;
	}

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

	public Object getValueType() {
		return delegate.getValueType();
	}
	
	public IEMFEditMapProperty values(EStructuralFeature feature) {
		return values(FeaturePath.fromList(feature));
	}

	public IEMFEditMapProperty values(FeaturePath featurePath) {
		return values(EMFEditProperties.value(editingDomain,featurePath));
	}

	public IEMFEditMapProperty values(IEMFEditValueProperty property) {
		return new EMFEditMapPropertyDecorator(editingDomain,super.values(property), property
				.getStructuralFeature());
	}

	public IObservableMap observe(Object source) {
		return new EMFEditObservableMapDecorator(editingDomain,delegate.observe(source),
				eStructuralFeature);
	}

	public IObservableMap observe(Realm realm, Object source) {
		return new EMFEditObservableMapDecorator(editingDomain,delegate.observe(realm, source),
				eStructuralFeature);
	}

	public IObservableFactory mapFactory() {
		return delegate.mapFactory();
	}

	public IObservableFactory mapFactory(Realm realm) {
		return delegate.mapFactory(realm);
	}

	public IObservableMap observeDetail(IObservableValue master) {
		return new EMFEditObservableMapDecorator(editingDomain,delegate.observeDetail(master),
				eStructuralFeature);
	}

	public String toString() {
		return delegate.toString();
	}
}
Index: src/org/eclipse/emf/databinding/edit/EMFEditProperties.java

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

package org.eclipse.emf.databinding.edit;

import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.edit.internal.EMFEditListProperty;
import org.eclipse.emf.databinding.edit.internal.EMFEditListPropertyDecorator;
import org.eclipse.emf.databinding.edit.internal.EMFEditMapProperty;
import org.eclipse.emf.databinding.edit.internal.EMFEditMapPropertyDecorator;
import org.eclipse.emf.databinding.edit.internal.EMFEditValueProperty;
import org.eclipse.emf.databinding.edit.internal.EMFEditValuePropertyDecorator;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * A factory for creating properties for Java objects that conform to the <a
 * href="http://java.sun.com/products/javabeans/docs/spec.html">JavaBean
 * specification</a> for bound properties.
 * 
 * @since 1.2
 */
public class EMFEditProperties {
	public static final boolean DEBUG = false;

	public static IEMFEditValueProperty value(EditingDomain editingDomain,
			EStructuralFeature feature) {
		return value(editingDomain, FeaturePath.fromList(feature));
	}

	/**
	 * Returns a value property for the given property name of the given bean
	 * class.
	 * 
	 * @param beanClass
	 *            the bean class
	 * @param propertyName
	 *            the property name. May be nested e.g. "parent.name"
	 * @param valueType
	 *            the value type of the returned value property
	 * @return a value property for the given property name of the given bean
	 *         class.
	 */
	public static IEMFEditValueProperty value(EditingDomain editingDomain,
			FeaturePath featurePath) {
		IValueProperty property;
		property = new EMFEditValueProperty(editingDomain, featurePath
				.getFeaturePath()[0]);

		IEMFEditValueProperty beanProperty = new EMFEditValuePropertyDecorator(
				editingDomain, property, featurePath.getFeaturePath()[0]);

		for (int i = 1; i < featurePath.getFeaturePath().length; i++) {
			beanProperty = beanProperty.value(featurePath.getFeaturePath()[i]);
		}

		return beanProperty;
	}

	public static IEMFEditValueProperty[] values(EditingDomain editingDomain,
			EStructuralFeature... features) {
		IEMFEditValueProperty[] properties = new IEMFEditValueProperty[features.length];
		for (int i = 0; i < properties.length; i++)
			properties[i] = value(editingDomain, features[i]);
		return properties;
	}

	/**
	 * Returns a value property array for the given property names of the given
	 * bean class.
	 * 
	 * @param beanClass
	 *            the bean class
	 * @param propertyNames
	 *            array of property names. May be nested e.g. "parent.name"
	 * @return a value property array for the given property names of the given
	 *         bean class.
	 */
	public static IEMFEditValueProperty[] values(EditingDomain editingDomain,
			FeaturePath... featurePaths) {
		IEMFEditValueProperty[] properties = new IEMFEditValueProperty[featurePaths.length];
		for (int i = 0; i < properties.length; i++)
			properties[i] = value(editingDomain, featurePaths[i]);
		return properties;
	}
	
	/**
	 * Returns a list property for the given property name of the given bean
	 * class.
	 * 
	 * @param beanClass
	 *            the bean class
	 * @param propertyName
	 *            the property name
	 * @param elementType
	 *            the element type of the returned list property
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static IEMFEditListProperty list(EditingDomain editingDomain,
			EStructuralFeature feature) {
		IListProperty property;
		property = new EMFEditListProperty(editingDomain, feature);
		return new EMFEditListPropertyDecorator(editingDomain, property,
				feature);
	}

	/**
	 * Returns a map property for the given property name of an arbitrary bean
	 * class. Objects lacking the named property are treated the same as if the
	 * property always contains an empty map.
	 * 
	 * @param propertyName
	 *            the property name
	 * @return a map property for the given property name of an arbitrary bean
	 *         class.
	 */
	public static IEMFEditMapProperty map(EditingDomain editingDomain,
			EStructuralFeature feature) {
		return map(editingDomain, feature, null, null);
	}

	/**
	 * Returns a map property for the given property name of the given bean
	 * class.
	 * 
	 * @param beanClass
	 *            the bean class
	 * @param propertyName
	 *            the property name
	 * @param keyType
	 *            the key type for the returned map property
	 * @param valueType
	 *            the value type for the returned map property
	 * @return a map property for the given property name of the given bean
	 *         class.
	 */
	public static IEMFEditMapProperty map(EditingDomain editingDomain,
			EStructuralFeature feature, Class<?> keyType, Class<?> valueType) {
		IMapProperty property;
		property = new EMFEditMapProperty(editingDomain, feature);
		return new EMFEditMapPropertyDecorator(editingDomain, property, feature);
	}
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditValueProperty.java

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

package org.eclipse.emf.databinding.edit.internal;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.databinding.internal.EMFValueProperty;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * @since 3.3
 * 
 */
public class EMFEditValueProperty extends EMFValueProperty {
	private final EditingDomain editingDomain;

	public EMFEditValueProperty(EditingDomain editingDomain, EStructuralFeature eStructuralFeature) {
		super(eStructuralFeature);
		this.editingDomain = editingDomain;
	}
	
	
	
	@Override
	protected void doSetValue(Object source, Object value) {
		EObject eObject = (EObject) source;
		Command command = SetCommand.create(editingDomain, eObject, getFeature(), value);
		editingDomain.getCommandStack().execute(command);
	}
}




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

package org.eclipse.emf.databinding.edit;

import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.databinding.IEMFProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * An {@link IValueProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.2
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFEditValueProperty extends IEMFProperty, IValueProperty {
	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property.
	 * 
	 * @param propertyName
	 *            the value property to observe. May be nested e.g.
	 *            "parent.name"
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 * @see #value(IEMFEditValueProperty)
	 */
	public IEMFEditValueProperty value(FeaturePath featurePath);

	public IEMFEditValueProperty value(EStructuralFeature feature);
	
	/**
	 * Returns a master-detail combination of this property and the specified
	 * value property. The returned property will observe the specified detail
	 * value property for the value of the master value property.
	 * <p>
	 * Example:
	 * 
	 * <pre>
	 * // Observes the Node-typed &quot;parent&quot; property of a Node object
	 * IBeanValueProperty parent = BeanProperties.value(Node.class, &quot;parent&quot;);
	 * // Observes the string-typed &quot;name&quot; property of a Node object
	 * IBeanValueProperty name = BeanProperties.value(Node.class, &quot;name&quot;);
	 * // Observes the name of the parent of a Node object.
	 * IBeanValueProperty parentName = parent.value(name);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 */
	public IEMFEditValueProperty value(IEMFEditValueProperty property);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * list property.
	 * 
	 * @param propertyName
	 *            the list property to observe
	 * @return a master-detail combination of this property and the specified
	 *         list property.
	 * @see #list(IEMFEditListProperty)
	 */
	public IEMFEditListProperty list(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * list property. The returned property will observe the specified list
	 * property for the value of the master property.
	 * <p>
	 * Example:
	 * 
	 * <pre>
	 * // Observes the Node-typed &quot;parent&quot; property of a Node object.
	 * IBeanValueProperty parent = BeanProperties.value(Node.class, &quot;parent&quot;);
	 * // Observes the List-typed &quot;children&quot; property of a Node object
	 * // where the elements are Node objects
	 * IBeanListProperty children = BeanProperties.list(Node.class, &quot;children&quot;,
	 * 		Node.class);
	 * // Observes the children of the parent (siblings) of a Node object.
	 * IBeanListProperty siblings = parent.list(children);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         list property.
	 */
	public IEMFEditListProperty list(IEMFEditListProperty property);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * map property.
	 * 
	 * @param propertyName
	 *            the map property to observe
	 * @return a master-detail combination of this property and the specified
	 *         map property.
	 * @see #map(IEMFEditMapProperty)
	 */
	public IEMFEditMapProperty map(EStructuralFeature feature);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * map property.
	 * 
	 * @param propertyName
	 *            the map property to observe
	 * @param keyType
	 *            the key type of the named property
	 * @param valueType
	 *            the value type of the named property
	 * @return a master-detail combination of this property and the specified
	 *         map property.
	 * @see #map(IEMFEditMapProperty)
	 */
	public IEMFEditMapProperty map(EStructuralFeature feature, Class<?> keyType,
			Class<?> valueType);

	/**
	 * Returns a master-detail combination of this property and the specified
	 * map property. The returned property will observe the specified map
	 * property for the value of the master property.
	 * <p>
	 * Example:
	 * 
	 * <pre>
	 * // Observes the Contact-typed &quot;supervisor&quot; property of a
	 * // Contact class 
	 * IBeanValueProperty supervisor = BeanProperties.value(Contact.class,
	 * 		&quot;supervisor&quot;);
	 * // Observes the property &quot;phoneNumbers&quot; of a Contact object--a property mapping
	 * // from PhoneNumberType to PhoneNumber &quot;set-typed &quot;children&quot;,
	 * IBeanMapProperty phoneNumbers = BeanProperties.map(Contact.class,
	 * 		&quot;phoneNumbers&quot;, PhoneNumberType.class, PhoneNumber.class);
	 * // Observes the phone numbers of a contact's supervisor:
	 * IBeanMapProperty supervisorPhoneNumbers = supervisor.map(phoneNumbers);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         map property.
	 */
	public IEMFEditMapProperty map(IEMFEditMapProperty property);
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditListProperty.java

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

package org.eclipse.emf.databinding.edit.internal;

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

import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffVisitor;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.databinding.internal.EMFListProperty;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.MoveCommand;
import org.eclipse.emf.edit.command.RemoveCommand;
import org.eclipse.emf.edit.command.ReplaceCommand;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * @since 3.3
 * 
 */
public class EMFEditListProperty extends EMFListProperty {
	private final EditingDomain editingDomain;

	public EMFEditListProperty(EditingDomain editingDomain,
			EStructuralFeature eStructuralFeature) {
		super(eStructuralFeature);
		this.editingDomain = editingDomain;
	}

	@SuppressWarnings("unchecked")
	@Override
	protected void doSetList(Object source, List list, ListDiff diff) {
		diff.accept(new ListVisitorImpl((EObject) source, getFeature()));
	}

	private class ListVisitorImpl extends ListDiffVisitor {
		private EObject eObj;
		private EStructuralFeature feature;

		private ListVisitorImpl(EObject eObj, EStructuralFeature feature) {
			this.eObj = eObj;
			this.feature = feature;
		}

		@Override
		public void handleAdd(int index, Object element) {
			execute(AddCommand.create(editingDomain, eObj, feature, element,
					index));
		}
		
		@Override
		public void handleMove(int oldIndex, int newIndex, Object element) {
			execute(MoveCommand.create(editingDomain, eObj, feature, element, newIndex));
		}
		
		@Override
		public void handleReplace(int index, Object oldElement,
				Object newElement) {
			execute(ReplaceCommand.create(editingDomain,eObj,feature,oldElement,Collections.singleton(newElement)));
		}

		@Override
		public void handleRemove(int index, Object element) {
			execute(RemoveCommand.create(editingDomain, eObj, feature, element));
		}

		private boolean execute(Command command) {
			if (command.canExecute()) {
				editingDomain.getCommandStack().execute(command);
				return true;
			} else {
				return false;
			}
		}
	}
}

Return to bug 262160

Lines 24-86 Link Here

(-)src/org/eclipse/emf/databinding/EMFUpdateListStrategy.java (-56 / +65 lines)
24	import org.eclipse.emf.ecore.EFactory;	24	import org.eclipse.emf.ecore.EFactory;
25		25
26	/**	26	/**
27	* PROVISIONAL	27	* PROVISIONAL This API is subject to arbitrary change, including renaming or
28	* This API is subject to arbitrary change, including renaming or removal.	28	* removal.
29	*/	29	*/
30	public class EMFUpdateListStrategy extends UpdateListStrategy	30	public class EMFUpdateListStrategy extends UpdateListStrategy {
31	{	31	/**
32	public EMFUpdateListStrategy()	32	* A list update strategy with default update policy
33	{	33	* {@link UpdateListStrategy#POLICY_UPDATE} and default converters and
34	this(true, POLICY_UPDATE);	34	* validators
35	}	35	*/
		36	public EMFUpdateListStrategy() {
		37	this(true, POLICY_UPDATE);
		38	}
36		39
37	public EMFUpdateListStrategy(int updatePolicy)	40	/**
38	{	41	* A list update strategy with a specific update policy but with default
39	this(true, updatePolicy);	42	* converters and validators
40	}	43	*
		44	* @param updatePolicy
		45	* the policy
		46	*/
		47	public EMFUpdateListStrategy(int updatePolicy) {
		48	this(true, updatePolicy);
		49	}
41		50
42	public EMFUpdateListStrategy(boolean provideDefaults, int updatePolicy)	51	/**
43	{	52	* A list update strategy with a specific update policy and with the
44	super(provideDefaults, updatePolicy);	53	* possibility to turn of default converters and validators
45	}	54	*
46		55	* @param provideDefaults
47	@Override	56	* <code>false</code> to turn of default converters and
48	protected IConverter createConverter(Object fromType, Object toType)	57	* validators
49	{	58	* @param updatePolicy
50	if (fromType == String.class)	59	* the policy
51	{	60	*/
52	if (toType instanceof EAttribute)	61	public EMFUpdateListStrategy(boolean provideDefaults, int updatePolicy) {
53	{	62	super(provideDefaults, updatePolicy);
54	final EAttribute eAttribute = (EAttribute)toType;	63	}
55	final EDataType eDataType = eAttribute.getEAttributeType();	64
56	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();	65	@Override
57	return	66	protected IConverter createConverter(Object fromType, Object toType) {
58	new Converter(fromType, toType)	67	if (fromType == String.class) {
59	{	68	if (toType instanceof EAttribute) {
60	public Object convert(Object fromObject)	69	final EAttribute eAttribute = (EAttribute) toType;
61	{	70	final EDataType eDataType = eAttribute.getEAttributeType();
62	return eFactory.createFromString(eDataType, (String)fromObject);	71	final EFactory eFactory = eDataType.getEPackage()
63	}	72	.getEFactoryInstance();
64	};	73	return new Converter(fromType, toType) {
65	}	74	public Object convert(Object fromObject) {
66	}	75	return eFactory.createFromString(eDataType,
67	else if (toType == String.class)	76	(String) fromObject);
68	{	77	}
69	if (fromType instanceof EAttribute)	78	};
70	{	79	}
71	final EAttribute eAttribute = (EAttribute)fromType;	80	} else if (toType == String.class) {
72	final EDataType eDataType = eAttribute.getEAttributeType();	81	if (fromType instanceof EAttribute) {
73	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();	82	final EAttribute eAttribute = (EAttribute) fromType;
74	return	83	final EDataType eDataType = eAttribute.getEAttributeType();
75	new Converter(fromType, toType)	84	final EFactory eFactory = eDataType.getEPackage()
76	{	85	.getEFactoryInstance();
77	public Object convert(Object fromObject)	86	return new Converter(fromType, toType) {
78	{	87	public Object convert(Object fromObject) {
79	return eFactory.convertToString(eDataType, fromObject);	88	return eFactory.convertToString(eDataType, fromObject);
80	}	89	}
81	};	90	};
82	}	91	}
83	}	92	}
84	return super.createConverter(fromType, toType);	93	return super.createConverter(fromType, toType);
85	}	94	}
86	}	95	}

Lines 22-51 Link Here

(-)src/org/eclipse/emf/databinding/EMFDataBindingContext.java (-23 / +31 lines)
22	import org.eclipse.core.databinding.observable.value.IObservableValue;	22	import org.eclipse.core.databinding.observable.value.IObservableValue;
23		23
24	/**	24	/**
25	* PROVISIONAL	25	* PROVISIONAL This API is subject to arbitrary change, including renaming or
26	* This API is subject to arbitrary change, including renaming or removal.	26	* removal.
27	*/	27	*/
28	public class EMFDataBindingContext extends DataBindingContext	28	public class EMFDataBindingContext extends DataBindingContext {
29	{	29	/**
30	public EMFDataBindingContext()	30	* Create a new databinding context which uses the default realm for
31	{	31	* validation
32	this(Realm.getDefault());	32	*/
33	}	33	public EMFDataBindingContext() {
		34	this(Realm.getDefault());
		35	}
34		36
35	public EMFDataBindingContext(Realm validationRealm)	37	/**
36	{	38	* Create a databinding context which uses an explicit realm for
37	super(validationRealm);	39	* synchronisation
38	}	40	*
		41	* @param validationRealm
		42	* the realm to use
		43	*/
		44	public EMFDataBindingContext(Realm validationRealm) {
		45	super(validationRealm);
		46	}
39		47
40	@Override	48	@Override
41	protected UpdateValueStrategy createModelToTargetUpdateValueStrategy(IObservableValue fromValue, IObservableValue toValue)	49	protected UpdateValueStrategy createModelToTargetUpdateValueStrategy(
42	{	50	IObservableValue fromValue, IObservableValue toValue) {
43	return new EMFUpdateValueStrategy();	51	return new EMFUpdateValueStrategy();
44	}	52	}
45		53
46	@Override	54	@Override
47	protected UpdateValueStrategy createTargetToModelUpdateValueStrategy(IObservableValue fromValue, IObservableValue toValue)	55	protected UpdateValueStrategy createTargetToModelUpdateValueStrategy(
48	{	56	IObservableValue fromValue, IObservableValue toValue) {
49	return new EMFUpdateValueStrategy();	57	return new EMFUpdateValueStrategy();
50	}	58	}
51	}	59	}

Lines 28-149 Link Here

(-)src/org/eclipse/emf/databinding/EObjectObservableValue.java (-116 / +126 lines)
28	import org.eclipse.emf.ecore.EStructuralFeature;	28	import org.eclipse.emf.ecore.EStructuralFeature;
29		29
30	/**	30	/**
31	* PROVISIONAL	31	* PROVISIONAL This API is subject to arbitrary change, including renaming or
32	* This API is subject to arbitrary change, including renaming or removal.	32	* removal.
33	*/	33	*/
34	public class EObjectObservableValue extends AbstractObservableValue implements IObserving	34	public class EObjectObservableValue extends AbstractObservableValue implements
35	{	35	IObserving {
36	protected EObject eObject;	36	/**
37	protected EStructuralFeature eStructuralFeature;	37	* The object instance
38	protected Adapter listener;	38	*/
39		39	protected EObject eObject;
40	public EObjectObservableValue(EObject eObject, EStructuralFeature eStructuralFeature)	40	/**
41	{	41	* The feature
42	this(Realm.getDefault(), eObject, eStructuralFeature);	42	*/
43	}	43	protected EStructuralFeature eStructuralFeature;
44		44	/**
45	public EObjectObservableValue(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)	45	* The listener
46	{	46	*/
47	super(realm);	47	protected Adapter listener;
48	this.eObject = eObject;	48
49	this.eStructuralFeature = eStructuralFeature;	49	/**
50	}	50	* Observe a feature of the instance using the default realm
51		51	*
52	@Override	52	* @param eObject
53	public synchronized void dispose()	53	* the object
54	{	54	* @param eStructuralFeature
55	if (listener != null)	55	* the feature
56	{	56	*/
57	eObject.eAdapters().remove(listener);	57	public EObjectObservableValue(EObject eObject,
58	listener = null;	58	EStructuralFeature eStructuralFeature) {
59	}	59	this(Realm.getDefault(), eObject, eStructuralFeature);
60	eObject = null;	60	}
61	eStructuralFeature = null;	61
62	super.dispose();	62	/**
63	}	63	* Observe a feature of the instance using the realm
64		64	*
65	public Object getObserved()	65	* @param realm
66	{	66	*
67	return eObject;	67	* @param eObject
68	}	68	* the object
69		69	* @param eStructuralFeature
70	@Override	70	* the feature
71	protected void firstListenerAdded()	71	*/
72	{	72	public EObjectObservableValue(Realm realm, EObject eObject,
73	listener =	73	EStructuralFeature eStructuralFeature) {
74	new AdapterImpl()	74	super(realm);
75	{	75	this.eObject = eObject;
76	@Override	76	this.eStructuralFeature = eStructuralFeature;
77	public void notifyChanged(Notification notification)	77	}
78	{	78
79	if (eStructuralFeature == notification.getFeature() && !notification.isTouch())	79	@Override
80	{	80	public synchronized void dispose() {
81	final ValueDiff diff = Diffs.createValueDiff(notification.getOldValue(), notification.getNewValue());	81	if (listener != null) {
82	getRealm().exec	82	eObject.eAdapters().remove(listener);
83	(new Runnable()	83	listener = null;
84	{	84	}
85	public void run()	85	eObject = null;
86	{	86	eStructuralFeature = null;
87	fireValueChange(diff);	87	super.dispose();
88	}	88	}
89	});	89
90	}	90	public Object getObserved() {
91	}	91	return eObject;
92	};	92	}
93	eObject.eAdapters().add(listener);	93
94	}	94	@Override
95		95	protected void firstListenerAdded() {
96	@Override	96	listener = new AdapterImpl() {
97	protected void lastListenerRemoved()	97	@Override
98	{	98	public void notifyChanged(Notification notification) {
99	eObject.eAdapters().remove(listener);	99	if (eStructuralFeature == notification.getFeature()
100	listener = null;	100	&& !notification.isTouch()) {
101	}	101	final ValueDiff diff = Diffs.createValueDiff(notification
102		102	.getOldValue(), notification.getNewValue());
103	@Override	103	getRealm().exec(new Runnable() {
104	protected Object doGetValue()	104	public void run() {
105	{	105	fireValueChange(diff);
106	return eObject.eGet(eStructuralFeature);	106	}
107	}	107	});
108		108	}
109	@Override	109	}
110	protected void doSetValue(Object value)	110	};
111	{	111	eObject.eAdapters().add(listener);
112	eObject.eSet(eStructuralFeature, value);	112	}
113	}	113
114		114	@Override
115	public Object getValueType()	115	protected void lastListenerRemoved() {
116	{	116	eObject.eAdapters().remove(listener);
117	return eStructuralFeature;	117	listener = null;
118	}	118	}
119		119
120	@Override	120	@Override
121	public String toString()	121	protected Object doGetValue() {
122	{	122	return eObject.eGet(eStructuralFeature);
123	StringBuilder result = new StringBuilder(getClass().getName());	123	}
124	result.append('@');	124
125	result.append(Integer.toHexString(hashCode()));	125	@Override
126		126	protected void doSetValue(Object value) {
127	result.append(" (eObject:");	127	eObject.eSet(eStructuralFeature, value);
128	result.append(eObject);	128	}
129	result.append(")");	129
130		130	public Object getValueType() {
131	result.append(" (eStructuralFeature: ");	131	return eStructuralFeature;
132	result.append(eStructuralFeature);	132	}
133	result.append(")");	133
134		134	@Override
135	try	135	public String toString() {
136	{	136	StringBuilder result = new StringBuilder(getClass().getName());
137	Object value = eObject.eGet(eStructuralFeature, false);	137	result.append('@');
138	result.append(" (value: ");	138	result.append(Integer.toHexString(hashCode()));
139	result.append(value);	139
140	result.append(")");	140	result.append(" (eObject:");
141	}	141	result.append(eObject);
142	catch (Exception exception)	142	result.append(")");
143	{	143
144	// Ignore.	144	result.append(" (eStructuralFeature: ");
145	}	145	result.append(eStructuralFeature);
		146	result.append(")");
		147
		148	try {
		149	Object value = eObject.eGet(eStructuralFeature, false);
		150	result.append(" (value: ");
		151	result.append(value);
		152	result.append(")");
		153	} catch (Exception exception) {
		154	// Ignore.
		155	}
146		156
147	return result.toString();	157	return result.toString();
148	}	158	}
149	}	159	}

Lines 28-98 Link Here

(-)src/org/eclipse/emf/databinding/EObjectObservableMap.java (-66 / +68 lines)
28	import org.eclipse.emf.ecore.util.ExtendedMetaData;	28	import org.eclipse.emf.ecore.util.ExtendedMetaData;
29		29
30	/**	30	/**
31	* PROVISIONAL	31	* PROVISIONAL This API is subject to arbitrary change, including renaming or
32	* This API is subject to arbitrary change, including renaming or removal.	32	* removal.
33	*/	33	*/
34	public class EObjectObservableMap extends ComputedObservableMap	34	public class EObjectObservableMap extends ComputedObservableMap {
35	{	35	/**
36	protected EStructuralFeature eStructuralFeature;	36	* The feature to observe
37		37	*/
38	private Adapter elementListener =	38	protected EStructuralFeature eStructuralFeature;
39	new AdapterImpl()	39
40	{	40	private Adapter elementListener = new AdapterImpl() {
41	@Override	41	@Override
42	public void notifyChanged(Notification notification)	42	public void notifyChanged(Notification notification) {
43	{	43	if (eStructuralFeature == notification.getFeature()
44	if (eStructuralFeature == notification.getFeature() && !notification.isTouch())	44	&& !notification.isTouch()) {
45	{	45	// TODO
46	// TODO	46	// This assumes we only get a SET notification, which isn't a
47	// This assumes we only get a SET notification, which isn't a good assumption.	47	// good assumption.
48	//	48	//
49	final MapDiff diff = Diffs.createMapDiffSingleChange(notification.getNotifier(), notification.getOldValue(), notification.getNewValue());	49	final MapDiff diff = Diffs.createMapDiffSingleChange(
50	getRealm().exec	50	notification.getNotifier(), notification.getOldValue(),
51	(new Runnable()	51	notification.getNewValue());
52	{	52	getRealm().exec(new Runnable() {
53	public void run()	53	public void run() {
54	{	54	fireMapChange(diff);
55	fireMapChange(diff);	55	}
56	}	56	});
57	});	57	}
58	}	58	}
59	}	59	};
60	};	60
61		61	/**
62	public EObjectObservableMap(IObservableSet objects, EStructuralFeature feature)	62	* Create a new observable for the set of features
63	{	63	*
64	super(objects);	64	* @param objects
65	this.eStructuralFeature = feature;	65	* the objects to observe
66	}	66	* @param feature
67		67	* the feature
68	@Override	68	*/
69	protected void hookListener(Object domainElement)	69	public EObjectObservableMap(IObservableSet objects,
70	{	70	EStructuralFeature feature) {
71	((EObject)domainElement).eAdapters().add(elementListener);	71	super(objects);
72	}	72	this.eStructuralFeature = feature;
73		73	}
74	@Override	74
75	protected void unhookListener(Object domainElement)	75	@Override
76	{	76	protected void hookListener(Object domainElement) {
77	((EObject)domainElement).eAdapters().remove(elementListener);	77	((EObject) domainElement).eAdapters().add(elementListener);
78	}	78	}
79		79
80	@Override	80	@Override
81	protected Object doGet(Object key)	81	protected void unhookListener(Object domainElement) {
82	{	82	((EObject) domainElement).eAdapters().remove(elementListener);
83	EObject eObject = (EObject)key;	83	}
84	return	84
85	ExtendedMetaData.INSTANCE.getAffiliation(eObject.eClass(), eStructuralFeature) == null ?	85	@Override
86	null :	86	protected Object doGet(Object key) {
87	eObject.eGet(eStructuralFeature);	87	EObject eObject = (EObject) key;
88	}	88	return ExtendedMetaData.INSTANCE.getAffiliation(eObject.eClass(),
89		89	eStructuralFeature) == null ? null : eObject
90	@Override	90	.eGet(eStructuralFeature);
91	protected Object doPut(Object key, Object value)	91	}
92	{	92
93	EObject eObject = (EObject)key;	93	@Override
94	Object result = eObject.eGet(eStructuralFeature);	94	protected Object doPut(Object key, Object value) {
95	eObject.eSet(eStructuralFeature, value);	95	EObject eObject = (EObject) key;
96	return result;	96	Object result = eObject.eGet(eStructuralFeature);
97	}	97	eObject.eSet(eStructuralFeature, value);
		98	return result;
		99	}
98	}	100	}

Lines 19-24 Link Here

(-)src/org/eclipse/emf/databinding/EMFUpdateValueStrategy.java (-88 / +91 lines)
19	import java.util.ArrayList;	19	import java.util.ArrayList;
20	import java.util.List;	20	import java.util.List;
21		21
		22	import org.eclipse.core.databinding.UpdateListStrategy;
22	import org.eclipse.core.databinding.UpdateValueStrategy;	23	import org.eclipse.core.databinding.UpdateValueStrategy;
23	import org.eclipse.core.databinding.conversion.Converter;	24	import org.eclipse.core.databinding.conversion.Converter;
24	import org.eclipse.core.databinding.conversion.IConverter;	25	import org.eclipse.core.databinding.conversion.IConverter;
Lines 27-121 Link Here
27	import org.eclipse.emf.ecore.EFactory;	28	import org.eclipse.emf.ecore.EFactory;
28		29
29	/**	30	/**
30	* PROVISIONAL	31	* PROVISIONAL This API is subject to arbitrary change, including renaming or
31	* This API is subject to arbitrary change, including renaming or removal.	32	* removal.
32	*/	33	*/
33	public class EMFUpdateValueStrategy extends UpdateValueStrategy	34	public class EMFUpdateValueStrategy extends UpdateValueStrategy {
34	{	35	/**
35	public EMFUpdateValueStrategy()	36	* A value update strategy with default update policy
36	{	37	* {@link UpdateListStrategy#POLICY_UPDATE} and default converters and
37	this(true, POLICY_UPDATE);	38	* validators
38	}	39	*/
		40	public EMFUpdateValueStrategy() {
		41	this(true, POLICY_UPDATE);
		42	}
39		43
40	public EMFUpdateValueStrategy(int updatePolicy)	44	/**
41	{	45	* A list value strategy with a specific update policy but with default
42	this(true, updatePolicy);	46	* converters and validators
43	}	47	*
		48	* @param updatePolicy
		49	* the policy
		50	*/
		51	public EMFUpdateValueStrategy(int updatePolicy) {
		52	this(true, updatePolicy);
		53	}
44		54
45	public EMFUpdateValueStrategy(boolean provideDefaults, int updatePolicy)	55	/**
46	{	56	* A list value strategy with a specific update policy and with the
47	super(provideDefaults, updatePolicy);	57	* possibility to turn of default converters and validators
48	}	58	*
49		59	* @param provideDefaults
50	@Override	60	* <code>false</code> to turn of default converters and
51	protected IConverter createConverter(Object fromType, Object toType)	61	* validators
52	{	62	* @param updatePolicy
53	if (fromType == String.class)	63	* the policy
54	{	64	*/
55	if (toType instanceof EAttribute)	65	public EMFUpdateValueStrategy(boolean provideDefaults, int updatePolicy) {
56	{	66	super(provideDefaults, updatePolicy);
57	final EAttribute eAttribute = (EAttribute)toType;	67	}
58	final EDataType eDataType = eAttribute.getEAttributeType();	68
59	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();	69	@Override
60	return	70	protected IConverter createConverter(Object fromType, Object toType) {
61	new Converter(fromType, toType)	71	if (fromType == String.class) {
62	{	72	if (toType instanceof EAttribute) {
63	public Object convert(Object fromObject)	73	final EAttribute eAttribute = (EAttribute) toType;
64	{	74	final EDataType eDataType = eAttribute.getEAttributeType();
65	String value = fromObject == null ? null : fromObject.toString();	75	final EFactory eFactory = eDataType.getEPackage()
66	if (eAttribute.isMany())	76	.getEFactoryInstance();
67	{	77	return new Converter(fromType, toType) {
68	List<Object> result = new ArrayList<Object>();	78	public Object convert(Object fromObject) {
69	if (value != null)	79	String value = fromObject == null ? null : fromObject
70	{	80	.toString();
71	for (String element : value.split(" "))	81	if (eAttribute.isMany()) {
72	{	82	List<Object> result = new ArrayList<Object>();
73	result.add(eFactory.createFromString(eDataType, element));	83	if (value != null) {
74	}	84	for (String element : value.split(" ")) {
75	}	85	result.add(eFactory.createFromString(
76	return result;	86	eDataType, element));
77	}	87	}
78	else	88	}
79	{	89	return result;
80	return eFactory.createFromString(eDataType, value);	90	} else {
81	}	91	return eFactory.createFromString(eDataType, value);
82	}	92	}
83	};	93	}
84	}	94	};
85	}	95	}
86	else if (toType == String.class)	96	} else if (toType == String.class) {
87	{	97	if (fromType instanceof EAttribute) {
88	if (fromType instanceof EAttribute)	98	final EAttribute eAttribute = (EAttribute) fromType;
89	{	99	final EDataType eDataType = eAttribute.getEAttributeType();
90	final EAttribute eAttribute = (EAttribute)fromType;	100	final EFactory eFactory = eDataType.getEPackage()
91	final EDataType eDataType = eAttribute.getEAttributeType();	101	.getEFactoryInstance();
92	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();	102	return new Converter(fromType, toType) {
93	return	103	public Object convert(Object fromObject) {
94	new Converter(fromType, toType)	104	if (eAttribute.isMany()) {
95	{	105	StringBuilder result = new StringBuilder();
96	public Object convert(Object fromObject)	106	for (Object value : (List<?>) fromObject) {
97	{	107	if (result.length() == 0) {
98	if (eAttribute.isMany())	108	result.append(' ');
99	{	109	}
100	StringBuilder result = new StringBuilder();	110	result.append(eFactory.convertToString(
101	for (Object value : (List<?>)fromObject)	111	eDataType, value));
102	{	112	}
103	if (result.length() == 0)	113	return result.toString();
104	{	114	} else {
105	result.append(' ');	115	return eFactory.convertToString(eDataType,
106	}	116	fromObject);
107	result.append(eFactory.convertToString(eDataType, value));	117	}
108	}	118	}
109	return result.toString();	119	};
110	}	120	}
111	else	121	}
112	{	122	return super.createConverter(fromType, toType);
113	return eFactory.convertToString(eDataType, fromObject);	123	}
114	}
115	}
116	};
117	}
118	}
119	return super.createConverter(fromType, toType);
120	}
121	}	124	}

Added Link Here

(-)src/org/eclipse/emf/databinding/IEMFMapProperty.java (+477 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 195222)
10	******************************************************************************/
11
12	package org.eclipse.emf.databinding;
13
14	import java.util.Map;
15
16	import org.eclipse.core.databinding.property.map.IMapProperty;
17	import org.eclipse.emf.ecore.EStructuralFeature;
18
19	/**
20	* An {@link IMapProperty} extension interface with convenience methods for
21	* creating nested bean properties.
22	*
23	* @since 1.2
24	* @noextend This interface is not intended to be extended by clients.
25	* @noimplement This interface is not intended to be implemented by clients.
26	*/
27	public interface IEMFMapProperty extends IEMFProperty, IMapProperty {
28
29	/**
30	* Returns a master-detail combination of this property and the specified
31	* nested value feature.
32	*
33	* @param featurePath
34	* the nested value feature to observe
35	* @return a master-detail combination of this property and the specified
36	* nested value feature.
37	* @see #values(IEMFValueProperty)
38	*/
39	public IEMFMapProperty values(FeaturePath featurePath);
40
41	/**
42	* Returns a master-detail combination of this property and the specified
43	* value feature.
44	*
45	* @param feature
46	* the value feature to observe
47	* @return a master-detail combination of this property and the specified
48	* nested value feature.
49	* @see #values(IEMFValueProperty)
50	*/
51	public IEMFMapProperty values(EStructuralFeature feature);
52
53	/**
54	* Returns a master-detail combination of this property and the specified
55	* value property. The returned property will observe the specified value
56	* property for all {@link Map#values() values} observed by this map
57	* property, mapping from this map property's {@link Map#keySet() key set}
58	* to the specified value property's value for each element in the master
59	* property's {@link Map#values() values} collection.
60	*
61	* @param property
62	* the detail property to observe
63	* @return a master-detail combination of this property and the specified
64	* value property.
65	*/
66	public IEMFMapProperty values(IEMFValueProperty property);
67	} Index: src/org/eclipse/emf/databinding/internal/EMFPropertyHelper.java
Added Link Here
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 194734)
10	* Martin Frey <martin.frey@logica.com> - bug 256150
11	* Matthew Hall - bug 264307
12	******************************************************************************/
13
14	package org.eclipse.emf.databinding.internal;
15
16	import org.eclipse.emf.ecore.EStructuralFeature;
17
18	/**
19	* @since 1.2
20	*
21	*/
22	public class EMFPropertyHelper {
23
24
25	/**
26	* @param eStructuralFeature
27	* @return String description of property descriptor
28	*/
29	public static String propertyName(EStructuralFeature eStructuralFeature) {
30	return eStructuralFeature.getEContainingClass().getName()
31	+ "." + eStructuralFeature.getName() + ""; //$NON-NLS-1$ //$NON-NLS-2$
32	}
33
34	/**
35	* @param eStructuralFeature
36	* @return class name excluding package
37	*/
38	public static String shortClassName(EStructuralFeature eStructuralFeature) {
39	return eStructuralFeature.getEType().getName();
40	}
41	} Index: src/org/eclipse/emf/databinding/internal/EWritableList.java
Added Link Here
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2007 BestSolution.at and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* Tom Schindl<tom.schindl@bestsolution.at> - Initial API and implementation
12	*
13	* </copyright>
14	*
15	* $Id: $
16	*/
17	package org.eclipse.emf.databinding.internal;
18
19	import java.util.Collection;
20	import java.util.Iterator;
21	import java.util.List;
22	import java.util.ListIterator;
23
24	import org.eclipse.core.databinding.observable.Diffs;
25	import org.eclipse.core.databinding.observable.ObservableTracker;
26	import org.eclipse.core.databinding.observable.Realm;
27	import org.eclipse.core.databinding.observable.list.AbstractObservableList;
28	import org.eclipse.core.databinding.observable.list.IObservableList;
29	import org.eclipse.core.databinding.observable.list.ListDiff;
30	import org.eclipse.core.databinding.observable.list.ListDiffEntry;
31	import org.eclipse.emf.common.notify.Adapter;
32	import org.eclipse.emf.common.notify.Notification;
33	import org.eclipse.emf.common.notify.Notifier;
34	import org.eclipse.emf.common.notify.NotifyingList;
35	import org.eclipse.emf.common.notify.impl.AdapterImpl;
36	import org.eclipse.emf.ecore.resource.Resource;
37
38	/**
39	* Writable list which can be used to observe an {@link NotifyingList}
40	*
41	* @param <Type>
42	*/
43	public class EWritableList<Type> extends AbstractObservableList implements
44	IObservableList {
45	private NotifyingList<Type> wrappedList;
46	private Object elementType;
47	private boolean stale = false;
48
49	private class Listener extends AdapterImpl {
50	private Object feature;
51
52	public Listener(Object feature) {
53	this.feature = feature;
54	}
55
56	@Override
57	public void notifyChanged(Notification msg) {
58
59	if (feature == null
60	&& msg.getFeature() == null
61	&& msg.getFeatureID(Resource.class) != Resource.RESOURCE__CONTENTS) {
62	return;
63	}
64
65	if (feature == msg.getFeature() && !msg.isTouch()) {
66	final ListDiff diff;
67	switch (msg.getEventType()) {
68	case Notification.ADD: {
69	diff = Diffs.createListDiff(Diffs.createListDiffEntry(msg
70	.getPosition(), true, msg.getNewValue()));
71	// fireListChange(diff);
72	break;
73	}
74	case Notification.ADD_MANY: {
75	Collection<?> newValues = (Collection<?>) msg.getNewValue();
76	ListDiffEntry[] listDiffEntries = new ListDiffEntry[newValues
77	.size()];
78	int position = msg.getPosition();
79	int index = 0;
80	for (Object newValue : newValues) {
81	listDiffEntries[index++] = Diffs.createListDiffEntry(
82	position++, true, newValue);
83	}
84	diff = Diffs.createListDiff(listDiffEntries);
85	// fireListChange(diff);
86	break;
87	}
88	case Notification.REMOVE: {
89	diff = Diffs.createListDiff(Diffs.createListDiffEntry(msg
90	.getPosition(), false, msg.getOldValue()));
91	// fireListChange(diff);
92	break;
93	}
94	case Notification.REMOVE_MANY: {
95	Collection<?> oldValues = (Collection<?>) msg.getOldValue();
96	ListDiffEntry[] listDiffEntries = new ListDiffEntry[oldValues
97	.size()];
98	int position = msg.getPosition();
99	int index = 0;
100	for (Object oldValue : oldValues) {
101	listDiffEntries[index++] = Diffs.createListDiffEntry(
102	position++, false, oldValue);
103	}
104	diff = Diffs.createListDiff(listDiffEntries);
105	// fireListChange(diff);
106	break;
107	}
108	case Notification.MOVE: {
109	Object movedValue = msg.getNewValue();
110	ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
111	listDiffEntries[0] = Diffs.createListDiffEntry(
112	(Integer) msg.getOldValue(), false, movedValue);
113	listDiffEntries[1] = Diffs.createListDiffEntry(msg
114	.getPosition(), true, movedValue);
115	diff = Diffs.createListDiff(listDiffEntries);
116	// fireListChange(diff);
117	break;
118	}
119	case Notification.UNSET: {
120	// This just represents going back to the unset state, but
121	// that doesn't affect the contents of the list.
122	//
123	return;
124	}
125	default: {
126	throw new RuntimeException("unhandled case");
127	}
128	}
129
130	getRealm().exec(new Runnable() {
131	public void run() {
132	fireListChange(diff);
133	}
134	});
135
136	// System.err.println("CHANGE: " +
137	// diff.getDifferences()[0].getElement());
138
139	// fireListChange(diff);
140	// listener.handlePropertyChange(new SimplePropertyEvent(msg
141	// .getNotifier(), EMFListProperty.this, diff));
142	}
143	}
144
145	}
146
147	private Adapter listener;
148
149	/**
150	* New writable list wrapping the {@link NotifyingList}
151	*
152	* @param wrappedList
153	* the wrapped list
154	*/
155	public EWritableList(NotifyingList<Type> wrappedList) {
156	this(Realm.getDefault(), wrappedList);
157	}
158
159	/**
160	* New writable list wrapping the {@link NotifyingList} and using the
161	* {@link Realm}
162	*
163	* @param realm
164	* the realm
165	* @param wrappedList
166	* the wrapped list
167	*/
168	public EWritableList(Realm realm, NotifyingList<Type> wrappedList) {
169	this(realm, wrappedList, null);
170	}
171
172	/**
173	* New writable list wrapping the {@link NotifyingList}
174	*
175	* @param realm
176	* the realm
177	* @param wrappedList
178	* the wrapped list
179	* @param elementType
180	* the element type
181	*/
182	public EWritableList(Realm realm, NotifyingList<Type> wrappedList,
183	Class<Type> elementType) {
184	super(realm);
185	this.wrappedList = wrappedList;
186	this.elementType = elementType;
187	}
188
189	@Override
190	protected void firstListenerAdded() {
191	if (wrappedList.getNotifier() instanceof Notifier) {
192	Notifier notifier = (Notifier) wrappedList.getNotifier();
193	listener = new Listener(wrappedList.getFeature());
194	notifier.eAdapters().add(listener);
195	} else {
196	throw new IllegalArgumentException(
197	"Wrapped list must have a notifier attached!");
198	}
199	}
200
201	@Override
202	protected void lastListenerRemoved() {
203	if (wrappedList.getNotifier() instanceof Notifier) {
204	Notifier notifier = (Notifier) wrappedList.getNotifier();
205	listener = new Listener(wrappedList.getFeature());
206	notifier.eAdapters().remove(listener);
207	} else {
208	throw new IllegalArgumentException(
209	"Wrapped list must have a notifier attached!");
210	}
211	}
212
213	@Override
214	public synchronized void dispose() {
215	super.dispose();
216	}
217
218	private void getterCalled() {
219	ObservableTracker.getterCalled(this);
220	}
221
222	@SuppressWarnings("unchecked")
223	public boolean add(Object o) {
224	checkRealm();
225	return wrappedList.add((Type) o);
226	}
227
228	@SuppressWarnings("unchecked")
229	public boolean addAll(Collection c) {
230	checkRealm();
231	return wrappedList.addAll(c);
232	}
233
234	@SuppressWarnings("unchecked")
235	public boolean addAll(int index, Collection c) {
236	checkRealm();
237	return wrappedList.addAll(index, c);
238	}
239
240	public boolean contains(Object o) {
241	getterCalled();
242	return wrappedList.contains(o);
243	}
244
245	@SuppressWarnings("unchecked")
246	public boolean containsAll(Collection c) {
247	getterCalled();
248	return wrappedList.containsAll(c);
249	}
250
251	public Object get(int index) {
252	getterCalled();
253	return wrappedList.get(index);
254	}
255
256	public Object getElementType() {
257	checkRealm();
258	return elementType;
259	}
260
261	public int indexOf(Object o) {
262	getterCalled();
263	return wrappedList.indexOf(o);
264	}
265
266	public boolean isEmpty() {
267	getterCalled();
268	return wrappedList.isEmpty();
269	}
270
271	public Iterator<Type> iterator() {
272	getterCalled();
273	return wrappedList.iterator();
274	}
275
276	public int lastIndexOf(Object o) {
277	getterCalled();
278	return wrappedList.lastIndexOf(o);
279	}
280
281	public ListIterator<Type> listIterator() {
282	getterCalled();
283	return wrappedList.listIterator();
284	}
285
286	public ListIterator<Type> listIterator(int index) {
287	getterCalled();
288	return wrappedList.listIterator(index);
289	}
290
291	public Object move(int oldIndex, int newIndex) {
292	checkRealm();
293	return wrappedList.move(oldIndex, newIndex);
294	}
295
296	public boolean remove(Object o) {
297	checkRealm();
298	return wrappedList.remove(o);
299	}
300
301	public Object remove(int index) {
302	checkRealm();
303	return wrappedList.remove(index);
304	}
305
306	@SuppressWarnings("unchecked")
307	public boolean removeAll(Collection c) {
308	checkRealm();
309	return wrappedList.removeAll(c);
310	}
311
312	@SuppressWarnings("unchecked")
313	public boolean retainAll(Collection c) {
314	checkRealm();
315	return wrappedList.retainAll(c);
316	}
317
318	@SuppressWarnings("unchecked")
319	public Object set(int index, Object element) {
320	checkRealm();
321	return wrappedList.set(index, (Type) element);
322	}
323
324	public int doGetSize() {
325	getterCalled();
326	return wrappedList.size();
327	}
328
329	public List<Type> subList(int fromIndex, int toIndex) {
330	getterCalled();
331	return wrappedList.subList(fromIndex, toIndex);
332	}
333
334	public Object[] toArray() {
335	getterCalled();
336	return wrappedList.toArray();
337	}
338
339	public Object[] toArray(Object[] a) {
340	getterCalled();
341	return wrappedList.toArray();
342	}
343
344	@SuppressWarnings("unchecked")
345	public void add(int index, Object element) {
346	checkRealm();
347	wrappedList.add(index, (Type) element);
348	}
349
350	public void clear() {
351	checkRealm();
352	wrappedList.clear();
353	}
354
355	public boolean isStale() {
356	getterCalled();
357	return stale;
358	}
359
360	// public void setStale(boolean stale) {
361	// checkRealm();
362	//
363	// boolean wasStale = this.stale;
364	// this.stale = stale;
365	// if (!wasStale && stale) {
366	// fireStale();
367	// }
368	// }
369	}

Added Link Here

(-)src/org/eclipse/emf/databinding/edit/internal/EMFEditMapProperty.java (+45 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 194734)
10	* Matthew Hall - bugs 195222, 264307, 265561
11	******************************************************************************/
12
13	package org.eclipse.emf.databinding.edit.internal;
14
15	import java.util.Map;
16
17	import org.eclipse.core.databinding.observable.map.MapDiff;
18	import org.eclipse.emf.common.command.Command;
19	import org.eclipse.emf.databinding.internal.EMFMapProperty;
20	import org.eclipse.emf.ecore.EObject;
21	import org.eclipse.emf.ecore.EStructuralFeature;
22	import org.eclipse.emf.edit.command.SetCommand;
23	import org.eclipse.emf.edit.domain.EditingDomain;
24
25	/**
26	* @since 3.3
27	*
28	*/
29	public class EMFEditMapProperty extends EMFMapProperty {
30	private final EditingDomain editingDomain;
31
32	public EMFEditMapProperty(EditingDomain editingDomain, EStructuralFeature eStructuralFeature) {
33	super(eStructuralFeature);
34	this.editingDomain = editingDomain;
35	}
36
37	@SuppressWarnings("unchecked")
38	@Override
39	protected void doSetMap(Object source, Map map, MapDiff diff) {
40	EObject eObject = (EObject) source;
41	Command command = SetCommand.create(editingDomain, eObject, getFeature(), map);
42	editingDomain.getCommandStack().execute(command);
43	}
44
45	}