Attachment #125841 for bug #262160

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




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




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




 * 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: 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;
  }
}

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	}

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




/**
 * <copyright> 
 *
 * Copyright (c) 2007 BestSolution.at and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: 
 *   Tom Schindl<tom.schindl@bestsolution.at> - Initial API and implementation
 *
 * </copyright>
 *
 * $Id: $
 */
package org.eclipse.emf.databinding.internal;

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

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

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;
				}
				}
				
//				System.err.println("CHANGE: " + diff.getDifferences()[0].getElement());
				
//				fireListChange(diff);
//				listener.handlePropertyChange(new SimplePropertyEvent(msg
//						.getNotifier(), EMFListProperty.this, diff));
			}
		}
		
	}
	
	private Adapter listener;
	
	public EWritableList(NotifyingList<Type> wrappedList) {
		this(Realm.getDefault(), wrappedList);
	}
	
	public EWritableList(Realm realm, NotifyingList<Type> wrappedList) {
		this(realm, wrappedList, null);
	}

	public EWritableList(Realm realm, NotifyingList<Type> wrappedList, Class<Type> elementType) {
		super(realm);
		this.wrappedList = wrappedList; 
		this.elementType = elementType;
		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
	public synchronized void dispose() {
		((Notifier)wrappedList.getNotifier()).eAdapters().remove(listener);
		super.dispose();
	}
	
	protected void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

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

	public boolean addAll(Collection c) {
		checkRealm();
		return wrappedList.addAll(c);
	}

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

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

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

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

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

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

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




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

package org.eclipse.emf.databinding.properties;

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * An {@link IValueProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.1
 * @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
	 * value property.
	 * 
	 * @param featurePath
	 *            the value property to observe. May be nested e.g.
	 * 
	 *            <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 * @see #value(IEMFValueProperty)
	 */
	public IEMFValueProperty value(EStructuralFeature... featurePath);

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

	/**
	 * Returns a master-detail combination of this property and the specified
	 * list property.
	 * 
	 * @param feature
	 *            the list property to observe
	 * @return a master-detail combination of this property and the specified
	 *         list property.
	 * @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.
	 * IBeanValueProperty parent = BeanProperties.value(Node.class, &quot;parent&quot;);
	 * // Observes the List-typed &quot;children&quot; property of a Node object
	 * // where the elements are Node objects
	 * IBeanListProperty children = BeanProperties.list(Node.class, &quot;children&quot;,
	 * 		Node.class);
	 * // Observes the children of the parent (siblings) of a Node object.
	 * IBeanListProperty siblings = parent.list(children);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         list property.
	 */
	public IEMFListProperty list(IEMFListProperty property);

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

	/**
	 * Returns a master-detail combination of this property and the specified
	 * map property.
	 * 
	 * @param feature
	 *            the map property to observe
	 * @return a master-detail combination of this property and the specified
	 *         map property.
	 * @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 
	 * IBeanValueProperty supervisor = BeanProperties.value(Contact.class,
	 * 		&quot;supervisor&quot;);
	 * // Observes the property &quot;phoneNumbers&quot; of a Contact object--a property mapping
	 * // from PhoneNumberType to PhoneNumber &quot;set-typed &quot;children&quot;,
	 * IBeanMapProperty phoneNumbers = BeanProperties.map(Contact.class,
	 * 		&quot;phoneNumbers&quot;, PhoneNumberType.class, PhoneNumber.class);
	 * // Observes the phone numbers of a contact's supervisor:
	 * IBeanMapProperty supervisorPhoneNumbers = supervisor.map(phoneNumbers);
	 * </pre>
	 * 
	 * @param property
	 *            the detail property to observe
	 * @return a master-detail combination of this property and the specified
	 *         map property.
	 */
	public IEMFMapProperty map(IEMFMapProperty property);
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 *     Matthew Hall - bug 195222
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.internal;

import java.util.Map;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.map.SimpleMapProperty;
import org.eclipse.emf.common.notify.Adapter;
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;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * 
 * @since 1.1
 */
public class EMFMapProperty extends SimpleMapProperty {

	private final EStructuralFeature feature;
	private final Class<?> keyType;
	private final Class<?> valueType;

	/**
	 * @param feature
	 * @param keyType
	 * @param valueType
	 */
	public EMFMapProperty(EStructuralFeature feature, Class<?> keyType,
			Class<?> valueType) {
		this.feature = feature;
		this.keyType = keyType;
		this.valueType = valueType;
	}

	public Object getKeyType() {
		return keyType;
	}

	public Object getValueType() {
		return valueType;
	}

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

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

	@Override
	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new Listener(listener);
	}

	private class Listener extends AdapterImpl implements
			INativePropertyListener {
		private final ISimplePropertyListener listener;

		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}

		@Override
		public void notifyChanged(Notification msg) {
			if (feature == msg.getFeature() && !msg.isTouch()) {
				// TODO
				// This assumes we only get a SET notification, which isn't a
				// good assumption.
				//
				final MapDiff diff = Diffs.createMapDiffSingleChange(msg
						.getNotifier(), msg.getOldValue(), msg.getNewValue());
				listener.handlePropertyChange(new SimplePropertyEvent(msg
						.getNotifier(), EMFMapProperty.this, diff));
			}
		}
	}

	@Override
	protected void doAddListener(Object source, INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().add((Adapter) listener);
	}

	@Override
	protected void doRemoveListener(Object source,
			INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().remove((Adapter) listener);
	}

	@Override
	public String toString() {
		String s = feature.getName() + "{:}"; //$NON-NLS-1$
		if (keyType != null || valueType != null)
			s += "<" + (keyType != null ? keyType.getName() : "null") + ", " //$NON-NLS-1$ //$NON-NLS-2$
					+ (valueType != null ? valueType.getName() : "null") + ">"; //$NON-NLS-1$
		return super.toString();
	}
}




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.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.properties.EMFProperties;
import org.eclipse.emf.databinding.properties.IEMFMapProperty;
import org.eclipse.emf.databinding.properties.IEMFValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFMapPropertyDecorator extends MapProperty implements
		IEMFMapProperty {
	private final IMapProperty delegate;
	private final EStructuralFeature feature;

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

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

	public Object getValueType() {
		return delegate.getValueType();
	}
	
	public IEMFMapProperty values(EStructuralFeature... featurePath) { 
		return values(EMFProperties.value(featurePath));
	}

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

	public IObservableMap observe(Object source) {
		return new EMFObservableMapDecorator(delegate.observe(source),
				feature);
	}
	
	public IObservableMap observe(Realm realm, Object source) {
		return new EMFObservableMapDecorator(delegate.observe(realm, source),
				feature);
	}
	
	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),
				feature);
	}
	
	public String toString() {
		return delegate.toString();
	}
}




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.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.properties.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * {@link IEMFObservable} decorator for an {@link IObservableList}.
 * 
 * @since 1.1
 */
public class EMFObservableListDecorator extends DecoratingObservableList
		implements IEMFObservable {
	private EStructuralFeature feature;
	
	/**
	 * @param decorated
	 * @param feature
	 */
	public EMFObservableListDecorator(IObservableList decorated, EStructuralFeature feature) {
		super(decorated, true);
		this.feature = feature;
	}

	public synchronized void dispose() {
		this.feature = null;
		super.dispose();
	}
	
	public EStructuralFeature getFeature() {
		return feature;
	}

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




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 *     Matthew Hall - bug 195222
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.internal;

import java.util.Collection;
import java.util.List;

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.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.list.SimpleListProperty;
import org.eclipse.emf.common.notify.Adapter;
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;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFListProperty extends SimpleListProperty {
	private final EStructuralFeature feature;

	/**
	 * @param feature
	 */
	public EMFListProperty(EStructuralFeature feature) {
		this.feature = feature;
	}

	public Object getElementType() {
		return feature;
	}

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

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

	@Override
	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new Listener(listener);
	}

	private class Listener extends AdapterImpl implements
			INativePropertyListener {
		private final ISimplePropertyListener listener;

		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}

		@Override
		public void notifyChanged(Notification msg) {
			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()));
					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");
				}
				}
				listener.handlePropertyChange(new SimplePropertyEvent(msg
						.getNotifier(), EMFListProperty.this, diff));
			}
		}
	}

	@Override
	protected void doAddListener(Object source, INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().add((Adapter) listener);
	}

	@Override
	protected void doRemoveListener(Object source,
			INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().remove((Adapter) listener);
	}
	
	public String toString() {
		String s = feature.getName() + "[]";
		s += "<" + feature.getEType().getInstanceClassName() + ">";
		return s;
	}
}




/*******************************************************************************
 * 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
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.properties;

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.properties.internal.EMFListProperty;
import org.eclipse.emf.databinding.properties.internal.EMFListPropertyDecorator;
import org.eclipse.emf.databinding.properties.internal.EMFMapProperty;
import org.eclipse.emf.databinding.properties.internal.EMFMapPropertyDecorator;
import org.eclipse.emf.databinding.properties.internal.EMFValueProperty;
import org.eclipse.emf.databinding.properties.internal.EMFValuePropertyDecorator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * A factory for creating properties for {@link EObject} objects
 * 
 * @since 1.1
 */
public class EMFProperties {
	/**
	 * Returns a value property for the given property name of an arbitrary bean
	 * class. Objects lacking the named property are treated the same as if the
	 * property always contains null.
	 * 
	 * @param featurePath
	 *            the property name. May be nested e.g.
	 *            <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
	 * @return a value property for the given property name of an arbitrary bean
	 *         class.
	 */
	public static IEMFValueProperty value(EStructuralFeature... featurePath) {
		IValueProperty property = new EMFValueProperty(featurePath[0]);

		IEMFValueProperty emfProperty = new EMFValuePropertyDecorator(property,
				featurePath[0]);
		for (int i = 1; i < featurePath.length; i++) {
			emfProperty = emfProperty.value(featurePath[i]);
		}
		return emfProperty;
	}

	// public static IEMFValueProperty[] values(EStructuralFeature[]...
	// features) {
	// return null;
	// }

	// public static IEMFSetProperty set(EStructuralFeature feature) {
	// ISetProperty property = new EMFSetProperty(feature, elementType);
	// return new EMFSetPropertyDecorator(property, feature);
	// }

	/**
	 * Returns a list property for the given property name of an arbitrary bean
	 * class. Objects lacking the named property are treated the same as if the
	 * property always contains an empty list.
	 * 
	 * @param feature
	 *            the property name
	 * @return a list property for the given property name of an arbitrary bean
	 *         class.
	 */
	public static IEMFListProperty list(EStructuralFeature feature) {
		IListProperty property = new EMFListProperty(feature);
		return new EMFListPropertyDecorator(property, feature);
	}

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

	/**
	 * Returns a map property for the given property name of the given bean
	 * class.
	 * 
	 * @param feature
	 *            the property name
	 * @param keyType
	 *            the key type for the returned map property
	 * @param valueType
	 *            the value type for the returned map property
	 * @return a map property for the given property name of the given bean
	 *         class.
	 */
	public static IEMFMapProperty map(EStructuralFeature feature,
			Class<?> keyType, Class<?> valueType) {
		IMapProperty property = new EMFMapProperty(feature, keyType, valueType);
		return new EMFMapPropertyDecorator(property, feature);
	}
}




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

package org.eclipse.emf.databinding.properties;

import java.util.Map;

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * An {@link IMapProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.1
 * @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
	 * value property.
	 * 
	 * @param featurePath
	 *            the value property to observe. May be nested e.g.
	 *            <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 * @see #values(IEMFValueProperty)
	 */
	public IEMFMapProperty values(EStructuralFeature... featurePath);

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




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.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.properties.EMFProperties;
import org.eclipse.emf.databinding.properties.IEMFListProperty;
import org.eclipse.emf.databinding.properties.IEMFValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFListPropertyDecorator extends ListProperty implements IEMFListProperty {
	private final IListProperty delegate;
	private final EStructuralFeature feature;
	
	/**
	 * @param delegate
	 * @param feature
	 */
	public EMFListPropertyDecorator(IListProperty delegate, EStructuralFeature feature) {
		this.delegate = delegate;
		this.feature = feature;
	}
	
	public Object getElementType() {
		return feature.getEType().getInstanceClass();
	}
	
	public IEMFListProperty values(EStructuralFeature... feature) {
		return values(EMFProperties.value(feature));
	}
	public IEMFListProperty values(IEMFValueProperty property) {
		return new EMFListPropertyDecorator(super.values(property),property.getFeature());
	}
	public EStructuralFeature getFeature() {
		return feature;
	}
	
	public IObservableList observe(Object source) {
		return new EMFObservableListDecorator(delegate.observe(source),
				feature);
	}
	
	public IObservableList observe(Realm realm, Object source) {
		return new EMFObservableListDecorator(delegate.observe(realm, source),
				feature);
	}
	
	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),
				feature);
	}
	
	public String toString() {
		return delegate.toString();
	}
}




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.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.properties.EMFProperties;
import org.eclipse.emf.databinding.properties.IEMFListProperty;
import org.eclipse.emf.databinding.properties.IEMFMapProperty;
import org.eclipse.emf.databinding.properties.IEMFValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFValuePropertyDecorator extends ValueProperty implements IEMFValueProperty {
	private final IValueProperty delegate;
	private final EStructuralFeature feature;
	
	/**
	 * @param delegate
	 * @param feature
	 */
	public EMFValuePropertyDecorator(IValueProperty delegate, EStructuralFeature feature) {
		this.delegate = delegate;
		this.feature = feature;
	}
	
	public Object getValueType() {
		return delegate.getValueType();
	}
	
	public EStructuralFeature getFeature() {
		return feature;
	}
	
	public IEMFValueProperty value(EStructuralFeature... featurePath) {
		return value(EMFProperties.value(featurePath));
	}

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

	public IEMFListProperty list(IEMFListProperty property) {
		return new EMFListPropertyDecorator(super.list(property),property.getFeature());
	}
	
//	public IEMFSetProperty set(EStructuralFeature featurePath) {
//		// TODO Auto-generated method stub
//		return null;
//	}
//
//	public IEMFSetProperty set(IEMFSetProperty property) {
//		// TODO Auto-generated method stub
//		return null;
//	}

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

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

	public IObservableValue observe(Object source) {
		return new EMFObservableValueDecorator(delegate.observe(source),
				feature);
	}
	
	public IObservableValue observe(Realm realm, Object source) {
		return new EMFObservableValueDecorator(
				delegate.observe(realm, source), feature);
	}
	
	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),
				feature);
	}

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

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




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.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.properties.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * {@link IEMFObservable} decorator for an {@link IObservableValue}.
 * 
 * @since 1.1
 */
public class EMFObservableValueDecorator extends DecoratingObservableValue
		implements IEMFObservable {
	private EStructuralFeature feature;
	
	/**
	 * @param decorated
	 * @param feature
	 */
	public EMFObservableValueDecorator(IObservableValue decorated, EStructuralFeature feature) {
		super(decorated, true);
		this.feature = feature;
	}
	
	public synchronized void dispose() {
		this.feature = null;
		super.dispose();
	}

	public EStructuralFeature getFeature() {
		return feature;
	}

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




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

package org.eclipse.emf.databinding.properties;

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * An {@link IListProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.1
 * @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 property.
	 * 
	 * @param featurePath
	 *            the value property to observe. May be nested e.g.
	 * 
	 *            <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
	 * @return a nested combination of this property and the specified value
	 *         property.
	 * @see #values(IEMFValueProperty)
	 */
	public IEMFListProperty values(EStructuralFeature... featurePath);

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




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 221704)
 *     Matthew Hall - bug 246625
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.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.properties.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * {@link IEMFObservable} decorator for an {@link IObservableMap}.
 * 
 * @since 1.1
 */
public class EMFObservableMapDecorator extends DecoratingObservableMap
		implements IEMFObservable {
	private EStructuralFeature feature;

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

	public synchronized void dispose() {
		this.feature = null;
		super.dispose();
	}
	
	public EStructuralFeature getFeature() {
		return feature;
	}

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




#Sat Jan 24 17:20:53 CET 2009
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.doc.comment.support=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=return_tag
org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected




/*******************************************************************************
 * 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
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.properties.internal;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.value.SimpleValueProperty;
import org.eclipse.emf.common.notify.Adapter;
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;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFValueProperty extends SimpleValueProperty {
	private EStructuralFeature feature;
	
	/**
	 * @param feature
	 */
	public EMFValueProperty(EStructuralFeature feature) {
		this.feature = feature;
	}
	
	public Object getValueType() {
		return feature.getEType().getInstanceClass();
	}
	
	@Override
	protected Object doGetValue(Object source) {
		EObject eObj = (EObject) source;
		return eObj.eGet(feature);
	}

	
	@Override
	protected void doSetValue(Object source, Object value) {
		EObject eObj = (EObject) source;
		eObj.eSet(feature, value);
	}
	
	@Override
	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new Listener(listener);
	}
	
	private class Listener extends AdapterImpl implements INativePropertyListener {
		private final ISimplePropertyListener listener;
		
		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}

		@Override
		public void notifyChanged(Notification msg) {
			if( feature == msg.getFeature() && !msg.isTouch() ) {
				ValueDiff diff;
				Object oldValue = msg.getOldValue();
				Object newValue = msg.getNewValue();
				if (oldValue != null && newValue != null) {
					diff = Diffs.createValueDiff(oldValue, newValue);
				} else {
					diff = null;
				}
				listener.handlePropertyChange(new SimplePropertyEvent(msg.getNotifier(), EMFValueProperty.this, diff));				
			}
		}
	}

	@Override
	protected void doAddListener(Object source, INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().add((Adapter) listener);
	}

	
	@Override
	protected void doRemoveListener(Object source,
			INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().remove((Adapter) listener);
	}	
	
	public String toString() {
		String s = feature.getName();
		s += "<" + feature.getEType().getInstanceClassName() + ">"; //$NON-NLS-1$//$NON-NLS-2$
		return s;
	}
}




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

package org.eclipse.emf.databinding.properties;

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * An IProperty extension interface providing access to details of bean
 * properties.
 * 
 * @since 1.1
 * @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 {
	/**
	 * @return the feature observed
	 */
	public EStructuralFeature getFeature();
}




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.properties;

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * Provides access to details of EMF observables.
 * <p>
 * This interface is not meant to be implemented by clients.
 * </p>
 * 
 * @since 1.1
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFObservable extends IObserving {
	/**
	 * @return the feature observed
	 */
	public EStructuralFeature getFeature();
}

Lines 105-111 Link Here

(-)src/org/eclipse/emf/databinding/edit/EMFEditObservables.java (-1 / +1 lines)
105	* @param eStructuralFeatures the features for which to track the value.	105	* @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.	106	* @return an array of observable maps tracking the current value of the given features for each object in the given set.
107	*/	107	*/
108	public static IObservableMap[] observeMaps(EditingDomain domain, IObservableSet objects, EStructuralFeature[] eStructuralFeatures)	108	public static IObservableMap[] observeMaps(EditingDomain domain, IObservableSet objects, EStructuralFeature... eStructuralFeatures)
109	{	109	{
110	IObservableMap[] result = new IObservableMap [eStructuralFeatures.length];	110	IObservableMap[] result = new IObservableMap [eStructuralFeatures.length];
111	for (int i = 0; i < eStructuralFeatures.length; i++)	111	for (int i = 0; i < eStructuralFeatures.length; i++)

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.edit	11	Export-Package: org.eclipse.emf.databinding.edit,
		12	org.eclipse.emf.databinding.edit.properties
12	Require-Bundle: org.eclipse.core.runtime,	13	Require-Bundle: org.eclipse.core.runtime,
13	org.eclipse.emf.databinding;visibility:=reexport,	14	org.eclipse.emf.databinding;visibility:=reexport,
14	org.eclipse.emf.edit;visibility:=reexport	15	org.eclipse.emf.edit;visibility:=reexport




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.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.edit.properties.EMFEditProperties;
import org.eclipse.emf.databinding.edit.properties.IEMFEditListProperty;
import org.eclipse.emf.databinding.edit.properties.IEMFEditMapProperty;
import org.eclipse.emf.databinding.edit.properties.IEMFEditValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFEditValuePropertyDecorator extends ValueProperty implements IEMFEditValueProperty {
	private final IValueProperty delegate;
	private final EStructuralFeature feature;
	private EditingDomain domain;
	
	/**
	 * @param delegate
	 * @param feature
	 */
	public EMFEditValuePropertyDecorator(EditingDomain domain, IValueProperty delegate, EStructuralFeature feature) {
		this.delegate = delegate;
		this.feature = feature;
		this.domain = domain;
	}
	
	public Object getValueType() {
		return delegate.getValueType();
	}
	
	public EStructuralFeature getFeature() {
		return feature;
	}
	
	public IEMFEditValueProperty value(EStructuralFeature... featurePath) {
		return value(EMFEditProperties.value(domain, featurePath));
	}

	public IEMFEditValueProperty value(IEMFEditValueProperty property) {
		return new EMFEditValuePropertyDecorator(property.getDomain(), super.value(property),property.getFeature());
	}
	
	public IEMFEditListProperty list(EStructuralFeature featurePath) {
		return list(EMFEditProperties.list(domain, featurePath));
	}

	public IEMFEditListProperty list(IEMFEditListProperty property) {
		return new EMFEditListPropertyDecorator(property.getDomain(), super.list(property),property.getFeature());
	}
	
//	public IEMFSetProperty set(EStructuralFeature featurePath) {
//		// TODO Auto-generated method stub
//		return null;
//	}
//
//	public IEMFSetProperty set(IEMFSetProperty property) {
//		// TODO Auto-generated method stub
//		return null;
//	}

	public IEMFEditMapProperty map(EStructuralFeature featurePath) {
		return map(EMFEditProperties.map(domain, featurePath));
	}

	public IEMFEditMapProperty map(IEMFEditMapProperty property) {
		return new EMFEditMapPropertyDecorator(property.getDomain(), super.map(property),property.getFeature());
	}

	public IObservableValue observe(Object source) {
		return new EMFEditObservableValueDecorator(domain, delegate.observe(source),
				feature);
	}
	
	public IObservableValue observe(Realm realm, Object source) {
		return new EMFEditObservableValueDecorator(domain,
				delegate.observe(realm, source), feature);
	}
	
	public IObservableFactory valueFactory() {
		return delegate.valueFactory();
	}

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

	public IObservableValue observeDetail(IObservableValue master) {
		return new EMFEditObservableValueDecorator(domain,delegate.observeDetail(master),
				feature);
	}

	public IObservableList observeDetail(IObservableList master) {
		return new EMFEditObservableListDecorator(domain, delegate.observeDetail(master),
				feature);
	}
	
	public IObservableMap observeDetail(IObservableSet master) {
		return new EMFEditObservableMapDecorator(domain, delegate.observeDetail(master),
				feature);
	}

	public IObservableMap observeDetail(IObservableMap master) {
		return new EMFEditObservableMapDecorator(domain, delegate.observeDetail(master),
				feature);
	}

	public EditingDomain getDomain() {
		return domain;
	}
}




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties;

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * Provides access to details of EMF observables.
 * <p>
 * This interface is not meant to be implemented by clients.
 * </p>
 * 
 * @since 1.1
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFEditObservable extends IObserving {
	/**
	 * @return the feature observed
	 */
	public EStructuralFeature getFeature();
	public EditingDomain getDomain();
}




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

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

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * An {@link IListProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.1
 * @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 property.
	 * 
	 * @param featurePath
	 *            the value property to observe. May be nested e.g.
	 * 
	 *            <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
	 * @return a nested combination of this property and the specified value
	 *         property.
	 * @see #values(IEMFEditValueProperty)
	 */
	public IEMFEditListProperty values(EStructuralFeature... featurePath);

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




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.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.properties.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * {@link IEMFObservable} decorator for an {@link IObservableList}.
 * 
 * @since 1.1
 */
public class EMFEditObservableListDecorator extends DecoratingObservableList
		implements IEMFObservable {
	private EStructuralFeature feature;
	private EditingDomain domain;
	
	/**
	 * @param decorated
	 * @param feature
	 */
	public EMFEditObservableListDecorator(EditingDomain domain, IObservableList decorated, EStructuralFeature feature) {
		super(decorated, true);
		this.feature = feature;
		this.domain = domain;
	}

	public synchronized void dispose() {
		this.feature = null;
		super.dispose();
	}
	
	public EStructuralFeature getFeature() {
		return feature;
	}

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




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

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

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * An IProperty extension interface providing access to details of bean
 * properties.
 * 
 * @since 1.1
 * @noextend This interface is not intended to be extended by clients.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IEMFEditProperty extends IProperty {
	/**
	 * @return the feature observed
	 */
	public EStructuralFeature getFeature();
	public EditingDomain getDomain();
}




/*******************************************************************************
 * 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
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.internal;

import java.util.Collection;
import java.util.List;

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.observable.list.ListDiffVisitor;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.list.SimpleListProperty;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.notify.Adapter;
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;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.RemoveCommand;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFEditListProperty extends SimpleListProperty {
	
	private class ListVisitorImpl extends ListDiffVisitor {
		private EditingDomain domain;
		private EObject eObj;
		private EStructuralFeature feature;
		
		private ListVisitorImpl(EditingDomain domain, EObject eObj, EStructuralFeature feature) {
			this.domain = domain;
			this.eObj = eObj;
			this.feature = feature;
		}
		
		@Override
		public void handleAdd(int index, Object element) {
			execute(AddCommand.create(domain, eObj, feature, element, index));
		}

		@Override
		public void handleRemove(int index, Object element) {
			execute(RemoveCommand.create(domain, eObj, feature, element));
		}
		
		private  boolean execute(Command command)
		  {
		    if (command.canExecute())
		    {
		      domain.getCommandStack().execute(command);
		      return true;
		    }
		    else
		    {
		      return false;
		    }
		  }
	}
	
	private EditingDomain domain;
	private final EStructuralFeature feature;

	/**
	 * @param feature
	 */
	public EMFEditListProperty(EditingDomain domain, EStructuralFeature feature) {
		this.feature = feature;
		this.domain = domain;
	}
	
	protected EStructuralFeature getFeature() {
		return feature;
	}

	public Object getElementType() {
		return feature;
	}

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

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

	@Override
	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new Listener(listener);
	}

	private class Listener extends AdapterImpl implements
			INativePropertyListener {
		private final ISimplePropertyListener listener;

		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}

		@Override
		public void notifyChanged(Notification msg) {
			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()));
					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");
				}
				}
				listener.handlePropertyChange(new SimplePropertyEvent(msg
						.getNotifier(), EMFEditListProperty.this, diff));
			}
		}
	}

	@Override
	protected void doAddListener(Object source, INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().add((Adapter) listener);
	}

	@Override
	protected void doRemoveListener(Object source,
			INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().remove((Adapter) listener);
	}
}




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

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

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * An {@link IValueProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.1
 * @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
	 * value property.
	 * 
	 * @param featurePath
	 *            the value property to observe. May be nested e.g.
	 * 
	 *            <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 * @see #value(IEMFEditValueProperty)
	 */
	public IEMFEditValueProperty value(EStructuralFeature... featurePath);

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

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

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

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

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

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




/*******************************************************************************
 * 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
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.internal;

import java.util.Map;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.map.SimpleMapProperty;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.notify.Adapter;
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;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFEditMapProperty extends SimpleMapProperty {
	
	private final EStructuralFeature feature;
	private final Class<?> keyType;
	private final Class<?> valueType;
	private EditingDomain domain;
	
	/**
	 * @param feature
	 * @param keyType
	 * @param valueType
	 */
	public EMFEditMapProperty(EditingDomain domain, EStructuralFeature feature, Class<?> keyType, Class<?> valueType) {
		this.feature = feature;
		this.keyType = keyType;
		this.valueType = valueType;
		this.domain = domain;
	}
	
	public Object getKeyType() {
		return keyType;
	}

	public Object getValueType() {
		return valueType;
	}

	@Override
	protected Map<?,?> doGetMap(Object source) {
		EObject eObj = (EObject) source;
		return (Map<?,?>) eObj.eGet(feature);
	}
	
	@SuppressWarnings("unchecked")
	@Override
	protected void doSetMap(Object source, Map map, MapDiff diff) {
		EObject eObject = (EObject)source;
	    Command command = SetCommand.create(domain, eObject, feature, map);
	    domain.getCommandStack().execute(command);
	}
	
	@Override
	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new Listener(listener);
	}
	
	private class Listener extends AdapterImpl implements INativePropertyListener {
		private final ISimplePropertyListener listener;

		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}
		
		@Override
		public void notifyChanged(Notification msg) {
			if (feature == msg.getFeature() && !msg.isTouch())
	        {
	          // TODO
	          // This assumes we only get a SET notification, which isn't a good assumption.
	          //
	          final MapDiff diff = Diffs.createMapDiffSingleChange(msg.getNotifier(), msg.getOldValue(), msg.getNewValue());
	          listener.handlePropertyChange(new SimplePropertyEvent(msg
						.getNotifier(), EMFEditMapProperty.this, diff));
	        }
		}
	}

	@Override
	protected void doAddListener(Object source, INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().add((Adapter) listener);
	}

	@Override
	protected void doRemoveListener(Object source,
			INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().remove((Adapter) listener);
	}

	

	

}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 221704)
 *     Matthew Hall - bug 246625
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.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.properties.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * {@link IEMFObservable} decorator for an {@link IObservableMap}.
 * 
 * @since 1.1
 */
public class EMFEditObservableMapDecorator extends DecoratingObservableMap
		implements IEMFObservable {
	private EStructuralFeature feature;
	private EditingDomain domain;

	/**
	 * @param decorated
	 * @param feature
	 */
	public EMFEditObservableMapDecorator(EditingDomain domain, IObservableMap decorated, EStructuralFeature feature) {
		super(decorated, true);
		this.feature = feature;
		this.domain = domain;
	}

	public synchronized void dispose() {
		this.feature = null;
		super.dispose();
	}
	
	public EStructuralFeature getFeature() {
		return feature;
	}

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




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 *     Matthew Hall - bug 195222, 247997, 261843
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties;

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.edit.properties.internal.EMFEditListProperty;
import org.eclipse.emf.databinding.edit.properties.internal.EMFEditListPropertyDecorator;
import org.eclipse.emf.databinding.edit.properties.internal.EMFEditMapProperty;
import org.eclipse.emf.databinding.edit.properties.internal.EMFEditMapPropertyDecorator;
import org.eclipse.emf.databinding.edit.properties.internal.EMFEditValueProperty;
import org.eclipse.emf.databinding.edit.properties.internal.EMFEditValuePropertyDecorator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * A factory for creating properties for {@link EObject} objects
 * 
 * @since 1.1
 */
public class EMFEditProperties {
	/**
	 * Returns a value property for the given property name of an arbitrary bean
	 * class. Objects lacking the named property are treated the same as if the
	 * property always contains null.
	 * 
	 * @param featurePath
	 *            the property name. May be nested e.g.
	 *            <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
	 * @return a value property for the given property name of an arbitrary bean
	 *         class.
	 */
	public static IEMFEditValueProperty value(EditingDomain domain, EStructuralFeature... featurePath) {
		IValueProperty property = new EMFEditValueProperty(domain,featurePath[0]);

		IEMFEditValueProperty emfProperty = new EMFEditValuePropertyDecorator(domain, property,
				featurePath[0]);
		for (int i = 1; i < featurePath.length; i++) {
			emfProperty = emfProperty.value(featurePath[i]);
		}
		return emfProperty;
	}

	// public static IEMFValueProperty[] values(EStructuralFeature[]...
	// features) {
	// return null;
	// }

	// public static IEMFSetProperty set(EStructuralFeature feature) {
	// ISetProperty property = new EMFSetProperty(feature, elementType);
	// return new EMFSetPropertyDecorator(property, feature);
	// }

	/**
	 * Returns a list property for the given property name of an arbitrary bean
	 * class. Objects lacking the named property are treated the same as if the
	 * property always contains an empty list.
	 * 
	 * @param feature
	 *            the property name
	 * @return a list property for the given property name of an arbitrary bean
	 *         class.
	 */
	public static IEMFEditListProperty list(EditingDomain domain, EStructuralFeature feature) {
		IListProperty property = new EMFEditListProperty(domain, feature);
		return new EMFEditListPropertyDecorator(domain, property, feature);
	}

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

	/**
	 * Returns a map property for the given property name of the given bean
	 * class.
	 * 
	 * @param feature
	 *            the property name
	 * @param keyType
	 *            the key type for the returned map property
	 * @param valueType
	 *            the value type for the returned map property
	 * @return a map property for the given property name of the given bean
	 *         class.
	 */
	public static IEMFEditMapProperty map(EditingDomain domain, EStructuralFeature feature,
			Class<?> keyType, Class<?> valueType) {
		IMapProperty property = new EMFEditMapProperty(domain, feature, keyType, valueType);
		return new EMFEditMapPropertyDecorator(domain, property, feature);
	}
}




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

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

import java.util.Map;

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

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * An {@link IMapProperty} extension interface with convenience methods for
 * creating nested bean properties.
 * 
 * @since 1.1
 * @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
	 * value property.
	 * 
	 * @param featurePath
	 *            the value property to observe. May be nested e.g.
	 *            <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
	 * @return a master-detail combination of this property and the specified
	 *         value property.
	 * @see #values(IEMFEditValueProperty)
	 */
	public IEMFEditMapProperty values(EStructuralFeature... featurePath);

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




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.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.edit.properties.EMFEditProperties;
import org.eclipse.emf.databinding.edit.properties.IEMFEditListProperty;
import org.eclipse.emf.databinding.edit.properties.IEMFEditValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFEditListPropertyDecorator extends ListProperty implements IEMFEditListProperty {
	private final IListProperty delegate;
	private final EStructuralFeature feature;
	private EditingDomain domain;
	
	/**
	 * @param delegate
	 * @param feature
	 */
	public EMFEditListPropertyDecorator(EditingDomain domain, IListProperty delegate, EStructuralFeature feature) {
		this.delegate = delegate;
		this.feature = feature;
		this.domain = domain;
	}
	
	public Object getElementType() {
		return feature.getEType().getInstanceClass();
	}
	
	public IEMFEditListProperty values(EStructuralFeature... feature) {
		return values(EMFEditProperties.value(domain, feature));
	}
	public IEMFEditListProperty values(IEMFEditValueProperty property) {
		return new EMFEditListPropertyDecorator(property.getDomain(), super.values(property),property.getFeature());
	}
	public EStructuralFeature getFeature() {
		return feature;
	}
	
	public IObservableList observe(Object source) {
		return new EMFEditObservableListDecorator(domain, delegate.observe(source),
				feature);
	}
	
	public IObservableList observe(Realm realm, Object source) {
		return new EMFEditObservableListDecorator(domain, delegate.observe(realm, source),
				feature);
	}
	
	public IObservableFactory listFactory() {
		return delegate.listFactory();
	}
	
	public IObservableFactory listFactory(Realm realm) {
		return delegate.listFactory(realm);
	}

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

	public EditingDomain getDomain() {
		return domain;
	}
}




/*******************************************************************************
 * 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
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.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.properties.IEMFObservable;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * {@link IEMFObservable} decorator for an {@link IObservableValue}.
 * 
 * @since 1.1
 */
public class EMFEditObservableValueDecorator extends DecoratingObservableValue
		implements IEMFObservable {
	private EStructuralFeature feature;
	private EditingDomain domain;
	
	/**
	 * @param decorated
	 * @param feature
	 */
	public EMFEditObservableValueDecorator(EditingDomain domain, IObservableValue decorated, EStructuralFeature feature) {
		super(decorated, true);
		this.feature = feature;
		this.domain = domain;
	}
	
	public synchronized void dispose() {
		this.feature = null;
		super.dispose();
	}

	public EStructuralFeature getFeature() {
		return feature;
	}

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




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 *     Matthew Hall - bug 195222
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.internal;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.value.SimpleValueProperty;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.notify.Adapter;
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;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFEditValueProperty extends SimpleValueProperty {
	private EStructuralFeature feature;
	private EditingDomain domain;
	
	/**
	 * @param feature
	 */
	public EMFEditValueProperty(EditingDomain domain, EStructuralFeature feature) {
		this.feature = feature;
		this.domain = domain;
	}
	
	public Object getValueType() {
		return feature.getEType().getInstanceClass();
	}
	
	@Override
	protected Object doGetValue(Object source) {
		EObject eObj = (EObject) source;
		return eObj.eGet(feature);
	}

	
	@Override
	protected void doSetValue(Object source, Object value) {
		EObject eObj = (EObject) source;
		Command command = SetCommand.create(domain, eObj, feature, value);
	    domain.getCommandStack().execute(command);
	}
	
	@Override
	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new Listener(listener);
	}
	
	private class Listener extends AdapterImpl implements INativePropertyListener {
		private final ISimplePropertyListener listener;
		
		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}

		@Override
		public void notifyChanged(Notification msg) {
			if( feature == msg.getFeature() && !msg.isTouch() ) {
				ValueDiff diff;
				Object oldValue = msg.getOldValue();
				Object newValue = msg.getNewValue();
				if (oldValue != null && newValue != null) {
					diff = Diffs.createValueDiff(oldValue, newValue);
				} else {
					diff = null;
				}
				listener.handlePropertyChange(new SimplePropertyEvent(msg.getNotifier(), EMFEditValueProperty.this, diff));				
			}
		}
	}

	@Override
	protected void doAddListener(Object source, INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().add((Adapter) listener);
	}

	
	@Override
	protected void doRemoveListener(Object source,
			INativePropertyListener listener) {
		EObject eObj = (EObject) source;
		eObj.eAdapters().remove((Adapter) listener);
	}	
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 195222)
 *     Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
 ******************************************************************************/
package org.eclipse.emf.databinding.edit.properties.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.edit.properties.EMFEditProperties;
import org.eclipse.emf.databinding.edit.properties.IEMFEditMapProperty;
import org.eclipse.emf.databinding.edit.properties.IEMFEditValueProperty;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.domain.EditingDomain;

/**
 * <p>
 * <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
 * removal.</b>
 * </p>
 * @since 1.1
 */
public class EMFEditMapPropertyDecorator extends MapProperty implements
		IEMFEditMapProperty {
	private final IMapProperty delegate;
	private final EStructuralFeature feature;
	private EditingDomain domain;

	/**
	 * @param delegate
	 * @param feature
	 */
	public EMFEditMapPropertyDecorator(EditingDomain domain, IMapProperty delegate, EStructuralFeature feature) {
		this.delegate = delegate;
		this.feature = feature;
		this.domain = domain;
	}
	
	public EStructuralFeature getFeature() {
		return feature;
	}

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

	public Object getValueType() {
		return delegate.getValueType();
	}
	
	public IEMFEditMapProperty values(EStructuralFeature... featurePath) { 
		return values(EMFEditProperties.value(domain, featurePath));
	}

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

	public IObservableMap observe(Object source) {
		return new EMFEditObservableMapDecorator(domain, delegate.observe(source),
				feature);
	}
	
	public IObservableMap observe(Realm realm, Object source) {
		return new EMFEditObservableMapDecorator(domain, delegate.observe(realm, source),
				feature);
	}
	
	public IObservableFactory mapFactory() {
		return delegate.mapFactory();
	}

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

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

	public EditingDomain getDomain() {
		return domain;
	}
}

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 9-15 Link Here

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

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	}

Added Link Here

(-)src/org/eclipse/emf/databinding/internal/EWritableList.java (+303 lines)
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2007 BestSolution.at and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* Tom Schindl<tom.schindl@bestsolution.at> - Initial API and implementation
12	*
13	* </copyright>
14	*
15	* $Id: $
16	*/
17	package org.eclipse.emf.databinding.internal;
18
19	import java.util.Collection;
20	import java.util.Iterator;
21	import java.util.List;
22	import java.util.ListIterator;
23
24	import org.eclipse.core.databinding.observable.Diffs;
25	import org.eclipse.core.databinding.observable.ObservableTracker;
26	import org.eclipse.core.databinding.observable.Realm;
27	import org.eclipse.core.databinding.observable.list.AbstractObservableList;
28	import org.eclipse.core.databinding.observable.list.IObservableList;
29	import org.eclipse.core.databinding.observable.list.ListDiff;
30	import org.eclipse.core.databinding.observable.list.ListDiffEntry;
31	import org.eclipse.emf.common.notify.Adapter;
32	import org.eclipse.emf.common.notify.Notification;
33	import org.eclipse.emf.common.notify.Notifier;
34	import org.eclipse.emf.common.notify.NotifyingList;
35	import org.eclipse.emf.common.notify.impl.AdapterImpl;
36	import org.eclipse.emf.ecore.resource.Resource;
37
38	public class EWritableList<Type> extends AbstractObservableList implements IObservableList {
39	private NotifyingList<Type> wrappedList;
40	private Object elementType;
41	private boolean stale = false;
42
43	private class Listener extends AdapterImpl {
44	private Object feature;
45
46	public Listener(Object feature) {
47	this.feature = feature;
48	}
49
50	@Override
51	public void notifyChanged(Notification msg) {
52
53	if( feature == null && msg.getFeature() == null && msg.getFeatureID(Resource.class) != Resource.RESOURCE__CONTENTS ) {
54	return;
55	}
56
57	if (feature == msg.getFeature() && !msg.isTouch()) {
58	final ListDiff diff;
59	switch (msg.getEventType()) {
60	case Notification.ADD: {
61	diff = Diffs.createListDiff(Diffs.createListDiffEntry(msg
62	.getPosition(), true, msg.getNewValue()));
63	fireListChange(diff);
64	break;
65	}
66	case Notification.ADD_MANY: {
67	Collection<?> newValues = (Collection<?>) msg.getNewValue();
68	ListDiffEntry[] listDiffEntries = new ListDiffEntry[newValues
69	.size()];
70	int position = msg.getPosition();
71	int index = 0;
72	for (Object newValue : newValues) {
73	listDiffEntries[index++] = Diffs.createListDiffEntry(
74	position++, true, newValue);
75	}
76	diff = Diffs.createListDiff(listDiffEntries);
77	fireListChange(diff);
78	break;
79	}
80	case Notification.REMOVE: {
81	diff = Diffs.createListDiff(Diffs.createListDiffEntry(msg
82	.getPosition(), false, msg.getOldValue()));
83	fireListChange(diff);
84	break;
85	}
86	case Notification.REMOVE_MANY: {
87	Collection<?> oldValues = (Collection<?>) msg.getOldValue();
88	ListDiffEntry[] listDiffEntries = new ListDiffEntry[oldValues
89	.size()];
90	int position = msg.getPosition();
91	int index = 0;
92	for (Object oldValue : oldValues) {
93	listDiffEntries[index++] = Diffs.createListDiffEntry(
94	position++, false, oldValue);
95	}
96	diff = Diffs.createListDiff(listDiffEntries);
97	fireListChange(diff);
98	break;
99	}
100	case Notification.MOVE: {
101	Object movedValue = msg.getNewValue();
102	ListDiffEntry[] listDiffEntries = new ListDiffEntry[2];
103	listDiffEntries[0] = Diffs.createListDiffEntry(
104	(Integer) msg.getOldValue(), false, movedValue);
105	listDiffEntries[1] = Diffs.createListDiffEntry(msg
106	.getPosition(), true, movedValue);
107	diff = Diffs.createListDiff(listDiffEntries);
108	fireListChange(diff);
109	break;
110	}
111	case Notification.UNSET: {
112	// This just represents going back to the unset state, but
113	// that doesn't affect the contents of the list.
114	//
115	return;
116	}
117	}
118
119	// System.err.println("CHANGE: " + diff.getDifferences()[0].getElement());
120
121	// fireListChange(diff);
122	// listener.handlePropertyChange(new SimplePropertyEvent(msg
123	// .getNotifier(), EMFListProperty.this, diff));
124	}
125	}
126
127	}
128
129	private Adapter listener;
130
131	public EWritableList(NotifyingList<Type> wrappedList) {
132	this(Realm.getDefault(), wrappedList);
133	}
134
135	public EWritableList(Realm realm, NotifyingList<Type> wrappedList) {
136	this(realm, wrappedList, null);
137	}
138
139	public EWritableList(Realm realm, NotifyingList<Type> wrappedList, Class<Type> elementType) {
140	super(realm);
141	this.wrappedList = wrappedList;
142	this.elementType = elementType;
143	if( wrappedList.getNotifier() instanceof Notifier ) {
144	Notifier notifier = (Notifier) wrappedList.getNotifier();
145	listener = new Listener(wrappedList.getFeature());
146	notifier.eAdapters().add(listener);
147	} else {
148	throw new IllegalArgumentException("Wrapped list must have a notifier attached!");
149	}
150	}
151
152	@Override
153	public synchronized void dispose() {
154	((Notifier)wrappedList.getNotifier()).eAdapters().remove(listener);
155	super.dispose();
156	}
157
158	protected void getterCalled() {
159	ObservableTracker.getterCalled(this);
160	}
161
162	public boolean add(Object o) {
163	checkRealm();
164	return wrappedList.add((Type) o);
165	}
166
167	public boolean addAll(Collection c) {
168	checkRealm();
169	return wrappedList.addAll(c);
170	}
171
172	public boolean addAll(int index, Collection c) {
173	checkRealm();
174	return wrappedList.addAll(index, c);
175	}
176
177	public boolean contains(Object o) {
178	getterCalled();
179	return wrappedList.contains(o);
180	}
181
182	public boolean containsAll(Collection c) {
183	getterCalled();
184	return wrappedList.containsAll(c);
185	}
186
187	public Object get(int index) {
188	getterCalled();
189	return wrappedList.get(index);
190	}
191
192	public Object getElementType() {
193	checkRealm();
194	return elementType;
195	}
196
197	public int indexOf(Object o) {
198	getterCalled();
199	return wrappedList.indexOf(o);
200	}
201
202	public boolean isEmpty() {
203	getterCalled();
204	return wrappedList.isEmpty();
205	}
206
207	public Iterator<Type> iterator() {
208	getterCalled();
209	return wrappedList.iterator();
210	}
211
212	public int lastIndexOf(Object o) {
213	getterCalled();
214	return wrappedList.lastIndexOf(o);
215	}
216
217	public ListIterator<Type> listIterator() {
218	getterCalled();
219	return wrappedList.listIterator();
220	}
221
222	public ListIterator<Type> listIterator(int index) {
223	getterCalled();
224	return wrappedList.listIterator(index);
225	}
226
227	public Object move(int oldIndex, int newIndex) {
228	checkRealm();
229	return wrappedList.move(oldIndex, newIndex);
230	}
231
232	public boolean remove(Object o) {
233	checkRealm();
234	return wrappedList.remove(o);
235	}
236
237	public Object remove(int index) {
238	checkRealm();
239	return wrappedList.remove(index);
240	}
241
242	public boolean removeAll(Collection c) {
243	checkRealm();
244	return wrappedList.removeAll(c);
245	}
246
247	@SuppressWarnings("unchecked")
248	public boolean retainAll(Collection c) {
249	checkRealm();
250	return wrappedList.retainAll(c);
251	}
252
253	@SuppressWarnings("unchecked")
254	public Object set(int index, Object element) {
255	checkRealm();
256	return wrappedList.set(index, (Type) element);
257	}
258
259	public int doGetSize() {
260	getterCalled();
261	return wrappedList.size();
262	}
263
264	public List<Type> subList(int fromIndex, int toIndex) {
265	getterCalled();
266	return wrappedList.subList(fromIndex, toIndex);
267	}
268
269	public Object[] toArray() {
270	getterCalled();
271	return wrappedList.toArray();
272	}
273
274	public Object[] toArray(Object[] a) {
275	getterCalled();
276	return wrappedList.toArray();
277	}
278
279	public void add(int index, Object element) {
280	checkRealm();
281	wrappedList.add(index, (Type) element);
282	}
283
284	public void clear() {
285	checkRealm();
286	wrappedList.clear();
287	}
288
289	public boolean isStale() {
290	getterCalled();
291	return stale;
292	}
293
294	// public void setStale(boolean stale) {
295	// checkRealm();
296	//
297	// boolean wasStale = this.stale;
298	// this.stale = stale;
299	// if (!wasStale && stale) {
300	// fireStale();
301	// }
302	// }
303	}

Added Link Here

(-)src/org/eclipse/emf/databinding/properties/IEMFValueProperty.java (+184 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 195222)
10	* Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
11	******************************************************************************/
12
13	package org.eclipse.emf.databinding.properties;
14
15	import org.eclipse.core.databinding.property.value.IValueProperty;
16	import org.eclipse.emf.ecore.EStructuralFeature;
17
18	/**
19	* <p>
20	* <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
21	* removal.</b>
22	* </p>
23	* An {@link IValueProperty} extension interface with convenience methods for
24	* creating nested bean properties.
25	*
26	* @since 1.1
27	* @noextend This interface is not intended to be extended by clients.
28	* @noimplement This interface is not intended to be implemented by clients.
29	*/
30	public interface IEMFValueProperty extends IEMFProperty, IValueProperty {
31	/**
32	* Returns a master-detail combination of this property and the specified
33	* value property.
34	*
35	* @param featurePath
36	* the value property to observe. May be nested e.g.
37	*
38	* <code>property.values(MyPackage.Literals.OBJ_PARENT, MyPackage.Literals.PARENT_NAME)</code>
39	* @return a master-detail combination of this property and the specified
40	* value property.
41	* @see #value(IEMFValueProperty)
42	*/
43	public IEMFValueProperty value(EStructuralFeature... featurePath);
44
45	/**
46	* Returns a master-detail combination of this property and the specified
47	* value property. The returned property will observe the specified detail
48	* value property for the value of the master value property.
49	* <p>
50	* Example:
51	*
52	* <pre>
53	* // Observes the Node-typed "parent" property of a Node object
54	* IBeanValueProperty parent = BeanProperties.value(Node.class, "parent");
55	* // Observes the string-typed "name" property of a Node object
56	* IBeanValueProperty name = BeanProperties.value(Node.class, "name");
57	* // Observes the name of the parent of a Node object.
58	* IBeanValueProperty parentName = parent.value(name);
59	* </pre>
60	*
61	* @param property
62	* the detail property to observe
63	* @return a master-detail combination of this property and the specified
64	* value property.
65	*/
66	public IEMFValueProperty value(IEMFValueProperty property);
67
68	/**
69	* Returns a master-detail combination of this property and the specified
70	* list property.
71	*
72	* @param feature
73	* the list property to observe
74	* @return a master-detail combination of this property and the specified
75	* list property.
76	* @see #list(IEMFListProperty)
77	*/
78	public IEMFListProperty list(EStructuralFeature feature);
79
80	/**
81	* Returns a master-detail combination of this property and the specified
82	* list property. The returned property will observe the specified list
83	* property for the value of the master property.
84	* <p>
85	* Example:
86	*
87	* <pre>
88	* // Observes the Node-typed "parent" property of a Node object.
89	* IBeanValueProperty parent = BeanProperties.value(Node.class, "parent");
90	* // Observes the List-typed "children" property of a Node object
91	* // where the elements are Node objects
92	* IBeanListProperty children = BeanProperties.list(Node.class, "children",
93	* Node.class);
94	* // Observes the children of the parent (siblings) of a Node object.
95	* IBeanListProperty siblings = parent.list(children);
96	* </pre>
97	*
98	* @param property
99	* the detail property to observe
100	* @return a master-detail combination of this property and the specified
101	* list property.
102	*/
103	public IEMFListProperty list(IEMFListProperty property);
104
105	// /**
106	// * Returns a master-detail combination of this property and the specified
107	// * set property.
108	// *
109	// * @param propertyName
110	// * the set property to observe
111	// * @return a master-detail combination of this property and the specified
112	// * set property.
113	// * @see #set(IEMFSetProperty)
114	// */
115	// public IEMFSetProperty set(EStructuralFeature featurePath);
116	//
117	// /**
118	// * Returns a master-detail combination of this property and the specified
119	// * set property. The returned property will observe the specified set
120	// * property for the value of the master property.
121	// * <p>
122	// * Example:
123	// *
124	// * <pre>
125	// * // Observes the Node-typed "parent" property of a Node
126	// object.
127	// * IBeanValueProperty parent = BeanProperties.value(Node.class,
128	// "parent");
129	// * // Observes the Set-typed "children" property of a Node
130	// object
131	// * // where the elements are Node objects
132	// * IBeanSetProperty children = BeanProperties.set(Node.class,
133	// "children",
134	// * Node.class);
135	// * // Observes the children of the parent (siblings) of a Node object.
136	// * IBeanSetProperty siblings = parent.set(children);
137	// * </pre>
138	// *
139	// * @param property
140	// * the detail property to observe
141	// * @return a master-detail combination of this property and the specified
142	// * set property.
143	// */
144	// public IEMFSetProperty set(IEMFSetProperty property);
145
146	/**
147	* Returns a master-detail combination of this property and the specified
148	* map property.
149	*
150	* @param feature
151	* the map property to observe
152	* @return a master-detail combination of this property and the specified
153	* map property.
154	* @see #map(IEMFMapProperty)
155	*/
156	public IEMFMapProperty map(EStructuralFeature feature);
157
158	/**
159	* Returns a master-detail combination of this property and the specified
160	* map property. The returned property will observe the specified map
161	* property for the value of the master property.
162	* <p>
163	* Example:
164	*
165	* <pre>
166	* // Observes the Contact-typed "supervisor" property of a
167	* // Contact class
168	* IBeanValueProperty supervisor = BeanProperties.value(Contact.class,
169	* "supervisor");
170	* // Observes the property "phoneNumbers" of a Contact object--a property mapping
171	* // from PhoneNumberType to PhoneNumber "set-typed "children",
172	* IBeanMapProperty phoneNumbers = BeanProperties.map(Contact.class,
173	* "phoneNumbers", PhoneNumberType.class, PhoneNumber.class);
174	* // Observes the phone numbers of a contact's supervisor:
175	* IBeanMapProperty supervisorPhoneNumbers = supervisor.map(phoneNumbers);
176	* </pre>
177	*
178	* @param property
179	* the detail property to observe
180	* @return a master-detail combination of this property and the specified
181	* map property.
182	*/
183	public IEMFMapProperty map(IEMFMapProperty property);
184	}

Added Link Here

(-)src/org/eclipse/emf/databinding/properties/internal/EMFObservableListDecorator.java (+59 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Brad Reynolds and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Brad Reynolds - initial API and implementation
10	* Matthew Hall - bugs 208858, 246625
11	* Tom Schindl<tom.schindl@bestsolution.at> - Port to EMF
12	******************************************************************************/
13	package org.eclipse.emf.databinding.properties.internal;
14
15	import org.eclipse.core.databinding.observable.IObservable;
16	import org.eclipse.core.databinding.observable.IObserving;
17	import org.eclipse.core.databinding.observable.list.DecoratingObservableList;
18	import org.eclipse.core.databinding.observable.list.IObservableList;
19	import org.eclipse.emf.databinding.properties.IEMFObservable;
20	import org.eclipse.emf.ecore.EStructuralFeature;
21
22	/**
23	* <p>
24	* <b>PROVISIONAL This API is subject to arbitrary change, including renaming or
25	* removal.</b>
26	* </p>
27	* {@link IEMFObservable} decorator for an {@link IObservableList}.
28	*
29	* @since 1.1
30	*/
31	public class EMFObservableListDecorator extends DecoratingObservableList
32	implements IEMFObservable {
33	private EStructuralFeature feature;
34
35	/**
36	* @param decorated
37	* @param feature
38	*/
39	public EMFObservableListDecorator(IObservableList decorated, EStructuralFeature feature) {
40	super(decorated, true);
41	this.feature = feature;
42	}
43
44	public synchronized void dispose() {
45	this.feature = null;
46	super.dispose();
47	}
48
49	public EStructuralFeature getFeature() {
50	return feature;
51	}
52
53	public Object getObserved() {
54	IObservable decorated = getDecorated();
55	if (decorated instanceof IObserving)
56	return ((IObserving) decorated).getObserved();
57	return null;
58	}
59	}

Added Link Here

(-).settings/org.eclipse.jdt.core.prefs (+15 lines)
1	#Sat Jan 24 17:20:53 CET 2009
2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.doc.comment.support=enabled
4	org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
5	org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
6	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
7	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=enabled
8	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
9	org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
10	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
11	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
12	org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=return_tag
13	org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
14	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
15	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected