Java tutorial
/******************************************************************************* * Copyright (c) 2012, 2015 Obeo. * 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: * Obeo - initial API and implementation *******************************************************************************/ package org.eclipse.emf.compare.domain.impl; import com.google.common.collect.ImmutableCollection; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import java.util.ArrayList; import java.util.List; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Status; import org.eclipse.emf.common.command.BasicCommandStack; import org.eclipse.emf.common.command.Command; import org.eclipse.emf.common.command.CommandStack; import org.eclipse.emf.common.notify.Notifier; import org.eclipse.emf.common.util.BasicMonitor; import org.eclipse.emf.compare.Comparison; import org.eclipse.emf.compare.Diff; import org.eclipse.emf.compare.command.ICompareCommandStack; import org.eclipse.emf.compare.command.ICompareCopyCommand; import org.eclipse.emf.compare.command.impl.CompareCommandStack; import org.eclipse.emf.compare.command.impl.DualCompareCommandStack; import org.eclipse.emf.compare.command.impl.MergeAllNonConflictingCommand; import org.eclipse.emf.compare.command.impl.MergeCommand; import org.eclipse.emf.compare.command.impl.TransactionalDualCompareCommandStack; import org.eclipse.emf.compare.domain.ICompareEditingDomain; import org.eclipse.emf.compare.domain.IMergeRunnable; import org.eclipse.emf.compare.internal.domain.IMergeAllNonConflictingRunnable; import org.eclipse.emf.compare.internal.utils.ComparisonUtil; import org.eclipse.emf.compare.merge.BatchMerger; import org.eclipse.emf.compare.merge.IBatchMerger; import org.eclipse.emf.compare.merge.IMerger; import org.eclipse.emf.compare.merge.IMerger.Registry; import org.eclipse.emf.compare.provider.EMFCompareEditPlugin; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.change.util.ChangeRecorder; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.resource.ResourceSet; import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; import org.eclipse.emf.edit.domain.EditingDomain; import org.eclipse.emf.edit.provider.IDisposable; import org.eclipse.emf.transaction.TransactionalEditingDomain; import org.eclipse.emf.transaction.impl.AbstractTransactionalCommandStack; import org.eclipse.emf.transaction.util.TransactionUtil; /** * Default implementation that use a change recorder in the background to record the changes made by executed * commands. * * @author <a href="mailto:mikael.barbero@obeo.fr">Mikael Barbero</a> */ public class EMFCompareEditingDomain implements ICompareEditingDomain, IDisposable { /** The change recorder instance. */ private final ChangeRecorder fChangeRecorder; /** The notifiers on which the change recorder will be installed. */ private final ImmutableCollection<Notifier> fNotifiers; /** The command stack on which the merge commands will be executed. */ private final ICompareCommandStack fCommandStack; /** List of domains we've created ourselves and should thus cleanup ourselves. */ private final List<TransactionalEditingDomain> disposableDomains; /** * Creates a new instance with the given notifiers to be listen to when something will be changed. * * @param left * the left root notifier of the comparison (i.e. the * {@link org.eclipse.emf.compare.scope.IComparisonScope#getLeft()} * @param right * the right root notifier of the comparison (i.e. the * {@link org.eclipse.emf.compare.scope.IComparisonScope#getRight()} * @param ancestor * the ancestor root notifier of the comparison (i.e. the * {@link org.eclipse.emf.compare.scope.IComparisonScope#getOrigin()} * @param commandStack * the command stack to be used to track execution of commands. */ public EMFCompareEditingDomain(Notifier left, Notifier right, Notifier ancestor, ICompareCommandStack commandStack) { if (ancestor == null) { fNotifiers = ImmutableList.of(left, right); } else { fNotifiers = ImmutableList.of(left, right, ancestor); } fCommandStack = commandStack; fChangeRecorder = new ChangeRecorder(); fChangeRecorder.setResolveProxies(false); disposableDomains = new ArrayList<TransactionalEditingDomain>(); } /** * Returns the resource set containing the given notifier, the given {@code notifier} if it is a * {@link ResourceSet}, <code>null</code> otherwise. * * @param notifier * the notifier from which we have to look for a {@link ResourceSet}. * @return the resource set containing the given notifier, the given {@code notifier} if it is a * {@link ResourceSet}, <code>null</code> otherwise */ private static ResourceSet getResourceSet(Notifier notifier) { ResourceSet resourceSet = null; if (notifier instanceof ResourceSet) { resourceSet = (ResourceSet) notifier; } else if (notifier instanceof Resource) { resourceSet = ((Resource) notifier).getResourceSet(); } else if (notifier instanceof EObject) { Resource eResource = ((EObject) notifier).eResource(); if (eResource != null) { resourceSet = eResource.getResourceSet(); } } else { // impossible as of today } return resourceSet; } /** * Creates a new compare editing domain on the given notifier with an appropriate * {@link ICompareCommandStack} set up on it. * * @param left * the left notifier. Should not be <code>null</code>. * @param right * the right notifier. Should not be <code>null</code>. * @param ancestor * the ancestor notifier. May be <code>null</code>. * @return a new compare editing domain on the given notifier. */ public static ICompareEditingDomain create(Notifier left, Notifier right, Notifier ancestor) { boolean hadLeftED = getExistingEditingDomain(left) != null; boolean hadRightED = getExistingEditingDomain(right) != null; EditingDomain leftED = getOrCreateEditingDomain(left); EditingDomain rightED = getOrCreateEditingDomain(right); final ICompareEditingDomain domain; if (leftED != null && rightED != null) { CommandStack leftCommandStack = leftED.getCommandStack(); CommandStack rightCommandStack = rightED.getCommandStack(); ICompareCommandStack commandStack; if (leftCommandStack instanceof AbstractTransactionalCommandStack && rightCommandStack instanceof AbstractTransactionalCommandStack) { commandStack = new TransactionalDualCompareCommandStack( (AbstractTransactionalCommandStack) leftCommandStack, (AbstractTransactionalCommandStack) rightCommandStack); } else if (leftCommandStack instanceof BasicCommandStack && rightCommandStack instanceof BasicCommandStack) { commandStack = new DualCompareCommandStack((BasicCommandStack) leftCommandStack, (BasicCommandStack) rightCommandStack); } else { EMFCompareEditPlugin.getPlugin().getLog().log(new Status(IStatus.WARNING, EMFCompareEditPlugin.PLUGIN_ID, "Command stacks of the editing domain of " //$NON-NLS-1$ + left + " and " //$NON-NLS-1$ + right + " are not instances of BasicCommandStack, nor AbstractTransactionalCommandStack, therefore, they will not be used as backing command stacks for the current merge session.")); //$NON-NLS-1$ commandStack = new CompareCommandStack(new BasicCommandStack()); } domain = new EMFCompareEditingDomain(left, right, ancestor, commandStack); } else { domain = create(left, right, ancestor, new BasicCommandStack()); } if (!hadLeftED && leftED instanceof TransactionalEditingDomain) { ((EMFCompareEditingDomain) domain).addDomainToDispose((TransactionalEditingDomain) leftED); } if (!hadRightED && rightED instanceof TransactionalEditingDomain) { ((EMFCompareEditingDomain) domain).addDomainToDispose((TransactionalEditingDomain) rightED); } return domain; } /** * Return an existing editing domain associated with the given {@link Notifier}. * * @param notifier * the notifier from which the editing domain has to be linked. * @return an editing domain associated with the given {@link Notifier} if any. */ private static EditingDomain getExistingEditingDomain(Notifier notifier) { EditingDomain editingDomain = TransactionUtil.getEditingDomain(notifier); if (editingDomain == null) { editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(notifier); } return editingDomain; } /** * Returns an editing domain associated with the given {@link Notifier}. It will first look for a * {@link TransactionalEditingDomain} then for an {@link AdapterFactoryEditingDomain}. It neither is found * a new {@link TransactionalEditingDomain} is created. * * @param notifier * the notifier from which the editing domain has to be linked. * @return an editing domain associated with the given {@link Notifier} */ private static EditingDomain getOrCreateEditingDomain(Notifier notifier) { EditingDomain editingDomain = getExistingEditingDomain(notifier); if (editingDomain == null) { ResourceSet resourceSet = getResourceSet(notifier); if (resourceSet != null) { editingDomain = TransactionalEditingDomain.Factory.INSTANCE.createEditingDomain(resourceSet); } } return editingDomain; } /** * Equivalent to {@code create(left, right, ancestor, commandStack, null)}. * * @param left * the left notifier. Should not be <code>null</code>. * @param right * the right notifier. Should not be <code>null</code>. * @param ancestor * the ancestor notifier. May be <code>null</code>. * @param commandStack * a command stack to which merge command will be delegated to. * @return a newly created compare editing domain. */ public static ICompareEditingDomain create(Notifier left, Notifier right, Notifier ancestor, CommandStack commandStack) { return create(left, right, ancestor, commandStack, null); } /** * Creates a new compare editing domain on the given notifier with an appropriate * {@link ICompareCommandStack} set up on it. * * @param left * the left notifier. Should not be <code>null</code>. * @param right * the right notifier. Should not be <code>null</code>. * @param ancestor * the ancestor notifier. May be <code>null</code>. * @param leftCommandStack * a command stack to which merge to left command will be delegated to. * @param rightCommandStack * a command stack to which merge to irght command will be delegated to. * @return a newly created compare editing domain. */ public static ICompareEditingDomain create(Notifier left, Notifier right, Notifier ancestor, CommandStack leftCommandStack, CommandStack rightCommandStack) { final ICompareCommandStack commandStack; if (leftCommandStack == null && rightCommandStack != null) { if (rightCommandStack instanceof ICompareCommandStack) { commandStack = (ICompareCommandStack) rightCommandStack; } else { commandStack = new CompareCommandStack(rightCommandStack); } } else if (leftCommandStack != null && rightCommandStack == null) { if (leftCommandStack instanceof ICompareCommandStack) { commandStack = (ICompareCommandStack) leftCommandStack; } else { commandStack = new CompareCommandStack(leftCommandStack); } } else if (leftCommandStack instanceof BasicCommandStack && rightCommandStack instanceof BasicCommandStack) { commandStack = new DualCompareCommandStack((BasicCommandStack) leftCommandStack, (BasicCommandStack) rightCommandStack); } else { commandStack = new CompareCommandStack(new BasicCommandStack()); } return new EMFCompareEditingDomain(left, right, ancestor, commandStack); } /** * {@inheritDoc} * * @see org.eclipse.emf.compare.domain.ICompareEditingDomain#dispose() */ public void dispose() { fChangeRecorder.dispose(); if (fCommandStack instanceof IDisposable) { ((IDisposable) fCommandStack).dispose(); } for (TransactionalEditingDomain domain : disposableDomains) { domain.dispose(); } } /** * {@inheritDoc} * * @see org.eclipse.emf.compare.domain.ICompareEditingDomain#getCommandStack() */ public ICompareCommandStack getCommandStack() { return fCommandStack; } /** * {@inheritDoc} * * @see org.eclipse.emf.compare.domain.ICompareEditingDomain#createCopyCommand(org.eclipse.emf.compare.Diff, * boolean, org.eclipse.emf.compare.merge.IMerger.Registry) * @since 3.0 */ public Command createCopyCommand(List<? extends Diff> differences, boolean leftToRight, IMerger.Registry mergerRegistry) { ImmutableSet.Builder<Notifier> notifiersBuilder = ImmutableSet.builder(); for (Diff diff : differences) { notifiersBuilder.add(ComparisonUtil.getComparison(diff)); } ImmutableSet<Notifier> notifiers = notifiersBuilder.addAll(fNotifiers).build(); IMergeRunnable runnable = new IMergeRunnable() { public void merge(List<? extends Diff> diffs, boolean lTR, Registry registry) { final IBatchMerger merger = new BatchMerger(registry); if (lTR) { merger.copyAllLeftToRight(diffs, new BasicMonitor()); } else { merger.copyAllRightToLeft(diffs, new BasicMonitor()); } } }; return new MergeCommand(fChangeRecorder, notifiers, differences, leftToRight, mergerRegistry, runnable); } /** * {@inheritDoc} * * @see org.eclipse.emf.compare.domain.ICompareEditingDomain#createCopyCommand(java.util.List, boolean, * org.eclipse.emf.compare.merge.IMerger.Registry, * org.eclipse.emf.compare.command.ICompareCopyCommand.IMergeRunnable) */ public ICompareCopyCommand createCopyCommand(List<? extends Diff> differences, boolean leftToRight, Registry mergerRegistry, IMergeRunnable runnable) { ImmutableSet.Builder<Notifier> notifiersBuilder = ImmutableSet.builder(); for (Diff diff : differences) { notifiersBuilder.add(ComparisonUtil.getComparison(diff)); } ImmutableSet<Notifier> notifiers = notifiersBuilder.addAll(fNotifiers).build(); return new MergeCommand(fChangeRecorder, notifiers, differences, leftToRight, mergerRegistry, runnable); } /** * Creates a command that will merge all non-conflicting differences in the given direction. * <p> * A "non-conflicting" difference is any difference that is not in a real conflict with another <u>and</u> * that does not, directly or indirectly, depend on the merge of a difference that is in conflict itself. * </p> * <p> * Note that only the differences originating from the "source" side of the chosen merge direction will be * considered. * </p> * * @param comparison * The comparison which differences to merge. * @param leftToRight * The direction in which we should merge the differences. * @param mergerRegistry * The registry to query for specific mergers for each difference. * @param runnable * the runnable to execute for the actual merge operation. * @return The copy command, ready for use. * @since 4.1 */ public ICompareCopyCommand createCopyAllNonConflictingCommand(Comparison comparison, boolean leftToRight, IMerger.Registry mergerRegistry, IMergeAllNonConflictingRunnable runnable) { ImmutableSet.Builder<Notifier> notifiersBuilder = ImmutableSet.builder(); notifiersBuilder.add(comparison); ImmutableSet<Notifier> notifiers = notifiersBuilder.addAll(fNotifiers).build(); return new MergeAllNonConflictingCommand(fChangeRecorder, notifiers, comparison, leftToRight, mergerRegistry, runnable); } /** * {@inheritDoc} * * @see org.eclipse.emf.compare.domain.ICompareEditingDomain#getChangeRecorder() */ public ChangeRecorder getChangeRecorder() { return fChangeRecorder; } /** * Sets up a {@link TransactionalEditingDomain} for disposal along with {@code this}. * * @param domain * The domain that should be disposed when we are. */ private void addDomainToDispose(TransactionalEditingDomain domain) { disposableDomains.add(domain); } }