342163: [Usability] Papyrus merge should use the service edit of Papyrus

https://bugs.eclipse.org/bugs/show_bug.cgi?id=342163

A save of my work : complete CReferenceChangeLeft/RightMerger

9 files changed, 360 insertions, 46 deletions

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/EObjectComparator.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/EObjectComparator.java
index cde7cd75373..5223fa5bb0c 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/EObjectComparator.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/EObjectComparator.java
@@ -39,7 +39,9 @@ public class EObjectComparator<T> implements Comparator<T> {
 		if(o1 instanceof EObject && o2 instanceof EObject) {

 			final int position1 = getWantedPosition((EObject)o1);

 			final int position2 = getWantedPosition((EObject)o2);

-			return position1 - position2;

+			if(position1 != -1 && position2 != -1) {

+				return position1 - position2;

+			}

 		}

 		return 0;

 	}

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/MoveWithIndexCommand.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/MoveWithIndexCommand.java
index 833b4b9f6be..f76f6502703 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/MoveWithIndexCommand.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/MoveWithIndexCommand.java
@@ -30,31 +30,49 @@ import org.eclipse.gmf.runtime.emf.type.core.requests.IEditCommandRequest;
 import org.eclipse.gmf.runtime.emf.type.core.requests.MoveRequest;

 

 //TODO move this class and create it in the service edit

+//TODO : breaks this class into 2 classes : 1 for the move and another one for the reorder?

 public class MoveWithIndexCommand extends MoveElementsCommand {

 

+	/**

+	 * 

+	 * Constructor.

+	 * 

+	 * @param request

+	 */

 	public MoveWithIndexCommand(final MoveRequest request) {

 		super(request);

 	}

 

-	//TODO : use the method reorder and attachrealposition

+	/**

+	 * 

+	 * @see org.eclipse.gmf.runtime.emf.type.core.commands.MoveElementsCommand#doExecuteWithResult(org.eclipse.core.runtime.IProgressMonitor,

+	 *      org.eclipse.core.runtime.IAdaptable)

+	 * 

+	 * @param monitor

+	 * @param info

+	 * @return

+	 * @throws ExecutionException

+	 */

 	@Override

 	protected CommandResult doExecuteWithResult(final IProgressMonitor monitor, final IAdaptable info) throws ExecutionException {

-		int index = getIndex();

+		final int index = getIndex();

 		if(index != -1) {

 			for(Iterator<?> i = getElementsToMove().keySet().iterator(); i.hasNext();) {

-				EObject element = (EObject)i.next();

-				EReference feature = getTargetFeature(element);

-				//we attach the real position to the object

-				PapyrusEFactory.attachRealPositionEAdapter(element, index);

+				final EObject element = (EObject)i.next();

+				final EReference feature = getTargetFeature(element);

 				if(feature != null) {

 					if(FeatureMapUtil.isMany(getTargetContainer(), feature)) {

-						Object value = getTargetContainer().eGet(feature);

+						if(shouldReorder()) {

+							//we attach the real position to the object

+							PapyrusEFactory.attachRealPositionEAdapter(element, index);

+						}

+						final Object value = getTargetContainer().eGet(feature);

 						if(value instanceof List<?>) {

-							List<?> listValue = (List<?>)value;

-							int indexMax = listValue.size() - 1;

+							final List<?> listValue = (List<?>)value;

+							final int indexMax = listValue.size() - 1;

 							if(indexMax < index) {

 								//we add the element at the end of the list

-								List values = ((List)getTargetContainer().eGet(feature));

+								final List values = ((List<?>)getTargetContainer().eGet(feature));

 								values.add(element);

 								if(shouldReorder()) {

 									PapyrusEFactory.reorderList(values);

@@ -84,6 +102,11 @@ public class MoveWithIndexCommand extends MoveElementsCommand {
 		return super.doExecuteWithResult(monitor, info);

 	}

 

+	@Override

+	public boolean canExecute() {

+		super.canExecute();

+		return true;

+	}

 	/**

 	 * 

 	 * @return

@@ -97,11 +120,17 @@ public class MoveWithIndexCommand extends MoveElementsCommand {
 		return -1;

 	}

 

+	/**

+	 * 

+	 * @return

+	 *         <code>true</code> when the list should be reorderded

+	 */

 	protected boolean shouldReorder() {

-		IEditCommandRequest req = getRequest();

+		final IEditCommandRequest req = getRequest();

+		boolean shouldReoder = false;

 		if(req instanceof MoveWithIndexRequest) {

-			return ((MoveWithIndexRequest)req).shouldReoder();

+			shouldReoder = ((MoveWithIndexRequest)req).shouldReoder();

 		}

-		return false;

+		return shouldReoder;

 	}

 }

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/MoveWithIndexRequest.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/MoveWithIndexRequest.java
index 718fc0020c0..0bc4a3d3b3a 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/MoveWithIndexRequest.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/MoveWithIndexRequest.java
@@ -23,11 +23,18 @@ import org.eclipse.gmf.runtime.emf.type.core.requests.MoveRequest;
  * 

  * Created for EMF-Compare, for MoveModelElementMerger

  * 

+ * 

  */

 public class MoveWithIndexRequest extends MoveRequest {

 

+	/**

+	 * the wanted index for the moved element

+	 */

 	private final int index;

 

+	/**

+	 * indicates if the list should be reordered after the move

+	 */

 	private final boolean reorder;

 

 	//TODO : and the other constructor?

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/PapyrusCompareEObjectCopier.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/PapyrusCompareEObjectCopier.java
index 6cd1ab64dbf..86eb69add77 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/PapyrusCompareEObjectCopier.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/PapyrusCompareEObjectCopier.java
@@ -13,22 +13,41 @@
  *****************************************************************************/

 package org.eclipse.papyrus.uml.compare.merger.utils;

 

+import java.util.ArrayList;

 import java.util.Collection;

+import java.util.Collections;

+import java.util.List;

 

 import org.eclipse.emf.common.command.Command;

+import org.eclipse.emf.common.notify.impl.AdapterImpl;

 import org.eclipse.emf.compare.diff.merge.EMFCompareEObjectCopier;

 import org.eclipse.emf.compare.diff.merge.service.MergeService;

 import org.eclipse.emf.compare.diff.metamodel.DiffElement;

 import org.eclipse.emf.ecore.EObject;

 import org.eclipse.emf.ecore.EReference;

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

 import org.eclipse.emf.transaction.TransactionalEditingDomain;

 import org.eclipse.papyrus.uml.merger.provider.PapyrusMergeCommandProvider;

 

-

+/**

+ * 

+ * This class copies the code of {@link EMFCompareEObjectCopier}, to do the actions with EMFCommands

+ * 

+ */

 public class PapyrusCompareEObjectCopier {

 

+	/**

+	 * we encapsulate the "standard" implementation of {@link EMFCompareEObjectCopier}

+	 */

 	private EMFCompareEObjectCopier copier = null;

 

+	/**

+	 * 

+	 * Constructor.

+	 * 

+	 * @param diff

+	 *        a diff element

+	 */

 	public PapyrusCompareEObjectCopier(final DiffElement diff) {

 		copier = MergeService.getCopier(diff);

 	}

@@ -44,8 +63,7 @@ public class PapyrusCompareEObjectCopier {
 	 * @param index

 	 * @return

 	 */

-	public Command getCopyReferenceValueCommand(final EReference targetReference, final EObject target, final EObject value, final EObject matchedValue, final int index) {

-		final TransactionalEditingDomain domain = MergerUtils.getEditingDomain();

+	public Command getCopyReferenceValueCommand(final TransactionalEditingDomain domain, final EReference targetReference, final EObject target, final EObject value, final EObject matchedValue, final int index) {

 		EObject actualValue = value;

 		if(value == null && matchedValue != null) {

 			//			handleLinkedResourceDependencyChange(matchedValue);

@@ -58,11 +76,12 @@ public class PapyrusCompareEObjectCopier {
 

 			final Object referenceValue = target.eGet(targetReference);

 			if(referenceValue instanceof Collection<?>) {

-				//TODO

-				//				addAtIndex((Collection<EObject>)referenceValue, matchedValue, index);

-				throw new UnsupportedOperationException("Not yet supported");

+				//tested with ReferenceChangeLefttargetExample

+				return getAddAtIndexCommand(domain, target, targetReference, (Collection<EObject>)referenceValue, matchedValue, index);

+

 			} else {

-				//				target.eSet(targetReference, matchedValue);

+				//target.eSet(targetReference, matchedValue);

+				//tested with the project UpdateReferenceExample2

 				return PapyrusMergeCommandProvider.INSTANCE.getSetCommand(domain, target, targetReference, targetReference);

 			}

 			//			return matchedValue;

@@ -72,5 +91,109 @@ public class PapyrusCompareEObjectCopier {
 		throw new UnsupportedOperationException("Not yet supported");

 	}

 

+	/**

+	 * 

+	 * @param key

+	 * @return

+	 *         the copied object

+	 */

+	public EObject getCopiedValue(final EObject key) {

+		return this.copier.get(key);

+	}

+

+	/**

+	 * Returns the command to set the wanted object at the wanted index

+	 * 

+	 * @param domain

+	 * @param editedElement

+	 * @param feature

+	 * @param collection

+	 * @param newValue

+	 * @param index

+	 * @return

+	 */

+	private Command getAddAtIndexCommand(final TransactionalEditingDomain domain, final EObject editedElement, final EStructuralFeature feature, final Collection<EObject> collection, final EObject newValue, final int index) {

+		final List<EObject> newColl = new ArrayList<EObject>(collection);

+		final int listSize = collection.size();

+		if(index > -1 && index < listSize) {

+			newColl.add(index, newValue);

+		} else {

+			newColl.add(newValue);

+		}

+		attachRealPositionEAdapter(newValue, index);

+		reorderList(newColl);

+		return PapyrusMergeCommandProvider.INSTANCE.getSetCommand(domain, editedElement, feature, newColl);

+	}

+

+	/**

+	 * Duplicate code from EFactory

+	 * If we could not merge a given object at its expected position in a list, we'll attach an Adapter to it

+	 * in order to "remember" that "expected" position. That will allow us to reorder the list later on if

+	 * need be.

+	 * 

+	 * @param object

+	 *        The object on which to attach an Adapter.

+	 * @param expectedPosition

+	 *        The expected position of <code>object</code> in its list.

+	 */

+	private void attachRealPositionEAdapter(final Object object, final int expectedPosition) {

+		if(object instanceof EObject) {

+			((EObject)object).eAdapters().add(new PositionAdapter(expectedPosition));

+		}

+	}

+

+	/**

+	 * Duplicate code from EFactory

+	 * Reorders the given list if it contains EObjects associated with a PositionAdapter which are not located

+	 * at their expected positions.

+	 * 

+	 * @param list

+	 *        The list that is to be reordered.

+	 * @param <T>

+	 *        type of the list's elements.

+	 */

+	private <T> void reorderList(final List<T> list) {

+		final List<T> newList = new ArrayList<T>(list);

+		Collections.sort(newList, new EObjectComparator());

+		for(int i = 0; i < list.size(); i++) {

+			int oldIndex = list.indexOf(newList.get(i));

+			list.add(i, list.remove(oldIndex));

+		}

+		return;

+	}

+

+

+	/**

+	 * This class exists in several classes of this plugin. It is not an error : the same obejct can be referenced by different

+	 * feature and different position at the same time. So we need to have a class PositionAdapter for each context!

+	 * duplicate code from Efactory

+	 * This adapter will be used to remember the accurate position of an EObject in its target list.

+	 * 

+	 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>

+	 */

+	private class PositionAdapter extends AdapterImpl {

+

+		/** The index at which we expect to find this object. */

+		private final int expectedIndex;

+

+		/**

+		 * Creates our adapter.

+		 * 

+		 * @param index

+		 *        The index at which we expect to find this object.

+		 */

+		public PositionAdapter(final int index) {

+			this.expectedIndex = index;

+		}

+

+		/**

+		 * Returns the index at which we expect to find this object.

+		 * 

+		 * @return The index at which we expect to find this object.

+		 */

+		public int getExpectedIndex() {

+			return expectedIndex;

+		}

+	}

 

 }

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/PapyrusMap.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/PapyrusMap.java
index c9223eca3b0..8f50000990c 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/PapyrusMap.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/compare/merger/utils/PapyrusMap.java
@@ -45,7 +45,7 @@ public class PapyrusMap<K, V> extends HashMap<K, V> {
 	 *         if the initial capacity is negative

 	 *         or the load factor is nonpositive.

 	 */

-	public PapyrusMap(int initialCapacity, float loadFactor) {

+	public PapyrusMap(final int initialCapacity, final float loadFactor) {

 		super(initialCapacity, loadFactor);

 	}

 

@@ -58,7 +58,7 @@ public class PapyrusMap<K, V> extends HashMap<K, V> {
 	 * @throws IllegalArgumentException

 	 *         if the initial capacity is negative.

 	 */

-	public PapyrusMap(int initialCapacity) {

+	public PapyrusMap(final int initialCapacity) {

 		super(initialCapacity);

 	}

 

@@ -81,12 +81,20 @@ public class PapyrusMap<K, V> extends HashMap<K, V> {
 	 * @throws NullPointerException

 	 *         if the specified map is null.

 	 */

-	public PapyrusMap(Map<? extends K, ? extends V> m) {

+	public PapyrusMap(final Map<? extends K, ? extends V> m) {

 		super(m);

 	}

 

+	/**

+	 * We display an error when a wanted element is not included in the Map

+	 * 

+	 * @see java.util.HashMap#get(java.lang.Object)

+	 * 

+	 * @param key

+	 * @return

+	 */

 	@Override

-	public V get(Object key) {

+	public V get(final Object key) {

 		V obj = super.get(key);

 		if(obj == null) {

 			Activator.log.error("The following element is unknown in the map : " + key, new NullPointerException());

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CReferenceChangeLeftTargetMerger.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CReferenceChangeLeftTargetMerger.java
index 6553f44dbd3..2894d307db0 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CReferenceChangeLeftTargetMerger.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CReferenceChangeLeftTargetMerger.java
@@ -14,19 +14,23 @@
 package org.eclipse.papyrus.uml.merger.provider;

 

 import java.util.Iterator;

+import java.util.List;

+import java.util.ListIterator;

 

 import org.eclipse.core.commands.ExecutionException;

 import org.eclipse.core.runtime.IAdaptable;

 import org.eclipse.core.runtime.IProgressMonitor;

 import org.eclipse.emf.common.command.Command;

 import org.eclipse.emf.common.command.CompoundCommand;

-import org.eclipse.emf.common.command.UnexecutableCommand;

 import org.eclipse.emf.compare.FactoryException;

 import org.eclipse.emf.compare.diff.internal.merge.impl.ReferenceChangeLeftTargetMerger;

 import org.eclipse.emf.compare.diff.metamodel.DiffElement;

 import org.eclipse.emf.compare.diff.metamodel.ReferenceChangeLeftTarget;

+import org.eclipse.emf.compare.diff.metamodel.ReferenceOrderChange;

 import org.eclipse.emf.compare.diff.metamodel.ResourceDependencyChange;

 import org.eclipse.emf.ecore.EObject;

+import org.eclipse.emf.ecore.EReference;

+import org.eclipse.emf.ecore.InternalEObject;

 import org.eclipse.emf.ecore.resource.Resource;

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

 import org.eclipse.emf.transaction.TransactionalEditingDomain;

@@ -35,6 +39,7 @@ import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCo
 import org.eclipse.papyrus.commands.wrappers.GMFtoEMFCommandWrapper;

 import org.eclipse.papyrus.uml.compare.merger.Activator;

 import org.eclipse.papyrus.uml.compare.merger.utils.MergerUtils;

+import org.eclipse.papyrus.uml.compare.merger.utils.PapyrusCompareEObjectCopier;

 import org.eclipse.papyrus.uml.compare.merger.utils.PapyrusEFactory;

 

 

@@ -141,13 +146,61 @@ public class CReferenceChangeLeftTargetMerger extends ReferenceChangeLeftTargetM
 

 	public Command getDoUndoInTargetCommand(final TransactionalEditingDomain domain) {

 		final CompoundCommand cmd = new CompoundCommand();

-		//		return cmd;

-		//TODO

-		return UnexecutableCommand.INSTANCE;

+		final ReferenceChangeLeftTarget theDiff = (ReferenceChangeLeftTarget)this.diff;

+		final EReference reference = theDiff.getReference();

+		final EObject element = theDiff.getRightElement();

+		final EObject leftTarget = theDiff.getLeftTarget();

+		final EObject rightTarget = theDiff.getRightTarget();

+

+		int index = -1;

+		if(reference.isMany()) {

+			final EObject leftElement = theDiff.getLeftElement();

+			final Object leftRefValue = leftElement.eGet(reference);

+			if(leftRefValue instanceof List) {

+				final List<?> refLeftValueList = (List<?>)leftRefValue;

+				index = refLeftValueList.indexOf(leftTarget);

+			}

+		}

+		final PapyrusCompareEObjectCopier copier = new PapyrusCompareEObjectCopier(diff);

+		Command copierCommand = copier.getCopyReferenceValueCommand(domain, reference, element, leftTarget, rightTarget, index);

+		cmd.append(copierCommand);

+		final AbstractTransactionalCommand updateDiffModelCommand = new AbstractTransactionalCommand(domain, "Update Diff Model", null) {

+

+			@Override

+			protected CommandResult doExecuteWithResult(final IProgressMonitor monitor, final IAdaptable info) throws ExecutionException {

+				final EObject copiedValue = copier.getCopiedValue(leftTarget);

+				final Iterator<EObject> siblings = getDiffModel().eAllContents();

+				while(siblings.hasNext()) {

+					final DiffElement op = (DiffElement)siblings.next();

+					if(op instanceof ReferenceChangeLeftTarget) {

+						final ReferenceChangeLeftTarget link = (ReferenceChangeLeftTarget)op;

+						// now if I'm in the target References I should put my copy in the origin

+						if(link.getReference().equals(reference.getEOpposite()) && link.getLeftTarget().equals(element)) {

+							removeFromContainer(link);

+						}

+					} else if(op instanceof ReferenceOrderChange) {

+						final ReferenceOrderChange link = (ReferenceOrderChange)op;

+						if(link.getLeftElement() == element && link.getReference() == reference) {

+							final ListIterator<EObject> targetIterator = link.getLeftTarget().listIterator();

+							boolean replaced = false;

+							while(!replaced && targetIterator.hasNext()) {

+								final EObject target = targetIterator.next();

+								if(target.eIsProxy() && equalProxyURIs(((InternalEObject)target).eProxyURI(), EcoreUtil.getURI(leftTarget))) {

+									targetIterator.set(copiedValue);

+									replaced = true;

+								}

+							}

+						}

+					}

+				}

+				return CommandResult.newOKCommandResult();

+			}

+		};

+		cmd.append(new GMFtoEMFCommandWrapper(updateDiffModelCommand));

+		return cmd;

 	}

 

 	public Command getMergeRequiredDifferencesCommand(final TransactionalEditingDomain domain, final boolean applyInOrigin) {

-		// TODO the super method mergeRequiredDifferences should be rewritten to use cmd too

 		return new GMFtoEMFCommandWrapper(new AbstractTransactionalCommand(domain, "Merge Required Differences", null) {

 

 			@Override

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CReferenceChangeRightTargetMerger.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CReferenceChangeRightTargetMerger.java
index 25653831623..0d1cece3afb 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CReferenceChangeRightTargetMerger.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CReferenceChangeRightTargetMerger.java
@@ -14,19 +14,23 @@
 package org.eclipse.papyrus.uml.merger.provider;

 

 import java.util.Iterator;

+import java.util.List;

+import java.util.ListIterator;

 

 import org.eclipse.core.commands.ExecutionException;

 import org.eclipse.core.runtime.IAdaptable;

 import org.eclipse.core.runtime.IProgressMonitor;

 import org.eclipse.emf.common.command.Command;

 import org.eclipse.emf.common.command.CompoundCommand;

-import org.eclipse.emf.common.command.UnexecutableCommand;

 import org.eclipse.emf.compare.FactoryException;

 import org.eclipse.emf.compare.diff.internal.merge.impl.ReferenceChangeRightTargetMerger;

 import org.eclipse.emf.compare.diff.metamodel.DiffElement;

 import org.eclipse.emf.compare.diff.metamodel.ReferenceChangeRightTarget;

+import org.eclipse.emf.compare.diff.metamodel.ReferenceOrderChange;

 import org.eclipse.emf.compare.diff.metamodel.ResourceDependencyChange;

 import org.eclipse.emf.ecore.EObject;

+import org.eclipse.emf.ecore.EReference;

+import org.eclipse.emf.ecore.InternalEObject;

 import org.eclipse.emf.ecore.resource.Resource;

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

 import org.eclipse.emf.transaction.TransactionalEditingDomain;

@@ -35,6 +39,7 @@ import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCo
 import org.eclipse.papyrus.commands.wrappers.GMFtoEMFCommandWrapper;

 import org.eclipse.papyrus.uml.compare.merger.Activator;

 import org.eclipse.papyrus.uml.compare.merger.utils.MergerUtils;

+import org.eclipse.papyrus.uml.compare.merger.utils.PapyrusCompareEObjectCopier;

 import org.eclipse.papyrus.uml.compare.merger.utils.PapyrusEFactory;

 

 

@@ -97,9 +102,60 @@ public class CReferenceChangeRightTargetMerger extends ReferenceChangeRightTarge
 

 	public Command getDoApplyInOriginCommand(final TransactionalEditingDomain domain) {

 		CompoundCommand cmd = new CompoundCommand("Undo In Target Command for CReferenceChangeRightTargetMerger#getDoApplyInOriginCommand");

-		//		return cmd;

-		//TODO

-		return UnexecutableCommand.INSTANCE;

+		final ReferenceChangeRightTarget theDiff = (ReferenceChangeRightTarget)this.diff;

+		final EReference reference = theDiff.getReference();

+		final EObject element = theDiff.getLeftElement();

+		final EObject rightTarget = theDiff.getRightTarget();

+		final EObject leftTarget = theDiff.getLeftTarget();

+

+		// ordering handling:

+		int index = -1;

+		if(reference.isMany()) {

+			final EObject rightElement = theDiff.getRightElement();

+			final Object rightRefValue = rightElement.eGet(reference);

+			if(rightRefValue instanceof List) {

+				final List<?> refRightValueList = (List<?>)rightRefValue;

+				index = refRightValueList.indexOf(rightTarget);

+			}

+		}

+		final PapyrusCompareEObjectCopier copier = new PapyrusCompareEObjectCopier(diff);

+		cmd.append(copier.getCopyReferenceValueCommand(domain, reference, element, rightTarget, leftTarget, index));

+

+		cmd.append(new GMFtoEMFCommandWrapper(new AbstractTransactionalCommand(domain, "", null) {

+

+			@Override

+			protected CommandResult doExecuteWithResult(final IProgressMonitor monitor, final IAdaptable info) throws ExecutionException {

+				final EObject copiedValue = copier.getCopiedValue(rightTarget);

+				// We'll now look through this reference's eOpposite as they are already taken care of

+				final Iterator<EObject> related = getDiffModel().eAllContents();

+				while(related.hasNext()) {

+					final DiffElement op = (DiffElement)related.next();

+					if(op instanceof ReferenceChangeRightTarget) {

+						final ReferenceChangeRightTarget link = (ReferenceChangeRightTarget)op;

+						// If this is my eOpposite, delete it from the DiffModel (merged along with this one)

+						if(link.getReference().equals(theDiff.getReference().getEOpposite()) && link.getRightTarget().equals(element)) {

+							removeFromContainer(link);

+						}

+					} else if(op instanceof ReferenceOrderChange) {

+						final ReferenceOrderChange link = (ReferenceOrderChange)op;

+						if(link.getLeftElement() == element && link.getReference() == reference) {

+							final ListIterator<EObject> targetIterator = link.getLeftTarget().listIterator();

+							boolean replaced = false;

+							while(!replaced && targetIterator.hasNext()) {

+								final EObject target = targetIterator.next();

+								if(target.eIsProxy() && equalProxyURIs(((InternalEObject)target).eProxyURI(), EcoreUtil.getURI(rightTarget))) {

+									targetIterator.set(copiedValue);

+									replaced = true;

+								}

+							}

+						}

+					}

+				}

+				return CommandResult.newOKCommandResult();

+			}

+		}));

+

+		return cmd;

 	}

 

 	public Command getDoUndoInTargetCommand(final TransactionalEditingDomain domain) {

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CUpdateReferenceMerger.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CUpdateReferenceMerger.java
index ba5c33a76c1..060527676d4 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CUpdateReferenceMerger.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/CUpdateReferenceMerger.java
@@ -18,16 +18,18 @@ import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IProgressMonitor;

 import org.eclipse.emf.common.command.Command;

 import org.eclipse.emf.common.command.CompoundCommand;

-import org.eclipse.emf.common.command.UnexecutableCommand;

 import org.eclipse.emf.compare.diff.internal.merge.impl.UpdateReferenceMerger;

 import org.eclipse.emf.compare.diff.metamodel.UpdateReference;

 import org.eclipse.emf.ecore.EObject;

 import org.eclipse.emf.ecore.EReference;

+import org.eclipse.emf.ecore.util.FeatureMapUtil;

+import org.eclipse.emf.edit.command.SetCommand;

 import org.eclipse.emf.transaction.TransactionalEditingDomain;

 import org.eclipse.gmf.runtime.common.core.command.CommandResult;

 import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;

 import org.eclipse.papyrus.commands.wrappers.GMFtoEMFCommandWrapper;

 import org.eclipse.papyrus.uml.compare.merger.utils.MergerUtils;

+import org.eclipse.papyrus.uml.compare.merger.utils.PapyrusCompareEObjectCopier;

 

 

 public class CUpdateReferenceMerger extends UpdateReferenceMerger implements ICommandMerger {

@@ -97,22 +99,56 @@ public class CUpdateReferenceMerger extends UpdateReferenceMerger implements ICo
 		final EObject matchedLeftTarget = theDiff.getLeftTarget();

 

 		if(leftTarget == null) {

-			// We're unsetting the value, no need to copy

-			//TODO

-			cmd = UnexecutableCommand.INSTANCE;

-			//			element.eUnset(reference);

+			if(FeatureMapUtil.isMany(element, reference)) {

+				//TODO : I didn't find an example to test this case.

+				throw new UnsupportedOperationException("Not Yet Supported");

+			} else {

+				final Object value = theDiff.getLeftElement().eGet(reference);

+				if(value instanceof EObject) {

+					cmd = PapyrusMergeCommandProvider.INSTANCE.getDestroyReferenceCommand(domain, element, reference, (EObject)value, false);

+				} else {

+					//TODO : we don't use the ServiceEdit

+					//TODO : not tested

+					//			element.eUnset(reference);

+					cmd = new SetCommand(domain, element, reference, null);

+				}

+			}

 		} else {

-			//TODO

-			cmd = UnexecutableCommand.INSTANCE;

-			//			MergeService.getCopier(diff).copyReferenceValue(reference, element, leftTarget,

-			//					matchedLeftTarget, -1);

+			final PapyrusCompareEObjectCopier copier = new PapyrusCompareEObjectCopier(diff);

+			cmd = copier.getCopyReferenceValueCommand(domain, reference, element, leftTarget, matchedLeftTarget, -1);

 		}

 		return cmd;

 	}

 

+

 	public Command getDoUndoInTargetCommand(final TransactionalEditingDomain domain) {

-		// TODO

-		return UnexecutableCommand.INSTANCE;

+		Command cmd = null;

+		final UpdateReference theDiff = (UpdateReference)this.diff;

+		final EReference reference = theDiff.getReference();

+		final EObject element = theDiff.getRightElement();

+		final EObject rightTarget = (EObject)theDiff.getLeftElement().eGet(reference);

+		final EObject matchedRightTarget = theDiff.getRightTarget();

+

+		if(rightTarget == null) {

+			if(FeatureMapUtil.isMany(element, reference)) {

+				//TODO : I didn't find an example to test this case.

+				throw new UnsupportedOperationException("Not Yet Supported");

+			} else {

+				final Object value = theDiff.getRightElement().eGet(reference);

+				if(value instanceof EObject) {

+					cmd = PapyrusMergeCommandProvider.INSTANCE.getDestroyReferenceCommand(domain, element, reference, (EObject)value, false);

+				} else {

+					//TODO : we don't use the ServiceEdit

+					//TODO : not tested

+					//			element.eUnset(reference);

+					cmd = new SetCommand(domain, element, reference, null);

+				}

+			}

+		} else {

+			final PapyrusCompareEObjectCopier copier = new PapyrusCompareEObjectCopier(diff);

+			cmd = copier.getCopyReferenceValueCommand(domain, reference, element, rightTarget, matchedRightTarget, -1);

+		}

+		return cmd;

 	}

 

 	public Command getMergeRequiredDifferencesCommand(final TransactionalEditingDomain domain, final boolean applyInOrigin) {

diff --git a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/PapyrusMergeCommandProvider.java b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/PapyrusMergeCommandProvider.java
index e8c5a4a6da2..86ea40aa0ee 100644
--- a/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/PapyrusMergeCommandProvider.java
+++ b/sandbox/UMLCompareMergerExample/org.eclipse.papyrus.uml.compare.merger/src/org/eclipse/papyrus/uml/merger/provider/PapyrusMergeCommandProvider.java
@@ -37,7 +37,7 @@ import org.eclipse.papyrus.infra.services.edit.service.IElementEditService;
 import org.eclipse.papyrus.uml.compare.merger.utils.MoveWithIndexCommand;

 import org.eclipse.papyrus.uml.compare.merger.utils.MoveWithIndexRequest;

 

-

+//TODO : try to merge with the PapyrusTableCommandFactory?

 public class PapyrusMergeCommandProvider {

 

 	public static PapyrusMergeCommandProvider INSTANCE = new PapyrusMergeCommandProvider();