Attachment #123633 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.emf.ecore.EStructuralFeature;

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




 *
 * 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 2-8 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %pluginName	3	Bundle-Name: %pluginName
4	Bundle-SymbolicName: org.eclipse.emf.databinding; singleton:=true	4	Bundle-SymbolicName: org.eclipse.emf.databinding; singleton:=true
5	Bundle-Version: 1.1.0.qualifier	5	Bundle-Version: 1.2.0.qualifier
6	Bundle-ClassPath: .	6	Bundle-ClassPath: .
7	Bundle-Activator: org.eclipse.emf.databinding.DataBindingPlugin$Implementation	7	Bundle-Activator: org.eclipse.emf.databinding.DataBindingPlugin$Implementation
8	Bundle-Vendor: %providerName	8	Bundle-Vendor: %providerName




/*******************************************************************************
 * 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) {
		diff.applyTo(doGetMap(source));
	}
	
	@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);
	}

	

	

}




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




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




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




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




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

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

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