Attachment #136365 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.EDataType;
import org.eclipse.emf.ecore.EFactory;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 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)
  {

        final EAttribute eAttribute = (EAttribute)toType;
        final EDataType eDataType = eAttribute.getEAttributeType();
        final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();
        return new Converter(fromType, toType)
          new Converter(fromType, toType)
          {
            public Object convert(Object fromObject)
            {

        final EAttribute eAttribute = (EAttribute)fromType;
        final EDataType eDataType = eAttribute.getEAttributeType();
        final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();
        return new Converter(fromType, toType)
          new Converter(fromType, toType)
          {
            public Object convert(Object fromObject)
            {





import org.eclipse.emf.common.util.ResourceLocator;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * This is the central singleton for the Data Binding plugin.
 */
public final class DataBindingPlugin extends EMFPlugin

   */
  public DataBindingPlugin()
  {
    super(new ResourceLocator []{});
  }

  /**

Lines 26-47 Link Here

(-)src/org/eclipse/emf/databinding/EObjectObservableValue.java (-13 / +40 lines)
26	import org.eclipse.emf.common.notify.impl.AdapterImpl;	26	import org.eclipse.emf.common.notify.impl.AdapterImpl;
27	import org.eclipse.emf.ecore.EObject;	27	import org.eclipse.emf.ecore.EObject;
28	import org.eclipse.emf.ecore.EStructuralFeature;	28	import org.eclipse.emf.ecore.EStructuralFeature;
		29	import org.eclipse.emf.ecore.util.ExtendedMetaData;
		30
29		31
30	/**	32	/**
31	* PROVISIONAL	33	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
32	* This API is subject to arbitrary change, including renaming or removal.	34	* @deprecated do not use this value it will be removed in 2.6
33	*/	35	*/
34	public class EObjectObservableValue extends AbstractObservableValue implements IObserving	36	public class EObjectObservableValue extends AbstractObservableValue implements IObserving
35	{	37	{
		38	/**
		39	* The object instance
		40	*/
36	protected EObject eObject;	41	protected EObject eObject;
		42	/**
		43	* The feature
		44	*/
37	protected EStructuralFeature eStructuralFeature;	45	protected EStructuralFeature eStructuralFeature;
		46	/**
		47	* The listener
		48	*/
38	protected Adapter listener;	49	protected Adapter listener;
39		50
		51	/**
		52	* Observe a feature of the instance using the default realm
		53	*
		54	* @param eObject
		55	* the object
		56	* @param eStructuralFeature
		57	* the feature
		58	*/
40	public EObjectObservableValue(EObject eObject, EStructuralFeature eStructuralFeature)	59	public EObjectObservableValue(EObject eObject, EStructuralFeature eStructuralFeature)
41	{	60	{
42	this(Realm.getDefault(), eObject, eStructuralFeature);	61	this(Realm.getDefault(), eObject, eStructuralFeature);
43	}	62	}
44		63
		64	/**
		65	* Observe a feature of the instance using the realm
		66	*
		67	* @param realm
		68	*
		69	* @param eObject
		70	* the object
		71	* @param eStructuralFeature
		72	* the feature
		73	*/
45	public EObjectObservableValue(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)	74	public EObjectObservableValue(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)
46	{	75	{
47	super(realm);	76	super(realm);
Lines 70-77 Link Here
70	@Override	99	@Override
71	protected void firstListenerAdded()	100	protected void firstListenerAdded()
72	{	101	{
73	listener =	102	listener = new AdapterImpl()
74	new AdapterImpl()
75	{	103	{
76	@Override	104	@Override
77	public void notifyChanged(Notification notification)	105	public void notifyChanged(Notification notification)
Lines 79-92 Link Here
79	if (eStructuralFeature == notification.getFeature() && !notification.isTouch())	107	if (eStructuralFeature == notification.getFeature() && !notification.isTouch())
80	{	108	{
81	final ValueDiff diff = Diffs.createValueDiff(notification.getOldValue(), notification.getNewValue());	109	final ValueDiff diff = Diffs.createValueDiff(notification.getOldValue(), notification.getNewValue());
82	getRealm().exec	110	getRealm().exec(new Runnable()
83	(new Runnable()	111	{
84	{	112	public void run()
85	public void run()	113	{
86	{	114	fireValueChange(diff);
87	fireValueChange(diff);	115	}
88	}	116	});
89	});
90	}	117	}
91	}	118	}
92	};	119	};
Lines 103-109 Link Here
103	@Override	130	@Override
104	protected Object doGetValue()	131	protected Object doGetValue()
105	{	132	{
106	return eObject.eGet(eStructuralFeature);	133	return ExtendedMetaData.INSTANCE.getAffiliation(eObject.eClass(), eStructuralFeature) == null ? null : eObject.eGet(eStructuralFeature);
107	}	134	}
108		135
109	@Override	136	@Override

Lines 21-37 Link Here

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

Lines 17-23 Link Here

(-)src/org/eclipse/emf/databinding/EMFObservables.java (-11 / +32 lines)
17	*/	17	*/
18	package org.eclipse.emf.databinding;	18	package org.eclipse.emf.databinding;
19		19
20
21	import org.eclipse.core.databinding.observable.IObservable;	20	import org.eclipse.core.databinding.observable.IObservable;
22	import org.eclipse.core.databinding.observable.Realm;	21	import org.eclipse.core.databinding.observable.Realm;
23	import org.eclipse.core.databinding.observable.list.IObservableList;	22	import org.eclipse.core.databinding.observable.list.IObservableList;
Lines 26-37 Link Here
26	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;	25	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
27	import org.eclipse.core.databinding.observable.set.IObservableSet;	26	import org.eclipse.core.databinding.observable.set.IObservableSet;
28	import org.eclipse.core.databinding.observable.value.IObservableValue;	27	import org.eclipse.core.databinding.observable.value.IObservableValue;
		28	import org.eclipse.emf.common.notify.NotifyingList;
		29	import org.eclipse.emf.databinding.internal.EWritableList;
29	import org.eclipse.emf.ecore.EObject;	30	import org.eclipse.emf.ecore.EObject;
30	import org.eclipse.emf.ecore.EStructuralFeature;	31	import org.eclipse.emf.ecore.EStructuralFeature;
		32	import org.eclipse.emf.ecore.resource.Resource;
		33
31		34
32	/**	35	/**
33	* PROVISIONAL	36	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
34	* This API is subject to arbitrary change, including renaming or removal.
35	*/	37	*/
36	public class EMFObservables	38	public class EMFObservables
37	{	39	{
Lines 40-45 Link Here
40	* @param eObject the object to observe.	42	* @param eObject the object to observe.
41	* @param eStructuralFeature the feature of the object to observe.	43	* @param eStructuralFeature the feature of the object to observe.
42	* @return an observable value for the given feature of the object.	44	* @return an observable value for the given feature of the object.
		45	* @deprecated you should use {@link EMFProperties#value(FeaturePath)} and {@link IEMFValueProperty#observe(Object)}
43	*/	46	*/
44	public static IObservableValue observeValue(EObject eObject, EStructuralFeature eStructuralFeature)	47	public static IObservableValue observeValue(EObject eObject, EStructuralFeature eStructuralFeature)
45	{	48	{
Lines 52-57 Link Here
52	* @param eObject the object to observe.	55	* @param eObject the object to observe.
53	* @param eStructuralFeature the feature of the object to observe.	56	* @param eStructuralFeature the feature of the object to observe.
54	* @return an observable value for the given feature of the object.	57	* @return an observable value for the given feature of the object.
		58	* @deprecated you should use {@link EMFProperties#value(EStructuralFeature)} and {@link IEMFValueProperty#observe(Realm, Object)}
55	*/	59	*/
56	public static IObservableValue observeValue(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)	60	public static IObservableValue observeValue(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)
57	{	61	{
Lines 63-68 Link Here
63	* @param eObject the object to observe.	67	* @param eObject the object to observe.
64	* @param eStructuralFeature the feature of the object to observe.	68	* @param eStructuralFeature the feature of the object to observe.
65	* @return an observable list for the given multi-valued feature of the object.	69	* @return an observable list for the given multi-valued feature of the object.
		70	* @deprecated you should use {@link EMFProperties#list(EStructuralFeature)} and {@link IEMFListProperty#observe(Object)}
66	*/	71	*/
67	public static IObservableList observeList(EObject eObject, EStructuralFeature eStructuralFeature)	72	public static IObservableList observeList(EObject eObject, EStructuralFeature eStructuralFeature)
68	{	73	{
Lines 75-80 Link Here
75	* @param eObject the object to observe.	80	* @param eObject the object to observe.
76	* @param eStructuralFeature the feature of the object to observe.	81	* @param eStructuralFeature the feature of the object to observe.
77	* @return an observable list for the given multi-valued feature of the object.	82	* @return an observable list for the given multi-valued feature of the object.
		83	* @deprecated you should use {@link EMFProperties#list(EStructuralFeature)} and {@link IEMFListProperty#observe(Realm,Object)}
78	*/	84	*/
79	public static IObservableList observeList(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)	85	public static IObservableList observeList(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)
80	{	86	{
Lines 87-92 Link Here
87	* @param objects the objects to track.	93	* @param objects the objects to track.
88	* @param eStructuralFeature the feature for which to track the value.	94	* @param eStructuralFeature the feature for which to track the value.
89	* @return an observable map tracking the current value of the given feature for each object in the given set.	95	* @return an observable map tracking the current value of the given feature for each object in the given set.
		96	* @deprecated you should use {@link EMFProperties#value(EStructuralFeature)} and {@link IEMFValueProperty#observeDetail(IObservableSet)}
90	*/	97	*/
91	public static IObservableMap observeMap(IObservableSet objects, EStructuralFeature eStructuralFeature)	98	public static IObservableMap observeMap(IObservableSet objects, EStructuralFeature eStructuralFeature)
92	{	99	{
Lines 99-104 Link Here
99	* @param objects the objects to track.	106	* @param objects the objects to track.
100	* @param eStructuralFeatures the features for which to track the value.	107	* @param eStructuralFeatures the features for which to track the value.
101	* @return an array of observable maps tracking the current value of the given features for each object in the given set.	108	* @return an array of observable maps tracking the current value of the given features for each object in the given set.
		109	* @deprecated you should use {@link EMFProperties#values(EStructuralFeature...)} and {@link IEMFValueProperty#observeDetail(IObservableSet)}
102	*/	110	*/
103	public static IObservableMap[] observeMaps(IObservableSet objects, EStructuralFeature[] eStructuralFeatures)	111	public static IObservableMap[] observeMaps(IObservableSet objects, EStructuralFeature[] eStructuralFeatures)
104	{	112	{
Lines 117-122 Link Here
117	* @param eStructuralFeature the feature for which to track the value.	125	* @param eStructuralFeature the feature for which to track the value.
118	* @return an observable value that tracks the current value of the named property for the current value of the master observable value	126	* @return an observable value that tracks the current value of the named property for the current value of the master observable value
119	* @see MasterDetailObservables#detailValue(IObservableValue, IObservableFactory, Object)	127	* @see MasterDetailObservables#detailValue(IObservableValue, IObservableFactory, Object)
		128	* @deprecated you should use {@link EMFProperties#value(EStructuralFeature)} and {@link IEMFValueProperty#observeDetail(IObservableValue)}
120	*/	129	*/
121	public static IObservableValue observeDetailValue(Realm realm, IObservableValue value, EStructuralFeature eStructuralFeature)	130	public static IObservableValue observeDetailValue(Realm realm, IObservableValue value, EStructuralFeature eStructuralFeature)
122	{	131	{
Lines 132-139 Link Here
132	*/	141	*/
133	public static IObservableFactory valueFactory(final Realm realm, final EStructuralFeature eStructuralFeature)	142	public static IObservableFactory valueFactory(final Realm realm, final EStructuralFeature eStructuralFeature)
134	{	143	{
135	return	144	return new IObservableFactory()
136	new IObservableFactory()
137	{	145	{
138	public IObservable createObservable(Object target)	146	public IObservable createObservable(Object target)
139	{	147	{
Lines 149-154 Link Here
149	* @param eStructuralFeature the feature for which to track the value.	157	* @param eStructuralFeature the feature for which to track the value.
150	* @return an observable value that tracks the current value of the named property for the current value of the master observable value	158	* @return an observable value that tracks the current value of the named property for the current value of the master observable value
151	* @see MasterDetailObservables#detailList(IObservableValue, IObservableFactory, Object)	159	* @see MasterDetailObservables#detailList(IObservableValue, IObservableFactory, Object)
		160	* @deprecated you should use {@link EMFProperties#value(EStructuralFeature)} and {@link IEMFValueProperty#observeDetail(IObservableList)}
152	*/	161	*/
153	public static IObservableList observeDetailList(Realm realm, IObservableValue value, EStructuralFeature eStructuralFeature)	162	public static IObservableList observeDetailList(Realm realm, IObservableValue value, EStructuralFeature eStructuralFeature)
154	{	163	{
Lines 164-171 Link Here
164	*/	173	*/
165	public static IObservableFactory listFactory(final Realm realm, final EStructuralFeature eStructuralFeature)	174	public static IObservableFactory listFactory(final Realm realm, final EStructuralFeature eStructuralFeature)
166	{	175	{
167	return	176	return new IObservableFactory()
168	new IObservableFactory()
169	{	177	{
170	public IObservable createObservable(Object target)	178	public IObservable createObservable(Object target)
171	{	179	{
Lines 173-179 Link Here
173	}	181	}
174	};	182	};
175	}	183	}
176		184
177	/**	185	/**
178	* Returns a factory for creating observable maps	186	* Returns a factory for creating observable maps
179	* tracking the value of the given feature of a particular {@link EObject object}.	187	* tracking the value of the given feature of a particular {@link EObject object}.
Lines 182-194 Link Here
182	*/	190	*/
183	public static IObservableFactory mapFactory(final EStructuralFeature eStructuralFeature)	191	public static IObservableFactory mapFactory(final EStructuralFeature eStructuralFeature)
184	{	192	{
185	return	193	return new IObservableFactory()
186	new IObservableFactory()
187	{	194	{
188	public IObservable createObservable(Object target)	195	public IObservable createObservable(Object target)
189	{	196	{
190	return observeMap((IObservableSet)target, eStructuralFeature);	197	return observeMap((IObservableSet)target, eStructuralFeature);
191	}	198	}
192	};	199	};
193	}	200	}
		201
		202	/**
		203	* Returns an observable for the resource contents (
		204	* {@link Resource#getContents()})
		205	*
		206	* @param resource
		207	* the resources the content should be observed
		208	* @return an observable list
		209	*/
		210	public static IObservableList observeResourceContents(Resource resource)
		211	{
		212	return new EWritableList<EObject>((NotifyingList<EObject>)resource.getContents());
		213	}
		214
194	}	215	}

Lines 32-55 Link Here

(-)src/org/eclipse/emf/databinding/EObjectObservableList.java (-33 / +57 lines)
32	import org.eclipse.emf.ecore.EObject;	32	import org.eclipse.emf.ecore.EObject;
33	import org.eclipse.emf.ecore.EStructuralFeature;	33	import org.eclipse.emf.ecore.EStructuralFeature;
34		34
		35
35	/**	36	/**
36	* PROVISIONAL	37	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
37	* This API is subject to arbitrary change, including renaming or removal.	38	* @deprecated do not use this list it will be removed in 2.6
38	*/	39	*/
39	public class EObjectObservableList extends ObservableList implements IObserving, InternalRawEList	40	public class EObjectObservableList extends ObservableList implements IObserving, InternalRawEList
40	{	41	{
		42	/**
		43	* The object owning the feature
		44	*/
41	protected EObject eObject;	45	protected EObject eObject;
		46	/**
		47	* The structural feature
		48	*/
42	protected EStructuralFeature eStructuralFeature;	49	protected EStructuralFeature eStructuralFeature;
		50	/**
		51	* The listener attached
		52	*/
43	protected Adapter listener;	53	protected Adapter listener;
44		54
		55	/**
		56	* Observe a list feature using a default realm
		57	*
		58	* @param eObject
		59	* the object instance
		60	* @param eStructuralFeature
		61	* the feature
		62	*/
45	public EObjectObservableList(EObject eObject, EStructuralFeature eStructuralFeature)	63	public EObjectObservableList(EObject eObject, EStructuralFeature eStructuralFeature)
46	{	64	{
47	this(Realm.getDefault(), eObject, eStructuralFeature);	65	this(Realm.getDefault(), eObject, eStructuralFeature);
48	}	66	}
49		67
		68	/**
		69	* Observe a list feature using a custom realm
		70	*
		71	* @param realm
		72	* the realm
		73	*
		74	* @param eObject
		75	* the object instance
		76	* @param eStructuralFeature
		77	* the feature
		78	*/
50	public EObjectObservableList(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)	79	public EObjectObservableList(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)
51	{	80	{
52	super(realm, (EList<?>)eObject.eGet(eStructuralFeature), eStructuralFeature);	81	super(realm, (EList< ? >)eObject.eGet(eStructuralFeature), eStructuralFeature);
53	this.eObject = eObject;	82	this.eObject = eObject;
54	this.eStructuralFeature = eStructuralFeature;	83	this.eStructuralFeature = eStructuralFeature;
55	}	84	}
Lines 57-64 Link Here
57	@Override	86	@Override
58	protected void firstListenerAdded()	87	protected void firstListenerAdded()
59	{	88	{
60	listener =	89	listener = new AdapterImpl()
61	new AdapterImpl()
62	{	90	{
63	@Override	91	@Override
64	public void notifyChanged(Notification notification)	92	public void notifyChanged(Notification notification)
Lines 68-82 Link Here
68	final ListDiff diff;	96	final ListDiff diff;
69	switch (notification.getEventType())	97	switch (notification.getEventType())
70	{	98	{
71	case Notification.ADD:	99	case Notification.ADD: {
72	{
73	diff = Diffs.createListDiff(Diffs.createListDiffEntry(notification.getPosition(), true, notification.getNewValue()));	100	diff = Diffs.createListDiff(Diffs.createListDiffEntry(notification.getPosition(), true, notification.getNewValue()));
74	break;	101	break;
75	}	102	}
76	case Notification.ADD_MANY:	103	case Notification.ADD_MANY: {
77	{	104	Collection< ? > newValues = (Collection< ? >)notification.getNewValue();
78	Collection<?> newValues = (Collection<?>)notification.getNewValue();	105	ListDiffEntry[] listDiffEntries = new ListDiffEntry [newValues.size()];
79	ListDiffEntry [] listDiffEntries = new ListDiffEntry [newValues.size()];
80	int position = notification.getPosition();	106	int position = notification.getPosition();
81	int index = 0;	107	int index = 0;
82	for (Object newValue : newValues)	108	for (Object newValue : newValues)
Lines 86-100 Link Here
86	diff = Diffs.createListDiff(listDiffEntries);	112	diff = Diffs.createListDiff(listDiffEntries);
87	break;	113	break;
88	}	114	}
89	case Notification.REMOVE:	115	case Notification.REMOVE: {
90	{
91	diff = Diffs.createListDiff(Diffs.createListDiffEntry(notification.getPosition(), false, notification.getOldValue()));	116	diff = Diffs.createListDiff(Diffs.createListDiffEntry(notification.getPosition(), false, notification.getOldValue()));
92	break;	117	break;
93	}	118	}
94	case Notification.REMOVE_MANY:	119	case Notification.REMOVE_MANY: {
95	{	120	Collection< ? > oldValues = (Collection< ? >)notification.getOldValue();
96	Collection<?> oldValues = (Collection<?>)notification.getOldValue();	121	ListDiffEntry[] listDiffEntries = new ListDiffEntry [oldValues.size()];
97	ListDiffEntry [] listDiffEntries = new ListDiffEntry [oldValues.size()];
98	int position = notification.getPosition();	122	int position = notification.getPosition();
99	int index = 0;	123	int index = 0;
100	for (Object oldValue : oldValues)	124	for (Object oldValue : oldValues)
Lines 105-140 Link Here
105	break;	129	break;
106	}	130	}
107	case Notification.SET:	131	case Notification.SET:
108	case Notification.RESOLVE:	132	case Notification.RESOLVE: {
109	{	133	ListDiffEntry[] listDiffEntries = new ListDiffEntry [2];
110	ListDiffEntry [] listDiffEntries = new ListDiffEntry [2];
111	listDiffEntries[0] = Diffs.createListDiffEntry(notification.getPosition(), false, notification.getOldValue());	134	listDiffEntries[0] = Diffs.createListDiffEntry(notification.getPosition(), false, notification.getOldValue());
112	listDiffEntries[1] = Diffs.createListDiffEntry(notification.getPosition(), true, notification.getNewValue());	135	listDiffEntries[1] = Diffs.createListDiffEntry(notification.getPosition(), true, notification.getNewValue());
113	diff = Diffs.createListDiff(listDiffEntries);	136	diff = Diffs.createListDiff(listDiffEntries);
114	break;	137	break;
115	}	138	}
116	case Notification.MOVE:	139	case Notification.MOVE: {
117	{
118	Object movedValue = notification.getNewValue();	140	Object movedValue = notification.getNewValue();
119	ListDiffEntry [] listDiffEntries = new ListDiffEntry [2];	141	ListDiffEntry[] listDiffEntries = new ListDiffEntry [2];
120	listDiffEntries[0] = Diffs.createListDiffEntry((Integer)notification.getOldValue(), false, movedValue);	142	listDiffEntries[0] = Diffs.createListDiffEntry((Integer)notification.getOldValue(), false, movedValue);
121	listDiffEntries[1] = Diffs.createListDiffEntry(notification.getPosition(), true, movedValue);	143	listDiffEntries[1] = Diffs.createListDiffEntry(notification.getPosition(), true, movedValue);
122	diff = Diffs.createListDiff(listDiffEntries);	144	diff = Diffs.createListDiff(listDiffEntries);
123	break;	145	break;
124	}	146	}
125	case Notification.UNSET:	147	case Notification.UNSET: {
126	{	148	// This just represents going back to the unset state,
127	// This just represents going back to the unset state, but that doesn't affect the contents of the list.	149	// but that doesn't affect the contents of the list.
128	//	150	//
129	return;	151	return;
130	}	152	}
131	default:	153	default: {
132	{
133	throw new RuntimeException("unhandled case");	154	throw new RuntimeException("unhandled case");
134	}	155	}
135	}	156	}
136	getRealm().exec	157	getRealm().exec(new Runnable()
137	(new Runnable()
138	{	158	{
139	public void run()	159	public void run()
140	{	160	{
Lines 146-152 Link Here
146	};	166	};
147	eObject.eAdapters().add(listener);	167	eObject.eAdapters().add(listener);
148	}	168	}
149		169
150	@Override	170	@Override
151	protected void lastListenerRemoved()	171	protected void lastListenerRemoved()
152	{	172	{
Lines 167-172 Link Here
167	super.dispose();	187	super.dispose();
168	}	188	}
169		189
		190	/**
		191	* @return the wrapped list
		192	*/
170	@SuppressWarnings("unchecked")	193	@SuppressWarnings("unchecked")
171	protected final List<Object> wrappedList()	194	protected final List<Object> wrappedList()
172	{	195	{
Lines 256-262 Link Here
256	public Object move(int newPosition, int oldPosition)	279	public Object move(int newPosition, int oldPosition)
257	{	280	{
258	checkRealm();	281	checkRealm();
259	return ((EList<?>)wrappedList).move(newPosition, oldPosition);	282	return ((EList< ? >)wrappedList).move(newPosition, oldPosition);
260	}	283	}
261		284
262	public void move(int newPosition, Object object)	285	public void move(int newPosition, Object object)
Lines 290-294 Link Here
290	@SuppressWarnings("unchecked")	313	@SuppressWarnings("unchecked")
291	interface InternalRawEList extends EList	314	interface InternalRawEList extends EList
292	{	315	{
293	// This is only at avoid needing an @SuppressWarnings("unchecked") on the EMFObservableList	316	// This is only at avoid needing an @SuppressWarnings("unchecked") on the
		317	// EMFObservableList
294	}	318	}




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


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * @deprecated do not use this map it will be removed in 2.6
 */
public class EObjectObservableMap extends ComputedObservableMap
{
  /**
   * The feature to observe
   */
  protected EStructuralFeature eStructuralFeature;

  private Adapter elementListener = new AdapterImpl()
    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);

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

  @Override




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.EDataType;
import org.eclipse.emf.ecore.EFactory;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 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 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 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)
  {

        final EAttribute eAttribute = (EAttribute)toType;
        final EDataType eDataType = eAttribute.getEAttributeType();
        final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();
        return new Converter(fromType, toType)
          new Converter(fromType, toType)
          {
            public Object convert(Object fromObject)
            {

        final EAttribute eAttribute = (EAttribute)fromType;
        final EDataType eDataType = eAttribute.getEAttributeType();
        final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();
        return new Converter(fromType, toType)
          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)
                  {

    }
    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> 
 *
 * 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)
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding;

import java.util.Map;

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


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * An {@link IMapProperty} extension interface with convenience methods for
 * creating nested {@link EStructuralFeature}s
 * 
 * @since 2.5
 * @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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding.internal;

import org.eclipse.emf.ecore.EStructuralFeature;


/**
 * @since 2.5
 */
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) 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 in 262160
 * </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> the type
 * @since 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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;


/**
 * @since 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
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> 
 *
 * 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
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding.internal;

/**
 * @since 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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;


/**
 * @since 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding;

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


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * Provides access to details of EObject observables.
 * <p>
 * This interface is not meant to be implemented by clients.
 * </p>
 * 
 * @since 2.5
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
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> 
 *
 * 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)
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding;

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


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * An {@link IValueProperty} extension interface with convenience methods for
 * creating nested {@link EStructuralFeature} properties.
 * 
 * @since 2.5
 * @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
   * IEMFValueProperty name = EMFProperties.value(MyPackage.Literals.NODE_NAME);
   * // Observes the name of the parent of a Node object.
   * IEMFValueProperty 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.
   * IEMFListProperty 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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * A factory to create property bound attributes for {@link EObject}
 * 
 * @since 2.5
 */
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 featureProperty = new EMFValuePropertyDecorator(property, featurePath.getFeaturePath()[0]);

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

    return featureProperty;
  }

  /**
   * 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> 
 *
 * 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> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding;

import org.eclipse.emf.ecore.EStructuralFeature;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * Encapsulate a path to features also known as nested feature like person.name
 * 
 * @since 2.5
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
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> 
 *
 * 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)
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding;

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

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * An IProperty extension interface providing access to details of {@link EObject}s
 * 
 * @since 2.5
 * @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 descriptor of the {@link EStructuralFeature} being observed.
   * 
   * @return the {@link EStructuralFeature} being observed
   */
  public EStructuralFeature getStructuralFeature();
}
Index: src/org/eclipse/emf/databinding/IEMFListProperty.java

/**
 * <copyright> 
 *
 * 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)
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding;

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


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * An {@link IListProperty} extension interface with convenience methods for
 * creating nested {@link EStructuralFeature}s
 * 
 * @since 2.5
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
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

/**
 * <copyright> 
 *
 * Copyright (c) 2009 Tom Schindl 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> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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;


/**
 * @since 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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;


/**
 * @since 2.5
 */
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





import org.eclipse.emf.common.util.ResourceLocator;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * This is the central singleton for the Data binding Edit plugin.
 */
public final class DataBindingEditPlugin extends EMFPlugin

   */
  public DataBindingEditPlugin()
  {
    super(new ResourceLocator []{});
  }

  /**

Lines 24-36 Link Here

(-)src/org/eclipse/emf/databinding/edit/EMFEditObservables.java (-9 / +26 lines)
24	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;	24	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
25	import org.eclipse.core.databinding.observable.set.IObservableSet;	25	import org.eclipse.core.databinding.observable.set.IObservableSet;
26	import org.eclipse.core.databinding.observable.value.IObservableValue;	26	import org.eclipse.core.databinding.observable.value.IObservableValue;
		27
		28	import org.eclipse.emf.databinding.FeaturePath;
		29	import org.eclipse.emf.databinding.IEMFValueProperty;
27	import org.eclipse.emf.ecore.EObject;	30	import org.eclipse.emf.ecore.EObject;
28	import org.eclipse.emf.ecore.EStructuralFeature;	31	import org.eclipse.emf.ecore.EStructuralFeature;
29	import org.eclipse.emf.edit.domain.EditingDomain;	32	import org.eclipse.emf.edit.domain.EditingDomain;
30		33
		34
31	/**	35	/**
32	* PROVISIONAL	36	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
33	* This API is subject to arbitrary change, including renaming or removal.
34	*/	37	*/
35	public class EMFEditObservables	38	public class EMFEditObservables
36	{	39	{
Lines 40-45 Link Here
40	* @param eObject the object to observe.	43	* @param eObject the object to observe.
41	* @param eStructuralFeature the feature of the object to observe.	44	* @param eStructuralFeature the feature of the object to observe.
42	* @return an observable value for the given feature of the object.	45	* @return an observable value for the given feature of the object.
		46	* @deprecated you should use {@link EMFEditProperties#value(EditingDomain,FeaturePath)} and {@link IEMFValueProperty#observe(Object)}
43	*/	47	*/
44	public static IObservableValue observeValue(EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)	48	public static IObservableValue observeValue(EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)
45	{	49	{
Lines 53-58 Link Here
53	* @param eObject the object to observe.	57	* @param eObject the object to observe.
54	* @param eStructuralFeature the feature of the object to observe.	58	* @param eStructuralFeature the feature of the object to observe.
55	* @return an observable value for the given feature of the object.	59	* @return an observable value for the given feature of the object.
		60	* @deprecated you should use {@link EMFEditProperties#value(EditingDomain,EStructuralFeature)} and {@link IEMFEditValueProperty#observe(Realm, Object)}
56	*/	61	*/
57	public static IObservableValue observeValue(Realm realm, EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)	62	public static IObservableValue observeValue(Realm realm, EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)
58	{	63	{
Lines 65-70 Link Here
65	* @param eObject the object to observe.	70	* @param eObject the object to observe.
66	* @param eStructuralFeature the feature of the object to observe.	71	* @param eStructuralFeature the feature of the object to observe.
67	* @return an observable list for the given multi-valued feature of the object.	72	* @return an observable list for the given multi-valued feature of the object.
		73	* @deprecated you should use {@link EMFEditProperties#list(EditingDomain,EStructuralFeature)} and {@link IEMFEditListProperty#observe(Object)}
68	*/	74	*/
69	public static IObservableList observeList(EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)	75	public static IObservableList observeList(EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)
70	{	76	{
Lines 78-83 Link Here
78	* @param eObject the object to observe.	84	* @param eObject the object to observe.
79	* @param eStructuralFeature the feature of the object to observe.	85	* @param eStructuralFeature the feature of the object to observe.
80	* @return an observable list for the given multi-valued feature of the object.	86	* @return an observable list for the given multi-valued feature of the object.
		87	* @deprecated you should use {@link EMFEditProperties#list(EditingDomain,EStructuralFeature)} and {@link IEMFEditListProperty#observe(Realm,Object)}
81	*/	88	*/
82	public static IObservableList observeList(Realm realm, EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)	89	public static IObservableList observeList(Realm realm, EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)
83	{	90	{
Lines 91-96 Link Here
91	* @param objects the objects to track.	98	* @param objects the objects to track.
92	* @param eStructuralFeature the feature for which to track the value.	99	* @param eStructuralFeature the feature for which to track the value.
93	* @return an observable map tracking the current value of the given feature for each object in the given set.	100	* @return an observable map tracking the current value of the given feature for each object in the given set.
		101	* @deprecated you should use {@link EMFEditProperties#value(EditingDomain,EStructuralFeature)} and {@link IEMFEditValueProperty#observeDetail(IObservableSet)}
94	*/	102	*/
95	public static IObservableMap observeMap(EditingDomain domain, IObservableSet objects, EStructuralFeature eStructuralFeature)	103	public static IObservableMap observeMap(EditingDomain domain, IObservableSet objects, EStructuralFeature eStructuralFeature)
96	{	104	{
Lines 104-109 Link Here
104	* @param objects the objects to track.	112	* @param objects the objects to track.
105	* @param eStructuralFeatures the features for which to track the value.	113	* @param eStructuralFeatures the features for which to track the value.
106	* @return an array of observable maps tracking the current value of the given features for each object in the given set.	114	* @return an array of observable maps tracking the current value of the given features for each object in the given set.
		115	* @deprecated you should use {@link EMFEditProperties#values(EditingDomain,EStructuralFeature...)} and {@link IEMFEditValueProperty#observeDetail(IObservableSet)}
107	*/	116	*/
108	public static IObservableMap[] observeMaps(EditingDomain domain, IObservableSet objects, EStructuralFeature[] eStructuralFeatures)	117	public static IObservableMap[] observeMaps(EditingDomain domain, IObservableSet objects, EStructuralFeature[] eStructuralFeatures)
109	{	118	{
Lines 123-130 Link Here
123	* @param eStructuralFeature the feature for which to track the value.	132	* @param eStructuralFeature the feature for which to track the value.
124	* @return an observable value that tracks the current value of the named property for the current value of the master observable value	133	* @return an observable value that tracks the current value of the named property for the current value of the master observable value
125	* @see MasterDetailObservables#detailValue(IObservableValue, IObservableFactory, Object)	134	* @see MasterDetailObservables#detailValue(IObservableValue, IObservableFactory, Object)
		135	* @deprecated you should use {@link EMFEditProperties#value(EditingDomain,EStructuralFeature)} and {@link IEMFEditValueProperty#observeDetail(IObservableValue)}
126	*/	136	*/
127	public static IObservableValue observeDetailValue(Realm realm, EditingDomain domain, IObservableValue value, EStructuralFeature eStructuralFeature)	137	public static IObservableValue observeDetailValue(
		138	Realm realm,
		139	EditingDomain domain,
		140	IObservableValue value,
		141	EStructuralFeature eStructuralFeature)
128	{	142	{
129	return MasterDetailObservables.detailValue(value, valueFactory(realm, domain, eStructuralFeature), eStructuralFeature);	143	return MasterDetailObservables.detailValue(value, valueFactory(realm, domain, eStructuralFeature), eStructuralFeature);
130	}	144	}
Lines 156-163 Link Here
156	* @param eStructuralFeature the feature for which to track the value.	170	* @param eStructuralFeature the feature for which to track the value.
157	* @return an observable value that tracks the current value of the named property for the current value of the master observable value	171	* @return an observable value that tracks the current value of the named property for the current value of the master observable value
158	* @see MasterDetailObservables#detailList(IObservableValue, IObservableFactory, Object)	172	* @see MasterDetailObservables#detailList(IObservableValue, IObservableFactory, Object)
		173	* @deprecated you should use {@link EMFEditProperties#value(EditingDomain,EStructuralFeature)} and {@link IEMFEditValueProperty#observeDetail(IObservableList)}
159	*/	174	*/
160	public static IObservableList observeDetailList(Realm realm, EditingDomain domain, IObservableValue value, EStructuralFeature eStructuralFeature)	175	public static IObservableList observeDetailList(
		176	Realm realm,
		177	EditingDomain domain,
		178	IObservableValue value,
		179	EStructuralFeature eStructuralFeature)
161	{	180	{
162	return MasterDetailObservables.detailList(value, listFactory(realm, domain, eStructuralFeature), eStructuralFeature);	181	return MasterDetailObservables.detailList(value, listFactory(realm, domain, eStructuralFeature), eStructuralFeature);
163	}	182	}
Lines 172-179 Link Here
172	*/	191	*/
173	public static IObservableFactory listFactory(final Realm realm, final EditingDomain domain, final EStructuralFeature eStructuralFeature)	192	public static IObservableFactory listFactory(final Realm realm, final EditingDomain domain, final EStructuralFeature eStructuralFeature)
174	{	193	{
175	return	194	return new IObservableFactory()
176	new IObservableFactory()
177	{	195	{
178	public IObservable createObservable(Object target)	196	public IObservable createObservable(Object target)
179	{	197	{
Lines 191-203 Link Here
191	*/	209	*/
192	public static IObservableFactory mapFactory(final EditingDomain domain, final EStructuralFeature eStructuralFeature)	210	public static IObservableFactory mapFactory(final EditingDomain domain, final EStructuralFeature eStructuralFeature)
193	{	211	{
194	return	212	return new IObservableFactory()
195	new IObservableFactory()
196	{	213	{
197	public IObservable createObservable(Object target)	214	public IObservable createObservable(Object target)
198	{	215	{
199	return observeMap(domain, (IObservableSet)target, eStructuralFeature);	216	return observeMap(domain, (IObservableSet)target, eStructuralFeature);
200	}	217	}
201	};	218	};
202	}	219	}
203	}	220	}

Lines 24-41 Link Here

(-)src/org/eclipse/emf/databinding/edit/EditingDomainEObjectObservableValue.java (-2 / +29 lines)
24	import org.eclipse.emf.edit.command.SetCommand;	24	import org.eclipse.emf.edit.command.SetCommand;
25	import org.eclipse.emf.edit.domain.EditingDomain;	25	import org.eclipse.emf.edit.domain.EditingDomain;
26		26
		27
27	/**	28	/**
28	* PROVISIONAL	29	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
29	* This API is subject to arbitrary change, including renaming or removal.	30	* @deprecated do not use this value it will be removed in 2.6
30	*/	31	*/
31	public class EditingDomainEObjectObservableValue extends EObjectObservableValue	32	public class EditingDomainEObjectObservableValue extends EObjectObservableValue
32	{	33	{
		34	/**
		35	* The editing domain
		36	*/
33	protected EditingDomain domain;	37	protected EditingDomain domain;
34		38
		39	/**
		40	* Observe a list feature using a default realm
		41	*
		42	* @param domain
		43	* the editing domain
		44	* @param eObject
		45	* the object instance
		46	* @param eStructuralFeature
		47	* the feature
		48	*/
35	public EditingDomainEObjectObservableValue(EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)	49	public EditingDomainEObjectObservableValue(EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)
36	{	50	{
37	this(Realm.getDefault(), domain, eObject, eStructuralFeature);	51	this(Realm.getDefault(), domain, eObject, eStructuralFeature);
38	}	52	}
		53
		54	/**
		55	* Observe a list feature using a custom realm
		56	*
		57	* @param realm
		58	* the realm
		59	* @param domain
		60	* the editing domain
		61	* @param eObject
		62	* the object instance
		63	* @param eStructuralFeature
		64	* the feature
		65	*/
39	public EditingDomainEObjectObservableValue(Realm realm, EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)	66	public EditingDomainEObjectObservableValue(Realm realm, EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)
40	{	67	{
41	super(realm, eObject, eStructuralFeature);	68	super(realm, eObject, eStructuralFeature);

Lines 30-54 Link Here

(-)src/org/eclipse/emf/databinding/edit/EditingDomainEObjectObservableList.java (-4 / +31 lines)
30	import org.eclipse.emf.edit.command.SetCommand;	30	import org.eclipse.emf.edit.command.SetCommand;
31	import org.eclipse.emf.edit.domain.EditingDomain;	31	import org.eclipse.emf.edit.domain.EditingDomain;
32		32
		33
33	/**	34	/**
34	* PROVISIONAL	35	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
35	* This API is subject to arbitrary change, including renaming or removal.	36	* @deprecated do not use this list it will be removed in 2.6
36	*/	37	*/
37	public class EditingDomainEObjectObservableList extends EObjectObservableList	38	public class EditingDomainEObjectObservableList extends EObjectObservableList
38	{	39	{
		40	/**
		41	* The editing domain
		42	*/
39	protected EditingDomain domain;	43	protected EditingDomain domain;
40		44
		45	/**
		46	* Observe a feature of the instance using the default realm
		47	* @param domain
		48	* the editing domain
		49	* @param eObject
		50	* the object
		51	* @param eStructuralFeature
		52	* the feature
		53	*/
41	public EditingDomainEObjectObservableList(EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)	54	public EditingDomainEObjectObservableList(EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)
42	{	55	{
43	this(Realm.getDefault(), domain, eObject, eStructuralFeature);	56	this(Realm.getDefault(), domain, eObject, eStructuralFeature);
44	}	57	}
45		58
		59	/**
		60	* Observe a feature of the instance using the realm
		61	* @param domain
		62	* the editing domain
		63	* @param realm
		64	*
		65	* @param eObject
		66	* the object
		67	* @param eStructuralFeature
		68	* the feature
		69	*/
46	public EditingDomainEObjectObservableList(Realm realm, EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)	70	public EditingDomainEObjectObservableList(Realm realm, EditingDomain domain, EObject eObject, EStructuralFeature eStructuralFeature)
47	{	71	{
48	super(realm, eObject, eStructuralFeature);	72	super(realm, eObject, eStructuralFeature);
49	this.domain = domain;	73	this.domain = domain;
50	}	74	}
51
52		75
53	@Override	76	@Override
54	public synchronized void dispose()	77	public synchronized void dispose()
Lines 57-62 Link Here
57	super.dispose();	80	super.dispose();
58	}	81	}
59		82
		83	/**
		84	* Execute a command
		85	* @param command the command to execute
		86	* @return <code>true</code> if execute else <code>false</code>
		87	*/
60	protected boolean execute(Command command)	88	protected boolean execute(Command command)
61	{	89	{
62	if (command.canExecute())	90	if (command.canExecute())
Lines 70-76 Link Here
70	}	98	}
71	}	99	}
72		100
73
74	@Override	101	@Override
75	public boolean add(Object object)	102	public boolean add(Object object)
76	{	103	{

Lines 24-43 Link Here

(-)src/org/eclipse/emf/databinding/edit/EditingDomainEObjectObservableMap.java (-4 / +17 lines)
24	import org.eclipse.emf.edit.command.SetCommand;	24	import org.eclipse.emf.edit.command.SetCommand;
25	import org.eclipse.emf.edit.domain.EditingDomain;	25	import org.eclipse.emf.edit.domain.EditingDomain;
26		26
		27
27	/**	28	/**
28	* PROVISIONAL	29	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
29	* This API is subject to arbitrary change, including renaming or removal.	30	* @deprecated do not use this map it will be removed in 2.6
30	*/	31	*/
31	public class EditingDomainEObjectObservableMap extends EObjectObservableMap	32	public class EditingDomainEObjectObservableMap extends EObjectObservableMap
32	{	33	{
		34	/**
		35	* The editing domain
		36	*/
33	protected EditingDomain domain;	37	protected EditingDomain domain;
34		38
		39	/**
		40	* Create a new observable for the set of features
		41	* @param domain
		42	* the editing domain
		43	* @param objects
		44	* the objects to observe
		45	* @param eStructuralFeature
		46	* the feature
		47	*/
35	public EditingDomainEObjectObservableMap(EditingDomain domain, IObservableSet objects, EStructuralFeature eStructuralFeature)	48	public EditingDomainEObjectObservableMap(EditingDomain domain, IObservableSet objects, EStructuralFeature eStructuralFeature)
36	{	49	{
37	super(objects, eStructuralFeature);	50	super(objects, eStructuralFeature);
38	this.domain = domain;	51	this.domain = domain;
39	}	52	}
40		53
41	@Override	54	@Override
42	protected Object doPut(Object key, Object value)	55	protected Object doPut(Object key, Object value)
43	{	56	{
Lines 45-51 Link Here
45	Object result = eObject.eGet(eStructuralFeature);	58	Object result = eObject.eGet(eStructuralFeature);
46	Command command = SetCommand.create(domain, eObject, eStructuralFeature, value);	59	Command command = SetCommand.create(domain, eObject, eStructuralFeature, value);
47	domain.getCommandStack().execute(command);	60	domain.getCommandStack().execute(command);
48		61
49	eObject.eSet(eStructuralFeature, value);	62	eObject.eSet(eStructuralFeature, value);
50	return result;	63	return result;
51	}	64	}

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> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
public class EMFEditMapProperty extends EMFMapProperty
{
  private final EditingDomain editingDomain;

  /**
   * @param editingDomain
   * @param eStructuralFeature
   */
  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> 
 *
 * 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)
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding.edit;

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


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * An {@link IListProperty} extension interface with convenience methods for
 * creating nested {@link EStructuralFeature}s
 * 
 * @since 2.5
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFEditListProperty extends IEMFEditProperty, 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(IEMFEditValueProperty)
   */
  public IEMFEditListProperty 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 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
   * 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 IEMFEditListProperty values(IEMFEditValueProperty property);
}
Index: src/org/eclipse/emf/databinding/edit/IEMFEditMapProperty.java

/**
 * <copyright> 
 *
 * 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)
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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.ecore.EStructuralFeature;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * An {@link IMapProperty} extension interface with convenience methods for
 * creating nested {@link EStructuralFeature} properties.
 * 
 * @since 2.5
 * @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 IEMFEditProperty, 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(IEMFEditValueProperty)
   */
  public IEMFEditMapProperty 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(IEMFEditValueProperty)
   */
  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> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 IEMFEditObservable} decorator for an {@link IObservableMap}.
 * 
 * @since 2.5
 */
public class EMFEditObservableMapDecorator extends EMFObservableMapDecorator implements IEMFEditObservable
{
  private final EditingDomain editingDomain;

  /**
   * @param editingDomain
   * @param decorated
   * @param eStructuralFeature
   */
  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> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding.edit;


import org.eclipse.emf.databinding.IEMFObservable;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.domain.EditingDomain;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * Provides access to details of {@link EObject} observables.
 * <p>
 * This interface is not meant to be implemented by clients.
 * </p>
 * 
 * @since 2.5
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFEditObservable extends IEMFObservable
{
  /**
   * @return the editing domain to execute commands
   */
  public EditingDomain getEditingDomain();
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditListPropertyDecorator.java

/**
 * <copyright> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
public class EMFEditListPropertyDecorator extends ListProperty implements IEMFEditListProperty
{
  private final IListProperty delegate;
  private final EStructuralFeature eStructuralFeature;
  private final EditingDomain editingDomain;

  
  /**
   * @param editingDomain
   * @param delegate
   * @param eStructuralFeature
   */
  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();
  }

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

/**
 * <copyright> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
public class EMFEditValuePropertyDecorator extends ValueProperty implements IEMFEditValueProperty
{
  private final IValueProperty delegate;
  private final EStructuralFeature eStructuralFeature;
  private final EditingDomain editingDomain;

  /**
   * @param editingDomain
   * @param delegate
   * @param eStructuralFeature
   */
  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 EMFEditProperties.map(editingDomain, feature);
  }

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

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

/**
 * <copyright> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 IEMFEditObservable} decorator for an {@link IObservableValue}.
 * 
 * @since 2.5
 */
public class EMFEditObservableValueDecorator extends EMFObservableValueDecorator implements IEMFEditObservable
{
  private final EditingDomain editingDomain;

  /**
   * @param editingDomain
   * @param decorated
   * @param eStructuralFeature
   */
  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> 
 *
 * 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)
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding.edit;

import org.eclipse.emf.databinding.IEMFProperty;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * An IProperty extension interface providing access to details of {@link EStructuralFeature}
 * properties.
 * 
 * @since 2.5
 * @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 IEMFProperty
{
  /**
   * @return the editing domain to execute commands
   */
  public EditingDomain getEditingDomain();
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditObservableListDecorator.java

/**
 * <copyright> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 IEMFEditObservable} decorator for an {@link IObservableList}.
 * 
 * @since 2.5
 */
public class EMFEditObservableListDecorator extends EMFObservableListDecorator implements IEMFEditObservable
{

  private final EditingDomain editingDomain;

  /**
   * @param editingDomain
   * @param decorated
   * @param eStructuralFeature
   */
  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> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
public class EMFEditMapPropertyDecorator extends MapProperty implements IEMFEditMapProperty
{
  private final IMapProperty delegate;
  private final EStructuralFeature eStructuralFeature;
  private final EditingDomain editingDomain;

  /**
   * @param editingDomain
   * @param delegate
   * @param eStructuralFeature
   */
  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();
  }

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

/**
 * <copyright> 
 *
 * 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
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * A factory to create property bound attributes for {@link EObject} which use an {@link EditingDomain} to make changes to the {@link EObject}
 * 
 * @since 2.5
 */
public class EMFEditProperties
{
  /**
   * Turn on debug logging
   */
  public static final boolean DEBUG = false;

  /**
   * Returns a value property for the given {@link EStructuralFeature}
   * 
   * @param editingDomain the editing domain
   * @param feature
   *            the feature instance the property is created for
   * @return a value property for the given {@link EStructuralFeature}
   */
  public static IEMFEditValueProperty value(EditingDomain editingDomain, EStructuralFeature feature)
  {
    return value(editingDomain, 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 editingDomain the editing domain
   * @param featurePath
   *            path to the feature
   * @return a value property for the given {@link FeaturePath}
   */
  public static IEMFEditValueProperty value(EditingDomain editingDomain, FeaturePath featurePath)
  {
    IValueProperty property;
    property = new EMFEditValueProperty(editingDomain, featurePath.getFeaturePath()[0]);

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

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

    return featureProperty;
  }

  /**
   * Returns multiple value properties for the given
   * {@link EStructuralFeature}s
   * 
   * @param editingDomain 
   *            the editing domain
   * @param features
   *            the feature instances the properties are created for
   * @return an array of properties for the given {@link EStructuralFeature}s
   */
  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 multiple value property for the given nested
   * {@link EStructuralFeature} features like the <code>name</code> of a
   * <code>person</code>
   * 
   * @param editingDomain 
   *            the editing domain
   * @param featurePaths
   *            path to the feature
   * @return an array of properties for the given {@link FeaturePath}s
   */
  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 {@link EStructuralFeature}
   * 
   * @param editingDomain 
   *            the editing domain
   * @param feature
   *            the feature instance the property is created for
   * @return a list property for the given {@link EStructuralFeature}
   */
  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 {@link EStructuralFeature}. Objects lacking the named property are treated the same as if the
   * property always contains an empty map.
   * 
   * @param editingDomain 
   *            the editing domain
   * @param feature
   *            the feature the property is created for
   * @return a map property for the given {@link EStructuralFeature}
   */
  public static IEMFEditMapProperty map(EditingDomain editingDomain, EStructuralFeature feature)
  {
    IMapProperty property;
    property = new EMFEditMapProperty(editingDomain, feature);
    return new EMFEditMapPropertyDecorator(editingDomain, property, feature);
  }
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditValueProperty.java

/**
 * <copyright> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
public class EMFEditValueProperty extends EMFValueProperty
{
  private final EditingDomain editingDomain;

  /**
   * @param editingDomain
   * @param eStructuralFeature
   */
  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> 
 *
 * 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)
 *   Tom Schindl <tom.schindl@bestsolution.at> - port to EMF in 262160
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
package org.eclipse.emf.databinding.edit;

import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.emf.databinding.FeaturePath;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;


/**
 * <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
 * 
 * An {@link IValueProperty} extension interface with convenience methods for
 * creating nested {@link EStructuralFeature} properties and does changes through the {@link EditingDomain}
 * 
 * @since 2.5
 * @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 IEMFEditProperty, 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(IEMFEditValueProperty)
   */
  public IEMFEditValueProperty 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(IEMFEditValueProperty)
   */
  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
   * IEMFValueProperty parent = EMFProperties.value(MyPackage.Literals.NODE_PARENT);
   * // Observes the string-typed &quot;name&quot; property of a Node object
   * IEMFValueProperty name = EMFProperties.value(MyPackage.Literals.NODE_NAME);
   * // Observes the name of the parent of a Node object.
   * IEMFValueProperty 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 feature.
   * 
   * @param feature
   *            the list feature to observe
   * @return a master-detail combination of this property and the specified
   *         list feature.
   * @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.
   * 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.
   * IEMFListProperty 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 feature.
   * 
   * @param feature
   *            the map property to observe
   * @return a master-detail combination of this property and the specified
   *         map feature.
   * @see #map(IEMFEditMapProperty)
   */
  public IEMFEditMapProperty 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 IEMFEditMapProperty map(IEMFEditMapProperty property);
}
Index: src/org/eclipse/emf/databinding/edit/internal/EMFEditListProperty.java

/**
 * <copyright> 
 *
 * 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)
 * </copyright>
 *
 * $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
 */
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 2.5
 */
public class EMFEditListProperty extends EMFListProperty
{
  private final EditingDomain editingDomain;

  /**
   * @param editingDomain
   * @param eStructuralFeature
   */
  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 23-49 Link Here

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

Lines 20-26 Link Here

(-)src/org/eclipse/emf/databinding/DataBindingPlugin.java (-1 / +3 lines)
20		20
21	import org.eclipse.emf.common.util.ResourceLocator;	21	import org.eclipse.emf.common.util.ResourceLocator;
22		22
		23
23	/**	24	/**
		25	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
24	* This is the central singleton for the Data Binding plugin.	26	* This is the central singleton for the Data Binding plugin.
25	*/	27	*/
26	public final class DataBindingPlugin extends EMFPlugin	28	public final class DataBindingPlugin extends EMFPlugin
Lines 40-46 Link Here
40	*/	42	*/
41	public DataBindingPlugin()	43	public DataBindingPlugin()
42	{	44	{
43	super(new ResourceLocator [] {});	45	super(new ResourceLocator []{});
44	}	46	}
45		47
46	/**	48	/**

Lines 19-24 Link Here

(-)src/org/eclipse/emf/databinding/EMFUpdateValueStrategy.java (-9 / +30 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 26-52 Link Here
26	import org.eclipse.emf.ecore.EDataType;	27	import org.eclipse.emf.ecore.EDataType;
27	import org.eclipse.emf.ecore.EFactory;	28	import org.eclipse.emf.ecore.EFactory;
28		29
		30
29	/**	31	/**
30	* PROVISIONAL	32	* <p><b>PROVISIONAL:</b> This API is subject to arbitrary change, including renaming or removal.</p>
31	* This API is subject to arbitrary change, including renaming or removal.
32	*/	33	*/
33	public class EMFUpdateValueStrategy extends UpdateValueStrategy	34	public class EMFUpdateValueStrategy extends UpdateValueStrategy
34	{	35	{
		36	/**
		37	* A value update strategy with default update policy
		38	* {@link UpdateListStrategy#POLICY_UPDATE} and default converters and
		39	* validators
		40	*/
35	public EMFUpdateValueStrategy()	41	public EMFUpdateValueStrategy()
36	{	42	{
37	this(true, POLICY_UPDATE);	43	this(true, POLICY_UPDATE);
38	}	44	}
39		45
		46	/**
		47	* A value strategy with a specific update policy but with default
		48	* converters and validators
		49	*
		50	* @param updatePolicy
		51	* the policy
		52	*/
40	public EMFUpdateValueStrategy(int updatePolicy)	53	public EMFUpdateValueStrategy(int updatePolicy)
41	{	54	{
42	this(true, updatePolicy);	55	this(true, updatePolicy);
43	}	56	}
44		57
		58	/**
		59	* A value strategy with a specific update policy and with the
		60	* possibility to turn of default converters and validators
		61	*
		62	* @param provideDefaults
		63	* <code>false</code> to turn of default converters and
		64	* validators
		65	* @param updatePolicy
		66	* the policy
		67	*/
45	public EMFUpdateValueStrategy(boolean provideDefaults, int updatePolicy)	68	public EMFUpdateValueStrategy(boolean provideDefaults, int updatePolicy)
46	{	69	{
47	super(provideDefaults, updatePolicy);	70	super(provideDefaults, updatePolicy);
48	}	71	}
49		72
50	@Override	73	@Override
51	protected IConverter createConverter(Object fromType, Object toType)	74	protected IConverter createConverter(Object fromType, Object toType)
52	{	75	{
Lines 57-64 Link Here
57	final EAttribute eAttribute = (EAttribute)toType;	80	final EAttribute eAttribute = (EAttribute)toType;
58	final EDataType eDataType = eAttribute.getEAttributeType();	81	final EDataType eDataType = eAttribute.getEAttributeType();
59	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();	82	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();
60	return	83	return new Converter(fromType, toType)
61	new Converter(fromType, toType)
62	{	84	{
63	public Object convert(Object fromObject)	85	public Object convert(Object fromObject)
64	{	86	{
Lines 90-104 Link Here
90	final EAttribute eAttribute = (EAttribute)fromType;	112	final EAttribute eAttribute = (EAttribute)fromType;
91	final EDataType eDataType = eAttribute.getEAttributeType();	113	final EDataType eDataType = eAttribute.getEAttributeType();
92	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();	114	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();
93	return	115	return new Converter(fromType, toType)
94	new Converter(fromType, toType)
95	{	116	{
96	public Object convert(Object fromObject)	117	public Object convert(Object fromObject)
97	{	118	{
98	if (eAttribute.isMany())	119	if (eAttribute.isMany())
99	{	120	{
100	StringBuilder result = new StringBuilder();	121	StringBuilder result = new StringBuilder();
101	for (Object value : (List<?>)fromObject)	122	for (Object value : (List< ? >)fromObject)
102	{	123	{
103	if (result.length() == 0)	124	if (result.length() == 0)
104	{	125	{
Lines 118-121 Link Here
118	}	139	}
119	return super.createConverter(fromType, toType);	140	return super.createConverter(fromType, toType);
120	}	141	}
121	}	142	}

Added Link Here

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