Attachment #125836 for bug #262160

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

Lines 8-14 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 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.properties
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




 * 
 * Contributors: 
 *   IBM - Initial API and implementation
 *   Tom Schindl<tom.schindl@bestsolution.at>
 * </copyright>
 *
 * $Id: EMFDataBindingContext.java,v 1.1 2007/11/16 21:25:21 emerks Exp $
 */
package org.eclipse.emf.databinding;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.value.IObservableValue;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * 
 * A DataBindingContext is the point of contact for the creation and management
 * of {@link Binding bindings}, and aggregates validation statuses of its
 * bindings, or more generally, its validation status providers.
 * <p>
 * A DataBindingContext provides the following abilities:
 * <ul>
 * <li>Ability to create bindings between {@link IObservableValue observable
 * values}.</li>
 * <li>Ability to create bindings between {@link IObservableList observable
 * lists}.</li>
 * <li>Access to the bindings created by the instance.</li>
 * <li>Access to the list of validation status providers (this includes all
 * bindings).</li>
 * </ul>
 * </p>
 * <p>
 * Multiple contexts can be used at any point in time. One strategy for the
 * management of contexts is the aggregation of validation statuses. For example
 * an <code>IWizardPage</code> could use a single context and the statuses could
 * be aggregated to set the page status and fulfillment. Each page in the
 * <code>IWizard</code> would have its own context instance.
 * </p>
 * 
 * @since 1.0
 */
public class EMFDataBindingContext extends DataBindingContext {
	/**
	 * Creates a data binding context, using the current default realm for the
	 * validation observables.
	 * 
	 * @see Realm
	 */
	public EMFDataBindingContext() {
		this(Realm.getDefault());
	}

	/**
	 * Creates a data binding context using the given realm for the validation
	 * observables.
	 * 
	 * @param validationRealm
	 *            the realm to be used for the validation observables
	 * 
	 * @see Realm
	 */
	public EMFDataBindingContext(Realm validationRealm) {
		super(validationRealm);
	}

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

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




 * Contributors: 
 *   IBM - Initial API and implementation
 *   Trevor S. Kaufman - Bug 215131 - added mapFactory
 *   Tom Schindl<tom.schindl@bestsolution.at>
 * </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.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;

import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.emf.common.notify.NotifyingList;
import org.eclipse.emf.databinding.internal.EWritableList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * A factory for creating observable objects of Java objects that conform to the
 * <a href="http://java.sun.com/products/javabeans/docs/spec.html">JavaBean
 * specification</a> for bound properties.
 * 
 * @since 1.0
 */
public class EMFObservables {
	/**
	 * 
	 */
	public static final boolean DEBUG = false;

	/**
	 * Returns an observable value for the given feature of the object.
	 * 
	 * @param eObject
	 *            the object to observe.
	 * @param eStructuralFeature
	 *            the feature of the object to observe.
	 * @return an observable value for the given feature of the object.
	 */
	public static IObservableValue observeValue(EObject eObject,
			EStructuralFeature eStructuralFeature) {
		return new EObjectObservableValue(eObject, eStructuralFeature);
	}

	/**
	 * Returns an observable value for the given feature of the object.
	 * 
	 * @param realm
	 *            the realm in which to observe.
	 * @param eObject
	 *            the object to observe.
	 * @param eStructuralFeature
	 *            the feature of the object to observe.
	 * @return an observable value for the given feature of the object.
	 */
	public static IObservableValue observeValue(Realm realm, EObject eObject,
			EStructuralFeature eStructuralFeature) {
		return new EObjectObservableValue(realm, eObject, eStructuralFeature);
	}

	/**
	 * Returns an observable list for the given multi-valued feature of the
	 * object.
	 * 
	 * @param eObject
	 *            the object to observe.
	 * @param eStructuralFeature
	 *            the feature of the object to observe.
	 * @return an observable list for the given multi-valued feature of the
	 *         object.
	 */
	public static IObservableList observeList(EObject eObject,
			EStructuralFeature eStructuralFeature) {
		return new EObjectObservableList(eObject, eStructuralFeature);
	}

	/**
	 * Returns an observable list for the given multi-valued feature of the
	 * object.
	 * 
	 * @param realm
	 *            the realm in which to observe.
	 * @param eObject
	 *            the object to observe.
	 * @param eStructuralFeature
	 *            the feature of the object to observe.
	 * @return an observable list for the given multi-valued feature of the
	 *         object.
	 */
	public static IObservableList observeList(Realm realm, EObject eObject,
			EStructuralFeature eStructuralFeature) {
		return new EObjectObservableList(realm, eObject, eStructuralFeature);
	}

	/**
	 * Returns an observable map in the default realm tracking the current value
	 * of the given feature for each object in the given set.
	 * 
	 * @param objects
	 *            the objects to track.
	 * @param eStructuralFeature
	 *            the feature for which to track the value.
	 * @return an observable map tracking the current value of the given feature
	 *         for each object in the given set.
	 */
	public static IObservableMap observeMap(IObservableSet objects,
			EStructuralFeature eStructuralFeature) {
		return new EObjectObservableMap(objects, eStructuralFeature);
	}

	/**
	 * Returns an array of observable maps in the default realm tracking the
	 * current value of the given features for each object in the given set.
	 * 
	 * @param objects
	 *            the objects to track.
	 * @param eStructuralFeatures
	 *            the features for which to track the value.
	 * @return an array of observable maps tracking the current value of the
	 *         given features for each object in the given set.
	 */
	public static IObservableMap[] observeMaps(IObservableSet objects,
			EStructuralFeature[] eStructuralFeatures) {
		IObservableMap[] result = new IObservableMap[eStructuralFeatures.length];
		for (int i = 0; i < eStructuralFeatures.length; i++) {
			result[i] = observeMap(objects, eStructuralFeatures[i]);
		}
		return result;
	}

	/**
	 * Returns an observable value that tracks the current value of the feature
	 * of the current value of the master observable value.
	 * 
	 * @param realm
	 *            the realm in which to observe.
	 * @param value
	 *            the master observable value.
	 * @param eStructuralFeature
	 *            the feature for which to track the value.
	 * @return an observable value that tracks the current value of the named
	 *         property for the current value of the master observable value
	 * @see MasterDetailObservables#detailValue(IObservableValue,
	 *      IObservableFactory, Object)
	 */
	public static IObservableValue observeDetailValue(Realm realm,
			IObservableValue value, EStructuralFeature eStructuralFeature) {
		return MasterDetailObservables.detailValue(value, valueFactory(realm,
				eStructuralFeature), eStructuralFeature);
	}

	/**
	 * Returns a factory for creating observable values tracking the value of
	 * the given feature of a particular {@link EObject object}.
	 * 
	 * @param realm
	 *            the realm in which to observe.
	 * @param eStructuralFeature
	 *            the feature for which to track the value.
	 * @return an observable factory.
	 */
	public static IObservableFactory valueFactory(final Realm realm,
			final EStructuralFeature eStructuralFeature) {
		return new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return observeValue(realm, (EObject) target, eStructuralFeature);
			}
		};
	}

	/**
	 * Returns an observable list that tracks the current value of the feature
	 * of the current value of the master observable value.
	 * 
	 * @param realm
	 *            the realm in which to observe.
	 * @param value
	 *            the master observable value.
	 * @param eStructuralFeature
	 *            the feature for which to track the value.
	 * @return an observable value that tracks the current value of the named
	 *         property for the current value of the master observable value
	 * @see MasterDetailObservables#detailList(IObservableValue,
	 *      IObservableFactory, Object)
	 */
	public static IObservableList observeDetailList(Realm realm,
			IObservableValue value, EStructuralFeature eStructuralFeature) {
		return MasterDetailObservables.detailList(value, listFactory(realm,
				eStructuralFeature), eStructuralFeature);
	}

	/**
	 * Returns a factory for creating observable lists tracking the value of the
	 * given feature of a particular {@link EObject object}.
	 * 
	 * @param realm
	 *            the realm in which to observe.
	 * @param eStructuralFeature
	 *            the feature for which to track the value.
	 * @return an observable factory.
	 */
	public static IObservableFactory listFactory(final Realm realm,
			final EStructuralFeature eStructuralFeature) {
		return new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return observeList(realm, (EObject) target, eStructuralFeature);
			}
		};
	}

	/**
	 * Returns a factory for creating observable maps tracking the value of the
	 * given feature of a particular {@link EObject object}.
	 * 
	 * @param eStructuralFeature
	 *            the feature for which to track the value.
	 * @return an observable factory.
	 */
	public static IObservableFactory mapFactory(
			final EStructuralFeature eStructuralFeature) {
		return new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return observeMap((IObservableSet) target, eStructuralFeature);
			}
		};
	}
	
	public static IObservableList observeResourceContents(Resource resource) {
		return new EWritableList<EObject>((NotifyingList<EObject>) resource.getContents());
	}
}




 * 
 * Contributors: 
 *   IBM - Initial API and implementation
 *   Tom Schindl<tom.schindl@bestsolution.at>
 * </copyright>
 *
 * $Id: EMFUpdateListStrategy.java,v 1.1 2007/11/16 21:25:21 emerks Exp $
 */
package org.eclipse.emf.databinding;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.UpdateListStrategy;
import org.eclipse.core.databinding.conversion.Converter;
import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EFactory;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * Customizes a {@link Binding} between two {@link IObservableList observable
 * lists}. The following behaviors can be customized via the strategy:
 * <ul>
 * <li>Conversion</li>
 * <li>Automatic processing</li>
 * </ul>
 * <p>
 * Conversion:<br/>
 * When elements are added they can be {@link #convert(Object) converted} to the
 * destination element type.
 * </p>
 * <p>
 * Automatic processing:<br/>
 * The processing to perform when the source observable changes. This behavior
 * is configured via policies provided on construction of the strategy (e.g.
 * {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST}, {@link #POLICY_UPDATE}).
 * </p>
 * 
 * 
 * @see DataBindingContext#bindList(IObservableList, IObservableList,
 *      UpdateListStrategy, UpdateListStrategy)
 * @see IConverter
 * @since 1.0
 */
public class EMFUpdateListStrategy extends UpdateListStrategy {
	/**
	 * Creates a new update list strategy for automatically updating the
	 * destination observable list whenever the source observable list changes.
	 * A default converter will be provided. The defaults can be changed by
	 * calling one of the setter methods.
	 */
	public EMFUpdateListStrategy() {
		this(true, POLICY_UPDATE);
	}
	
	/**
	 * Creates a new update list strategy with a configurable update policy. A
	 * default converter will be provided. The defaults can be changed by
	 * calling one of the setter methods.
	 *
	 * @param updatePolicy
	 *            one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST}, or
	 *            {@link #POLICY_UPDATE}
	 */
	public EMFUpdateListStrategy(int updatePolicy) {
		this(true, updatePolicy);
	}

	/**
	 * Creates a new update list strategy with a configurable update policy. A
	 * default converter will be provided if <code>provideDefaults</code> is
	 * <code>true</code>. The defaults can be changed by calling one of the
	 * setter methods.
	 *
	 * @param provideDefaults
	 *            if <code>true</code>, default validators and a default
	 *            converter will be provided based on the observable list's
	 *            type.
	 * @param updatePolicy
	 *            one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST}, or
	 *            {@link #POLICY_UPDATE}
	 */
	public EMFUpdateListStrategy(boolean provideDefaults, int updatePolicy) {
		super(provideDefaults, updatePolicy);
	}

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

Lines 9-15 Link Here

(-)src/org/eclipse/emf/databinding/EMFUpdateValueStrategy.java (-89 / +150 lines)
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
12	*	12	* Tom Schindl<tom.schindl@bestsolution.at>
13	* </copyright>	13	* </copyright>
14	*	14	*
15	* $Id: EMFUpdateValueStrategy.java,v 1.2 2008/02/22 12:10:18 emerks Exp $	15	* $Id: EMFUpdateValueStrategy.java,v 1.2 2008/02/22 12:10:18 emerks Exp $
Lines 19-121 Link Here
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.Binding;
		23	import org.eclipse.core.databinding.DataBindingContext;
22	import org.eclipse.core.databinding.UpdateValueStrategy;	24	import org.eclipse.core.databinding.UpdateValueStrategy;
23	import org.eclipse.core.databinding.conversion.Converter;	25	import org.eclipse.core.databinding.conversion.Converter;
24	import org.eclipse.core.databinding.conversion.IConverter;	26	import org.eclipse.core.databinding.conversion.IConverter;
		27	import org.eclipse.core.databinding.observable.value.IObservableValue;
		28	import org.eclipse.core.databinding.validation.IValidator;
25	import org.eclipse.emf.ecore.EAttribute;	29	import org.eclipse.emf.ecore.EAttribute;
26	import org.eclipse.emf.ecore.EDataType;	30	import org.eclipse.emf.ecore.EDataType;
27	import org.eclipse.emf.ecore.EFactory;	31	import org.eclipse.emf.ecore.EFactory;
28		32
29	/**	33	/**
30	* PROVISIONAL	34	* <p>
31	* This API is subject to arbitrary change, including renaming or removal.	35	* <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
		36	* removal.</b>
		37	* </p>
		38	* Customizes a {@link Binding} between two {@link IObservableValue observable
		39	* values}. The following behaviors can be customized via the strategy:
		40	* <ul>
		41	* <li>Validation</li>
		42	* <li>Conversion</li>
		43	* <li>Automatic processing</li>
		44	* </ul>
		45	* <p>
		46	* The update phases are:
		47	* <ol>
		48	* <li>Validate after get - {@link #validateAfterGet(Object)}</li>
		49	* <li>Conversion - {@link #convert(Object)}</li>
		50	* <li>Validate after conversion - {@link #validateAfterConvert(Object)}</li>
		51	* <li>Validate before set - {@link #validateBeforeSet(Object)}</li>
		52	* <li>Value set - {@link #doSet(IObservableValue, Object)}</li>
		53	* </ol>
		54	* </p>
		55	* <p>
		56	* Validation:<br/>
		57	* {@link IValidator Validators} validate the value at multiple phases in the
		58	* update process. Statuses returned from validators are aggregated into a
		59	* <code>MultiStatus</code> until a status of <code>ERROR</code> or
		60	* <code>CANCEL</code> is encountered. Either of these statuses will abort the
		61	* update process. These statuses are available as the
		62	* {@link Binding#getValidationStatus() binding validation status}.
		63	* </p>
		64	* <p>
		65	* Conversion:<br/>
		66	* A {@link IConverter converter} will convert the value from the type of the
		67	* source observable into the type of the destination. The strategy has the
		68	* ability to default converters for common scenarios.
		69	* </p>
		70	* <p>
		71	* Automatic processing:<br/>
		72	* The processing to perform when the source observable changes. This behavior
		73	* is configured via policies provided on construction of the strategy (e.g.
		74	* {@link #POLICY_NEVER}, {@link #POLICY_CONVERT}, {@link #POLICY_ON_REQUEST},
		75	* {@link #POLICY_UPDATE}).
		76	* </p>
		77	*
		78	* @see DataBindingContext#bindValue(IObservableValue, IObservableValue,
		79	* UpdateValueStrategy, UpdateValueStrategy)
		80	* @see Binding#getValidationStatus()
		81	* @see IValidator
		82	* @see IConverter
		83	* @since 1.0
32	*/	84	*/
33	public class EMFUpdateValueStrategy extends UpdateValueStrategy	85	public class EMFUpdateValueStrategy extends UpdateValueStrategy {
34	{	86	/**
35	public EMFUpdateValueStrategy()	87	* Creates a new update value strategy for automatically updating the
36	{	88	* destination observable value whenever the source observable value
37	this(true, POLICY_UPDATE);	89	* changes. Default validators and a default converter will be provided. The
38	}	90	* defaults can be changed by calling one of the setter methods.
		91	*/
		92	public EMFUpdateValueStrategy() {
		93	this(true, POLICY_UPDATE);
		94	}
		95
		96	/**
		97	* Creates a new update value strategy with a configurable update policy.
		98	* Default validators and a default converter will be provided. The defaults
		99	* can be changed by calling one of the setter methods.
		100	*
		101	* @param updatePolicy
		102	* one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST},
		103	* {@link #POLICY_CONVERT}, or {@link #POLICY_UPDATE}
		104	*/
		105	public EMFUpdateValueStrategy(int updatePolicy) {
		106	this(true, updatePolicy);
		107	}
39		108
40	public EMFUpdateValueStrategy(int updatePolicy)	109	/**
41	{	110	* Creates a new update value strategy with a configurable update policy.
42	this(true, updatePolicy);	111	* Default validators and a default converter will be provided if
43	}	112	* <code>provideDefaults</code> is <code>true</code>. The defaults can
		113	* be changed by calling one of the setter methods.
		114	*
		115	* @param provideDefaults
		116	* if <code>true</code>, default validators and a default
		117	* converter will be provided based on the observable value's
		118	* type.
		119	* @param updatePolicy
		120	* one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST},
		121	* {@link #POLICY_CONVERT}, or {@link #POLICY_UPDATE}
		122	*/
		123	public EMFUpdateValueStrategy(boolean provideDefaults, int updatePolicy) {
		124	super(provideDefaults, updatePolicy);
		125	}
44		126
45	public EMFUpdateValueStrategy(boolean provideDefaults, int updatePolicy)	127	@Override
46	{	128	protected IConverter createConverter(Object fromType, Object toType) {
47	super(provideDefaults, updatePolicy);	129	if (fromType == String.class) {
48	}	130	if (toType instanceof EAttribute) {
49		131	final EAttribute eAttribute = (EAttribute) toType;
50	@Override	132	final EDataType eDataType = eAttribute.getEAttributeType();
51	protected IConverter createConverter(Object fromType, Object toType)	133	final EFactory eFactory = eDataType.getEPackage()
52	{	134	.getEFactoryInstance();
53	if (fromType == String.class)	135	return new Converter(fromType, toType) {
54	{	136	public Object convert(Object fromObject) {
55	if (toType instanceof EAttribute)	137	String value = fromObject == null ? null : fromObject
56	{	138	.toString();
57	final EAttribute eAttribute = (EAttribute)toType;	139	if (eAttribute.isMany()) {
58	final EDataType eDataType = eAttribute.getEAttributeType();	140	List<Object> result = new ArrayList<Object>();
59	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();	141	if (value != null) {
60	return	142	for (String element : value.split(" ")) {
61	new Converter(fromType, toType)	143	result.add(eFactory.createFromString(
62	{	144	eDataType, element));
63	public Object convert(Object fromObject)	145	}
64	{	146	}
65	String value = fromObject == null ? null : fromObject.toString();	147	return result;
66	if (eAttribute.isMany())	148	} else {
67	{	149	return eFactory.createFromString(eDataType, value);
68	List<Object> result = new ArrayList<Object>();	150	}
69	if (value != null)	151	}
70	{	152	};
71	for (String element : value.split(" "))	153	}
72	{	154	} else if (toType == String.class) {
73	result.add(eFactory.createFromString(eDataType, element));	155	if (fromType instanceof EAttribute) {
74	}	156	final EAttribute eAttribute = (EAttribute) fromType;
75	}	157	final EDataType eDataType = eAttribute.getEAttributeType();
76	return result;	158	final EFactory eFactory = eDataType.getEPackage()
77	}	159	.getEFactoryInstance();
78	else	160	return new Converter(fromType, toType) {
79	{	161	public Object convert(Object fromObject) {
80	return eFactory.createFromString(eDataType, value);	162	if (eAttribute.isMany()) {
81	}	163	StringBuilder result = new StringBuilder();
82	}	164	for (Object value : (List<?>) fromObject) {
83	};	165	if (result.length() == 0) {
84	}	166	result.append(' ');
85	}	167	}
86	else if (toType == String.class)	168	result.append(eFactory.convertToString(
87	{	169	eDataType, value));
88	if (fromType instanceof EAttribute)	170	}
89	{	171	return result.toString();
90	final EAttribute eAttribute = (EAttribute)fromType;	172	} else {
91	final EDataType eDataType = eAttribute.getEAttributeType();	173	return eFactory.convertToString(eDataType,
92	final EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();	174	fromObject);
93	return	175	}
94	new Converter(fromType, toType)	176	}
95	{	177	};
96	public Object convert(Object fromObject)	178	}
97	{	179	}
98	if (eAttribute.isMany())	180	return super.createConverter(fromType, toType);
99	{	181	}
100	StringBuilder result = new StringBuilder();
101	for (Object value : (List<?>)fromObject)
102	{
103	if (result.length() == 0)
104	{
105	result.append(' ');
106	}
107	result.append(eFactory.convertToString(eDataType, value));
108	}
109	return result.toString();
110	}
111	else
112	{
113	return eFactory.convertToString(eDataType, fromObject);
114	}
115	}
116	};
117	}
118	}
119	return super.createConverter(fromType, toType);
120	}
121	}	182	}




 *
 * Contributors:
 *   IBM - Initial API and implementation
 *   Tom Schindl<tom.schindl@bestsolution.at>
 * </copyright>
 *
 * $Id: EObjectObservableList.java,v 1.4 2008/02/21 15:26:16 emerks Exp $

import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 */
public class EObjectObservableList extends ObservableList implements
		IObserving, InternalRawEList {
	protected EObject eObject;
	protected EStructuralFeature eStructuralFeature;
	protected Adapter listener;

	public EObjectObservableList(EObject eObject,
			EStructuralFeature eStructuralFeature) {
		this(Realm.getDefault(), eObject, eStructuralFeature);
	}

	public EObjectObservableList(Realm realm, EObject eObject,
			EStructuralFeature eStructuralFeature) {
		super(realm, (EList<?>) eObject.eGet(eStructuralFeature),
				eStructuralFeature);
		this.eObject = eObject;
		this.eStructuralFeature = eStructuralFeature;
	}

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

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

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

	@SuppressWarnings("unchecked")
	protected final List<Object> wrappedList() {
		return wrappedList;
	}

	public Object getObserved() {
		return eObject;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		result.append(" (wrappedList: ");
		result.append(wrappedList);
		result.append(")");
    StringBuilder result = new StringBuilder(getClass().getName());
    result.append('@');
    result.append(Integer.toHexString(hashCode()));

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

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

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

		return result.toString();
	}
}

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




 * 
 * Contributors: 
 *   IBM - Initial API and implementation
 *   Tom Schindl<tom.schindl@bestsolution.at>
 * </copyright>
 *
 * $Id: EObjectObservableMap.java,v 1.4 2008/10/21 11:03:56 emerks Exp $

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 */
public class EObjectObservableMap extends ComputedObservableMap {
	protected EStructuralFeature eStructuralFeature;

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

	public EObjectObservableMap(IObservableSet objects,
			EStructuralFeature feature) {
		super(objects);
		this.eStructuralFeature = feature;
	}

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

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

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

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

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




 *
 * Contributors:
 *   IBM - Initial API and implementation
 *   Tom Schindl<tom.schindl@bestsolution.at>
 * </copyright>
 *
 * $Id: EObjectObservableValue.java,v 1.2 2008/01/26 21:01:07 emerks Exp $

import org.eclipse.emf.ecore.EStructuralFeature;

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

	public EObjectObservableValue(EObject eObject,
			EStructuralFeature eStructuralFeature) {
		this(Realm.getDefault(), eObject, eStructuralFeature);
	}

	public EObjectObservableValue(Realm realm, EObject eObject,
			EStructuralFeature eStructuralFeature) {
		super(realm);
		this.eObject = eObject;
		this.eStructuralFeature = eStructuralFeature;
	}

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

	public Object getObserved() {
		return eObject;
	}

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

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

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

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

	public Object getValueType() {
		return eStructuralFeature;
	}

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

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

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

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

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

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

		return result.toString();
	}
}

Return to bug 262160

Lines 9-51 Link Here

(-)src/org/eclipse/emf/databinding/EMFDataBindingContext.java (-24 / +65 lines)
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
12	*	12	* Tom Schindl<tom.schindl@bestsolution.at>
13	* </copyright>	13	* </copyright>
14	*	14	*
15	* $Id: EMFDataBindingContext.java,v 1.1 2007/11/16 21:25:21 emerks Exp $	15	* $Id: EMFDataBindingContext.java,v 1.1 2007/11/16 21:25:21 emerks Exp $
16	*/	16	*/
17	package org.eclipse.emf.databinding;	17	package org.eclipse.emf.databinding;
18		18
		19	import org.eclipse.core.databinding.Binding;
19	import org.eclipse.core.databinding.DataBindingContext;	20	import org.eclipse.core.databinding.DataBindingContext;
20	import org.eclipse.core.databinding.UpdateValueStrategy;	21	import org.eclipse.core.databinding.UpdateValueStrategy;
21	import org.eclipse.core.databinding.observable.Realm;	22	import org.eclipse.core.databinding.observable.Realm;
		23	import org.eclipse.core.databinding.observable.list.IObservableList;
22	import org.eclipse.core.databinding.observable.value.IObservableValue;	24	import org.eclipse.core.databinding.observable.value.IObservableValue;
23		25
24	/**	26	/**
25	* PROVISIONAL	27	* <p>
26	* This API is subject to arbitrary change, including renaming or removal.	28	* <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
		29	* removal.</b>
		30	* </p>
		31	*
		32	* A DataBindingContext is the point of contact for the creation and management
		33	* of {@link Binding bindings}, and aggregates validation statuses of its
		34	* bindings, or more generally, its validation status providers.
		35	* <p>
		36	* A DataBindingContext provides the following abilities:
		37	* <ul>
		38	* <li>Ability to create bindings between {@link IObservableValue observable
		39	* values}.</li>
		40	* <li>Ability to create bindings between {@link IObservableList observable
		41	* lists}.</li>
		42	* <li>Access to the bindings created by the instance.</li>
		43	* <li>Access to the list of validation status providers (this includes all
		44	* bindings).</li>
		45	* </ul>
		46	* </p>
		47	* <p>
		48	* Multiple contexts can be used at any point in time. One strategy for the
		49	* management of contexts is the aggregation of validation statuses. For example
		50	* an <code>IWizardPage</code> could use a single context and the statuses could
		51	* be aggregated to set the page status and fulfillment. Each page in the
		52	* <code>IWizard</code> would have its own context instance.
		53	* </p>
		54	*
		55	* @since 1.0
27	*/	56	*/
28	public class EMFDataBindingContext extends DataBindingContext	57	public class EMFDataBindingContext extends DataBindingContext {
29	{	58	/**
30	public EMFDataBindingContext()	59	* Creates a data binding context, using the current default realm for the
31	{	60	* validation observables.
32	this(Realm.getDefault());	61	*
33	}	62	* @see Realm
		63	*/
		64	public EMFDataBindingContext() {
		65	this(Realm.getDefault());
		66	}
		67
		68	/**
		69	* Creates a data binding context using the given realm for the validation
		70	* observables.
		71	*
		72	* @param validationRealm
		73	* the realm to be used for the validation observables
		74	*
		75	* @see Realm
		76	*/
		77	public EMFDataBindingContext(Realm validationRealm) {
		78	super(validationRealm);
		79	}
34		80
35	public EMFDataBindingContext(Realm validationRealm)	81	@Override
36	{	82	protected UpdateValueStrategy createModelToTargetUpdateValueStrategy(
37	super(validationRealm);	83	IObservableValue fromValue, IObservableValue toValue) {
38	}	84	return new EMFUpdateValueStrategy();
		85	}
39		86
40	@Override	87	@Override
41	protected UpdateValueStrategy createModelToTargetUpdateValueStrategy(IObservableValue fromValue, IObservableValue toValue)	88	protected UpdateValueStrategy createTargetToModelUpdateValueStrategy(
42	{	89	IObservableValue fromValue, IObservableValue toValue) {
43	return new EMFUpdateValueStrategy();	90	return new EMFUpdateValueStrategy();
44	}	91	}
45
46	@Override
47	protected UpdateValueStrategy createTargetToModelUpdateValueStrategy(IObservableValue fromValue, IObservableValue toValue)
48	{
49	return new EMFUpdateValueStrategy();
50	}
51	}	92	}

Lines 10-23 Link Here

(-)src/org/eclipse/emf/databinding/EMFObservables.java (-162 / +219 lines)
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
12	* Trevor S. Kaufman - Bug 215131 - added mapFactory	12	* Trevor S. Kaufman - Bug 215131 - added mapFactory
13	*	13	* Tom Schindl<tom.schindl@bestsolution.at>
14	* </copyright>	14	* </copyright>
15	*	15	*
16	* $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $	16	* $Id: EMFObservables.java,v 1.3 2008/04/22 13:36:00 emerks Exp $
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-194 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;
31		33
32	/**	34	/**
33	* PROVISIONAL	35	* <p>
34	* This API is subject to arbitrary change, including renaming or removal.	36	* <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
		37	* removal.</b>
		38	* </p>
		39	* A factory for creating observable objects of Java objects that conform to the
		40	* <a href="http://java.sun.com/products/javabeans/docs/spec.html">JavaBean
		41	* specification</a> for bound properties.
		42	*
		43	* @since 1.0
35	*/	44	*/
36	public class EMFObservables	45	public class EMFObservables {
37	{	46	/**
38	/**	47	*
39	* Returns an observable value for the given feature of the object.	48	*/
40	* @param eObject the object to observe.	49	public static final boolean DEBUG = false;
41	* @param eStructuralFeature the feature of the object to observe.	50
42	* @return an observable value for the given feature of the object.	51	/**
43	*/	52	* Returns an observable value for the given feature of the object.
44	public static IObservableValue observeValue(EObject eObject, EStructuralFeature eStructuralFeature)	53	*
45	{	54	* @param eObject
46	return new EObjectObservableValue(eObject, eStructuralFeature);	55	* the object to observe.
47	}	56	* @param eStructuralFeature
48		57	* the feature of the object to observe.
49	/**	58	* @return an observable value for the given feature of the object.
50	* Returns an observable value for the given feature of the object.	59	*/
51	* @param realm the realm in which to observe.	60	public static IObservableValue observeValue(EObject eObject,
52	* @param eObject the object to observe.	61	EStructuralFeature eStructuralFeature) {
53	* @param eStructuralFeature the feature of the object to observe.	62	return new EObjectObservableValue(eObject, eStructuralFeature);
54	* @return an observable value for the given feature of the object.	63	}
55	*/	64
56	public static IObservableValue observeValue(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)	65	/**
57	{	66	* Returns an observable value for the given feature of the object.
58	return new EObjectObservableValue(realm, eObject, eStructuralFeature);	67	*
59	}	68	* @param realm
60		69	* the realm in which to observe.
61	/**	70	* @param eObject
62	* Returns an observable list for the given multi-valued feature of the object.	71	* the object to observe.
63	* @param eObject the object to observe.	72	* @param eStructuralFeature
64	* @param eStructuralFeature the feature of the object to observe.	73	* the feature of the object to observe.
65	* @return an observable list for the given multi-valued feature of the object.	74	* @return an observable value for the given feature of the object.
66	*/	75	*/
67	public static IObservableList observeList(EObject eObject, EStructuralFeature eStructuralFeature)	76	public static IObservableValue observeValue(Realm realm, EObject eObject,
68	{	77	EStructuralFeature eStructuralFeature) {
69	return new EObjectObservableList(eObject, eStructuralFeature);	78	return new EObjectObservableValue(realm, eObject, eStructuralFeature);
70	}	79	}
71		80
72	/**	81	/**
73	* Returns an observable list for the given multi-valued feature of the object.	82	* Returns an observable list for the given multi-valued feature of the
74	* @param realm the realm in which to observe.	83	* object.
75	* @param eObject the object to observe.	84	*
76	* @param eStructuralFeature the feature of the object to observe.	85	* @param eObject
77	* @return an observable list for the given multi-valued feature of the object.	86	* the object to observe.
78	*/	87	* @param eStructuralFeature
79	public static IObservableList observeList(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)	88	* the feature of the object to observe.
80	{	89	* @return an observable list for the given multi-valued feature of the
81	return new EObjectObservableList(realm, eObject, eStructuralFeature);	90	* object.
82	}	91	*/
83		92	public static IObservableList observeList(EObject eObject,
84	/**	93	EStructuralFeature eStructuralFeature) {
85	* Returns an observable map in the default realm	94	return new EObjectObservableList(eObject, eStructuralFeature);
86	* tracking the current value of the given feature for each object in the given set.	95	}
87	* @param objects the objects to track.	96
88	* @param eStructuralFeature the feature for which to track the value.	97	/**
89	* @return an observable map tracking the current value of the given feature for each object in the given set.	98	* Returns an observable list for the given multi-valued feature of the
90	*/	99	* object.
91	public static IObservableMap observeMap(IObservableSet objects, EStructuralFeature eStructuralFeature)	100	*
92	{	101	* @param realm
93	return new EObjectObservableMap(objects, eStructuralFeature);	102	* the realm in which to observe.
94	}	103	* @param eObject
95		104	* the object to observe.
96	/**	105	* @param eStructuralFeature
97	* Returns an array of observable maps in the default realm	106	* the feature of the object to observe.
98	* tracking the current value of the given features for each object in the given set.	107	* @return an observable list for the given multi-valued feature of the
99	* @param objects the objects to track.	108	* object.
100	* @param eStructuralFeatures the features for which to track the value.	109	*/
101	* @return an array of observable maps tracking the current value of the given features for each object in the given set.	110	public static IObservableList observeList(Realm realm, EObject eObject,
102	*/	111	EStructuralFeature eStructuralFeature) {
103	public static IObservableMap[] observeMaps(IObservableSet objects, EStructuralFeature[] eStructuralFeatures)	112	return new EObjectObservableList(realm, eObject, eStructuralFeature);
104	{	113	}
105	IObservableMap[] result = new IObservableMap [eStructuralFeatures.length];	114
106	for (int i = 0; i < eStructuralFeatures.length; i++)	115	/**
107	{	116	* Returns an observable map in the default realm tracking the current value
108	result[i] = observeMap(objects, eStructuralFeatures[i]);	117	* of the given feature for each object in the given set.
109	}	118	*
110	return result;	119	* @param objects
111	}	120	* the objects to track.
112		121	* @param eStructuralFeature
113	/**	122	* the feature for which to track the value.
114	* Returns an observable value that tracks the current value of the feature of the current value of the master observable value.	123	* @return an observable map tracking the current value of the given feature
115	* @param realm the realm in which to observe.	124	* for each object in the given set.
116	* @param value the master observable value.	125	*/
117	* @param eStructuralFeature the feature for which to track the value.	126	public static IObservableMap observeMap(IObservableSet objects,
118	* @return an observable value that tracks the current value of the named property for the current value of the master observable value	127	EStructuralFeature eStructuralFeature) {
119	* @see MasterDetailObservables#detailValue(IObservableValue, IObservableFactory, Object)	128	return new EObjectObservableMap(objects, eStructuralFeature);
120	*/	129	}
121	public static IObservableValue observeDetailValue(Realm realm, IObservableValue value, EStructuralFeature eStructuralFeature)	130
122	{	131	/**
123	return MasterDetailObservables.detailValue(value, valueFactory(realm, eStructuralFeature), eStructuralFeature);	132	* Returns an array of observable maps in the default realm tracking the
124	}	133	* current value of the given features for each object in the given set.
125		134	*
126	/**	135	* @param objects
127	* Returns a factory for creating observable values	136	* the objects to track.
128	* tracking the value of the given feature of a particular {@link EObject object}.	137	* @param eStructuralFeatures
129	* @param realm the realm in which to observe.	138	* the features for which to track the value.
130	* @param eStructuralFeature the feature for which to track the value.	139	* @return an array of observable maps tracking the current value of the
131	* @return an observable factory.	140	* given features for each object in the given set.
132	*/	141	*/
133	public static IObservableFactory valueFactory(final Realm realm, final EStructuralFeature eStructuralFeature)	142	public static IObservableMap[] observeMaps(IObservableSet objects,
134	{	143	EStructuralFeature[] eStructuralFeatures) {
135	return	144	IObservableMap[] result = new IObservableMap[eStructuralFeatures.length];
136	new IObservableFactory()	145	for (int i = 0; i < eStructuralFeatures.length; i++) {
137	{	146	result[i] = observeMap(objects, eStructuralFeatures[i]);
138	public IObservable createObservable(Object target)	147	}
139	{	148	return result;
140	return observeValue(realm, (EObject)target, eStructuralFeature);	149	}
141	}	150
142	};	151	/**
143	}	152	* Returns an observable value that tracks the current value of the feature
144		153	* of the current value of the master observable value.
145	/**	154	*
146	* Returns an observable list that tracks the current value of the feature of the current value of the master observable value.	155	* @param realm
147	* @param realm the realm in which to observe.	156	* the realm in which to observe.
148	* @param value the master observable value.	157	* @param value
149	* @param eStructuralFeature the feature for which to track the value.	158	* the master observable value.
150	* @return an observable value that tracks the current value of the named property for the current value of the master observable value	159	* @param eStructuralFeature
151	* @see MasterDetailObservables#detailList(IObservableValue, IObservableFactory, Object)	160	* the feature for which to track the value.
152	*/	161	* @return an observable value that tracks the current value of the named
153	public static IObservableList observeDetailList(Realm realm, IObservableValue value, EStructuralFeature eStructuralFeature)	162	* property for the current value of the master observable value
154	{	163	* @see MasterDetailObservables#detailValue(IObservableValue,
155	return MasterDetailObservables.detailList(value, listFactory(realm, eStructuralFeature), eStructuralFeature);	164	* IObservableFactory, Object)
156	}	165	*/
157		166	public static IObservableValue observeDetailValue(Realm realm,
158	/**	167	IObservableValue value, EStructuralFeature eStructuralFeature) {
159	* Returns a factory for creating observable lists	168	return MasterDetailObservables.detailValue(value, valueFactory(realm,
160	* tracking the value of the given feature of a particular {@link EObject object}.	169	eStructuralFeature), eStructuralFeature);
161	* @param realm the realm in which to observe.	170	}
162	* @param eStructuralFeature the feature for which to track the value.	171
163	* @return an observable factory.	172	/**
164	*/	173	* Returns a factory for creating observable values tracking the value of
165	public static IObservableFactory listFactory(final Realm realm, final EStructuralFeature eStructuralFeature)	174	* the given feature of a particular {@link EObject object}.
166	{	175	*
167	return	176	* @param realm
168	new IObservableFactory()	177	* the realm in which to observe.
169	{	178	* @param eStructuralFeature
170	public IObservable createObservable(Object target)	179	* the feature for which to track the value.
171	{	180	* @return an observable factory.
172	return observeList(realm, (EObject)target, eStructuralFeature);	181	*/
173	}	182	public static IObservableFactory valueFactory(final Realm realm,
174	};	183	final EStructuralFeature eStructuralFeature) {
175	}	184	return new IObservableFactory() {
176		185	public IObservable createObservable(Object target) {
177	/**	186	return observeValue(realm, (EObject) target, eStructuralFeature);
178	* Returns a factory for creating observable maps	187	}
179	* tracking the value of the given feature of a particular {@link EObject object}.	188	};
180	* @param eStructuralFeature the feature for which to track the value.	189	}
181	* @return an observable factory.	190
182	*/	191	/**
183	public static IObservableFactory mapFactory(final EStructuralFeature eStructuralFeature)	192	* Returns an observable list that tracks the current value of the feature
184	{	193	* of the current value of the master observable value.
185	return	194	*
186	new IObservableFactory()	195	* @param realm
187	{	196	* the realm in which to observe.
188	public IObservable createObservable(Object target)	197	* @param value
189	{	198	* the master observable value.
190	return observeMap((IObservableSet)target, eStructuralFeature);	199	* @param eStructuralFeature
191	}	200	* the feature for which to track the value.
192	};	201	* @return an observable value that tracks the current value of the named
193	}	202	* property for the current value of the master observable value
		203	* @see MasterDetailObservables#detailList(IObservableValue,
		204	* IObservableFactory, Object)
		205	*/
		206	public static IObservableList observeDetailList(Realm realm,
		207	IObservableValue value, EStructuralFeature eStructuralFeature) {
		208	return MasterDetailObservables.detailList(value, listFactory(realm,
		209	eStructuralFeature), eStructuralFeature);
		210	}
		211
		212	/**
		213	* Returns a factory for creating observable lists tracking the value of the
		214	* given feature of a particular {@link EObject object}.
		215	*
		216	* @param realm
		217	* the realm in which to observe.
		218	* @param eStructuralFeature
		219	* the feature for which to track the value.
		220	* @return an observable factory.
		221	*/
		222	public static IObservableFactory listFactory(final Realm realm,
		223	final EStructuralFeature eStructuralFeature) {
		224	return new IObservableFactory() {
		225	public IObservable createObservable(Object target) {
		226	return observeList(realm, (EObject) target, eStructuralFeature);
		227	}
		228	};
		229	}
		230
		231	/**
		232	* Returns a factory for creating observable maps tracking the value of the
		233	* given feature of a particular {@link EObject object}.
		234	*
		235	* @param eStructuralFeature
		236	* the feature for which to track the value.
		237	* @return an observable factory.
		238	*/
		239	public static IObservableFactory mapFactory(
		240	final EStructuralFeature eStructuralFeature) {
		241	return new IObservableFactory() {
		242	public IObservable createObservable(Object target) {
		243	return observeMap((IObservableSet) target, eStructuralFeature);
		244	}
		245	};
		246	}
		247
		248	public static IObservableList observeResourceContents(Resource resource) {
		249	return new EWritableList<EObject>((NotifyingList<EObject>) resource.getContents());
		250	}
194	}	251	}

Lines 9-15 Link Here

(-)src/org/eclipse/emf/databinding/EObjectObservableList.java (-254 / +241 lines)
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
12	*	12	* Tom Schindl<tom.schindl@bestsolution.at>
13	* </copyright>	13	* </copyright>
14	*	14	*
15	* $Id: EObjectObservableList.java,v 1.4 2008/02/21 15:26:16 emerks Exp $	15	* $Id: EObjectObservableList.java,v 1.4 2008/02/21 15:26:16 emerks Exp $
Lines 33-294 Link Here
33	import org.eclipse.emf.ecore.EStructuralFeature;	33	import org.eclipse.emf.ecore.EStructuralFeature;
34		34
35	/**	35	/**
36	* PROVISIONAL	36	* <p>
37	* This API is subject to arbitrary change, including renaming or removal.	37	* <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
		38	* removal.</b>
		39	* </p>
38	*/	40	*/
39	public class EObjectObservableList extends ObservableList implements IObserving, InternalRawEList	41	public class EObjectObservableList extends ObservableList implements
40	{	42	IObserving, InternalRawEList {
41	protected EObject eObject;	43	protected EObject eObject;
42	protected EStructuralFeature eStructuralFeature;	44	protected EStructuralFeature eStructuralFeature;
43	protected Adapter listener;	45	protected Adapter listener;
44		46
45	public EObjectObservableList(EObject eObject, EStructuralFeature eStructuralFeature)	47	public EObjectObservableList(EObject eObject,
46	{	48	EStructuralFeature eStructuralFeature) {
47	this(Realm.getDefault(), eObject, eStructuralFeature);	49	this(Realm.getDefault(), eObject, eStructuralFeature);
48	}	50	}
49		51
50	public EObjectObservableList(Realm realm, EObject eObject, EStructuralFeature eStructuralFeature)	52	public EObjectObservableList(Realm realm, EObject eObject,
51	{	53	EStructuralFeature eStructuralFeature) {
52	super(realm, (EList<?>)eObject.eGet(eStructuralFeature), eStructuralFeature);	54	super(realm, (EList<?>) eObject.eGet(eStructuralFeature),
53	this.eObject = eObject;	55	eStructuralFeature);
54	this.eStructuralFeature = eStructuralFeature;	56	this.eObject = eObject;
55	}	57	this.eStructuralFeature = eStructuralFeature;
56		58	}
57	@Override	59
58	protected void firstListenerAdded()	60	@Override
59	{	61	protected void firstListenerAdded() {
60	listener =	62	listener = new AdapterImpl() {
61	new AdapterImpl()	63	@Override
62	{	64	public void notifyChanged(Notification notification) {
63	@Override	65	if (eStructuralFeature == notification.getFeature()
64	public void notifyChanged(Notification notification)	66	&& !notification.isTouch()) {
65	{	67	final ListDiff diff;
66	if (eStructuralFeature == notification.getFeature() && !notification.isTouch())	68	switch (notification.getEventType()) {
67	{	69	case Notification.ADD: {
68	final ListDiff diff;	70	diff = Diffs.createListDiff(Diffs.createListDiffEntry(
69	switch (notification.getEventType())	71	notification.getPosition(), true, notification
70	{	72	.getNewValue()));
71	case Notification.ADD:	73	break;
72	{	74	}
73	diff = Diffs.createListDiff(Diffs.createListDiffEntry(notification.getPosition(), true, notification.getNewValue()));	75	case Notification.ADD_MANY: {
74	break;	76	Collection<?> newValues = (Collection<?>) notification
75	}	77	.getNewValue();
76	case Notification.ADD_MANY:	78	ListDiffEntry[] listDiffEntries = new ListDiffEntry[newValues
77	{	79	.size()];
78	Collection<?> newValues = (Collection<?>)notification.getNewValue();	80	int position = notification.getPosition();
79	ListDiffEntry [] listDiffEntries = new ListDiffEntry [newValues.size()];	81	int index = 0;
80	int position = notification.getPosition();	82	for (Object newValue : newValues) {
81	int index = 0;	83	listDiffEntries[index++] = Diffs
82	for (Object newValue : newValues)	84	.createListDiffEntry(position++, true,
83	{	85	newValue);
84	listDiffEntries[index++] = Diffs.createListDiffEntry(position++, true, newValue);	86	}
85	}	87	diff = Diffs.createListDiff(listDiffEntries);
86	diff = Diffs.createListDiff(listDiffEntries);	88	break;
87	break;	89	}
88	}	90	case Notification.REMOVE: {
89	case Notification.REMOVE:	91	diff = Diffs.createListDiff(Diffs.createListDiffEntry(
90	{	92	notification.getPosition(), false, notification
91	diff = Diffs.createListDiff(Diffs.createListDiffEntry(notification.getPosition(), false, notification.getOldValue()));	93	.getOldValue()));
92	break;	94	break;
93	}	95	}
94	case Notification.REMOVE_MANY:	96	case Notification.REMOVE_MANY: {
95	{	97	Collection<?> oldValues = (Collection<?>) notification
96	Collection<?> oldValues = (Collection<?>)notification.getOldValue();	98	.getOldValue();
97	ListDiffEntry [] listDiffEntries = new ListDiffEntry [oldValues.size()];	99	ListDiffEntry[] listDiffEntries = new ListDiffEntry[oldValues
98	int position = notification.getPosition();	100	.size()];
99	int index = 0;	101	int position = notification.getPosition();
100	for (Object oldValue : oldValues)	102	int index = 0;
101	{	103	for (Object oldValue : oldValues) {
102	listDiffEntries[index++] = Diffs.createListDiffEntry(position++, false, oldValue);	104	listDiffEntries[index++] = Diffs
103	}	105	.createListDiffEntry(position++, false,
104	diff = Diffs.createListDiff(listDiffEntries);	106	oldValue);
105	break;	107	}
106	}	108	diff = Diffs.createListDiff(listDiffEntries);
107	case Notification.SET:	109	break;
108	case Notification.RESOLVE:	110	}
109	{	111	case Notification.SET:
110	ListDiffEntry [] listDiffEntries = new ListDiffEntry [2];	112	case Notification.RESOLVE: {
111	listDiffEntries[0] = Diffs.createListDiffEntry(notification.getPosition(), false, notification.getOldValue());	113	ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
112	listDiffEntries[1] = Diffs.createListDiffEntry(notification.getPosition(), true, notification.getNewValue());	114	listDiffEntries[0] = Diffs.createListDiffEntry(
113	diff = Diffs.createListDiff(listDiffEntries);	115	notification.getPosition(), false, notification
114	break;	116	.getOldValue());
115	}	117	listDiffEntries[1] = Diffs.createListDiffEntry(
116	case Notification.MOVE:	118	notification.getPosition(), true, notification
117	{	119	.getNewValue());
118	Object movedValue = notification.getNewValue();	120	diff = Diffs.createListDiff(listDiffEntries);
119	ListDiffEntry [] listDiffEntries = new ListDiffEntry [2];	121	break;
120	listDiffEntries[0] = Diffs.createListDiffEntry((Integer)notification.getOldValue(), false, movedValue);	122	}
121	listDiffEntries[1] = Diffs.createListDiffEntry(notification.getPosition(), true, movedValue);	123	case Notification.MOVE: {
122	diff = Diffs.createListDiff(listDiffEntries);	124	Object movedValue = notification.getNewValue();
123	break;	125	ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
124	}	126	listDiffEntries[0] = Diffs.createListDiffEntry(
125	case Notification.UNSET:	127	(Integer) notification.getOldValue(), false,
126	{	128	movedValue);
127	// This just represents going back to the unset state, but that doesn't affect the contents of the list.	129	listDiffEntries[1] = Diffs.createListDiffEntry(
128	//	130	notification.getPosition(), true, movedValue);
129	return;	131	diff = Diffs.createListDiff(listDiffEntries);
130	}	132	break;
131	default:	133	}
132	{	134	case Notification.UNSET: {
133	throw new RuntimeException("unhandled case");	135	// This just represents going back to the unset state,
134	}	136	// but that doesn't affect the contents of the list.
135	}	137	//
136	getRealm().exec	138	return;
137	(new Runnable()	139	}
138	{	140	default: {
139	public void run()	141	throw new RuntimeException("unhandled case");
140	{	142	}
141	fireListChange(diff);	143	}
142	}	144	getRealm().exec(new Runnable() {
143	});	145	public void run() {
144	}	146	fireListChange(diff);
145	}	147	}
146	};	148	});
147	eObject.eAdapters().add(listener);	149	}
148	}	150	}
149		151	};
150	@Override	152	eObject.eAdapters().add(listener);
151	protected void lastListenerRemoved()	153	}
152	{	154
153	eObject.eAdapters().remove(listener);	155	@Override
154	listener = null;	156	protected void lastListenerRemoved() {
155	}	157	eObject.eAdapters().remove(listener);
156		158	listener = null;
157	@Override	159	}
158	public synchronized void dispose()	160
159	{	161	@Override
160	if (listener != null)	162	public synchronized void dispose() {
161	{	163	if (listener != null) {
162	eObject.eAdapters().remove(listener);	164	eObject.eAdapters().remove(listener);
163	listener = null;	165	listener = null;
164	}	166	}
165	eObject = null;	167	eObject = null;
166	eStructuralFeature = null;	168	eStructuralFeature = null;
167	super.dispose();	169	super.dispose();
168	}	170	}
169		171
170	@SuppressWarnings("unchecked")	172	@SuppressWarnings("unchecked")
171	protected final List<Object> wrappedList()	173	protected final List<Object> wrappedList() {
172	{	174	return wrappedList;
173	return wrappedList;	175	}
174	}	176
175		177	public Object getObserved() {
176	public Object getObserved()	178	return eObject;
177	{	179	}
178	return eObject;	180
179	}	181	@Override
180		182	public boolean add(Object object) {
181	@Override	183	checkRealm();
182	public boolean add(Object object)	184	return wrappedList().add(object);
183	{	185	}
184	checkRealm();	186
185	return wrappedList().add(object);	187	@Override
186	}	188	public void add(int index, Object object) {
187		189	checkRealm();
188	@Override	190	wrappedList().add(index, object);
189	public void add(int index, Object object)	191	}
190	{	192
191	checkRealm();	193	@SuppressWarnings("unchecked")
192	wrappedList().add(index, object);	194	@Override
193	}	195	public boolean addAll(Collection collection) {
194		196	checkRealm();
195	@SuppressWarnings("unchecked")	197	return wrappedList().addAll(collection);
196	@Override	198	}
197	public boolean addAll(Collection collection)	199
198	{	200	@SuppressWarnings("unchecked")
199	checkRealm();	201	@Override
200	return wrappedList().addAll(collection);	202	public boolean addAll(int index, Collection collection) {
201	}	203	checkRealm();
202		204	return wrappedList().addAll(index, collection);
203	@SuppressWarnings("unchecked")	205	}
204	@Override	206
205	public boolean addAll(int index, Collection collection)	207	@Override
206	{	208	public Object set(int index, Object element) {
207	checkRealm();	209	checkRealm();
208	return wrappedList().addAll(index, collection);	210	return wrappedList().set(index, element);
209	}	211	}
210		212
211	@Override	213	@Override
212	public Object set(int index, Object element)	214	public Object remove(int index) {
213	{	215	checkRealm();
214	checkRealm();	216	return wrappedList.remove(index);
215	return wrappedList().set(index, element);	217	}
216	}	218
217		219	@Override
218	@Override	220	public boolean remove(Object element) {
219	public Object remove(int index)	221	checkRealm();
220	{	222	return wrappedList.remove(element);
221	checkRealm();	223	}
222	return wrappedList.remove(index);	224
223	}	225	@SuppressWarnings("unchecked")
224		226	@Override
225	@Override	227	public boolean removeAll(Collection collection) {
226	public boolean remove(Object element)	228	checkRealm();
227	{	229	return wrappedList().removeAll(collection);
228	checkRealm();	230	}
229	return wrappedList.remove(element);	231
230	}	232	@SuppressWarnings("unchecked")
231		233	@Override
232	@SuppressWarnings("unchecked")	234	public boolean retainAll(Collection collection) {
233	@Override	235	checkRealm();
234	public boolean removeAll(Collection collection)	236	return wrappedList().retainAll(collection);
235	{	237	}
236	checkRealm();	238
237	return wrappedList().removeAll(collection);	239	@Override
238	}	240	public void clear() {
239		241	checkRealm();
240	@SuppressWarnings("unchecked")	242	wrappedList.clear();
241	@Override	243	}
242	public boolean retainAll(Collection collection)	244
243	{	245	@Override
244	checkRealm();	246	public Object move(int newPosition, int oldPosition) {
245	return wrappedList().retainAll(collection);	247	checkRealm();
246	}	248	return ((EList<?>) wrappedList).move(newPosition, oldPosition);
247		249	}
248	@Override	250
249	public void clear()	251	public void move(int newPosition, Object object) {
250	{	252	move(newPosition, indexOf(object));
251	checkRealm();	253	}
252	wrappedList.clear();	254
253	}	255	@Override
254		256	public String toString() {
255	@Override	257	StringBuilder result = new StringBuilder(getClass().getName());
256	public Object move(int newPosition, int oldPosition)	258	result.append('@');
257	{	259	result.append(Integer.toHexString(hashCode()));
258	checkRealm();	260
259	return ((EList<?>)wrappedList).move(newPosition, oldPosition);	261	result.append(" (eObject:");
260	}	262	result.append(eObject);
261		263	result.append(")");
262	public void move(int newPosition, Object object)	264
263	{	265	result.append(" (eStructuralFeature: ");
264	move(newPosition, indexOf(object));	266	result.append(eStructuralFeature);
265	}	267	result.append(")");
266		268
267	@Override	269	result.append(" (wrappedList: ");
268	public String toString()	270	result.append(wrappedList);
269	{	271	result.append(")");
270	StringBuilder result = new StringBuilder(getClass().getName());
271	result.append('@');
272	result.append(Integer.toHexString(hashCode()));
273
274	result.append(" (eObject:");
275	result.append(eObject);
276	result.append(")");
277
278	result.append(" (eStructuralFeature: ");
279	result.append(eStructuralFeature);
280	result.append(")");
281
282	result.append(" (wrappedList: ");
283	result.append(wrappedList);
284	result.append(")");
285		272
286	return result.toString();	273	return result.toString();
287	}	274	}
288	}	275	}
289		276
290	@SuppressWarnings("unchecked")	277	@SuppressWarnings("unchecked")
291	interface InternalRawEList extends EList	278	interface InternalRawEList extends EList {
292	{	279	// This is only at avoid needing an @SuppressWarnings("unchecked") on the
293	// This is only at avoid needing an @SuppressWarnings("unchecked") on the EMFObservableList	280	// EMFObservableList
294	}	281	}