| /******************************************************************************* |
| * Copyright (c) 2016 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.internal.conflict; |
| |
| import static org.eclipse.emf.compare.ConflictKind.PSEUDO; |
| import static org.eclipse.emf.compare.ConflictKind.REAL; |
| import static org.eclipse.emf.compare.DifferenceKind.ADD; |
| import static org.eclipse.emf.compare.DifferenceKind.CHANGE; |
| import static org.eclipse.emf.compare.DifferenceKind.MOVE; |
| import static org.eclipse.emf.compare.internal.utils.ComparisonUtil.isAddOrSetDiff; |
| import static org.eclipse.emf.compare.internal.utils.ComparisonUtil.isDeleteOrUnsetDiff; |
| import static org.eclipse.emf.compare.utils.EMFCompareJavaPredicates.ofKind; |
| import static org.eclipse.emf.compare.utils.EMFCompareJavaPredicates.onFeature; |
| import static org.eclipse.emf.compare.utils.EMFCompareJavaPredicates.possiblyConflictingWith; |
| import static org.eclipse.emf.compare.utils.EMFCompareJavaPredicates.valueMatches; |
| import static org.eclipse.emf.compare.utils.MatchUtil.matchingIndices; |
| |
| import java.util.Collection; |
| |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.Monitor; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.ReferenceChange; |
| import org.eclipse.emf.compare.diff.FeatureFilter; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| |
| /** |
| * Search conflicts for containment {@link ReferenceChange}s. |
| * |
| * @author <a href="mailto:laurent.delaigue@obeo.fr">Laurent Delaigue</a> |
| */ |
| public class ContainmentRefChangeConflictSearch { |
| |
| /** |
| * Search conflicts for containment {@link ReferenceChange} of kind {@link DifferenceKind#ADD}. |
| * |
| * @author <a href="mailto:laurent.delaigue@obeo.fr">Laurent Delaigue</a> |
| */ |
| public static class Add extends AbstractConflictSearch<ReferenceChange> { |
| |
| /** |
| * Constructor. |
| * |
| * @param diff |
| * The diff to search for conflicts |
| * @param index |
| * Comparison index, must not be null |
| * @param monitor |
| * the monitor to report progress to, must not be null |
| */ |
| public Add(ReferenceChange diff, ComparisonIndex index, Monitor monitor) { |
| super(diff, index, monitor); |
| } |
| |
| @Override |
| public void detectConflicts() { |
| EObject value = diff.getValue(); |
| EReference feature = diff.getReference(); |
| |
| // First let's see if non-containment diffs point to the EObject added |
| Collection<ReferenceChange> refChanges = index.getReferenceChangesByValue(value); |
| Iterable<ReferenceChange> candidates = refChanges.stream() |
| .filter(possiblyConflictingWith(diff).and(ofKind(ADD, CHANGE)))::iterator; |
| for (ReferenceChange candidate : candidates) { |
| if (candidate.getReference().isContainment()) { |
| if (candidate.getReference() == feature && candidate.getMatch() == diff.getMatch()) { |
| // added in the same feature in the same match. |
| // Might be a real conflict if order is significant and not at the same index |
| FeatureFilter featureFilter = getFeatureFilter(comparison); |
| if (featureFilter == null || featureFilter.checkForOrderingChanges(feature)) { |
| if (matchingIndices(diff.getMatch(), feature, value, candidate.getValue())) { |
| conflict(candidate, PSEUDO); |
| } else { |
| conflict(candidate, REAL); |
| } |
| } else { |
| // order doesn't matter |
| conflict(candidate, PSEUDO); |
| } |
| } else { |
| // added in a different feature or another match |
| conflict(candidate, REAL); |
| } |
| } |
| } |
| |
| // Can conflict with other ADD or SET if isMany() == false |
| EList<Diff> diffsInSameMatch = diff.getMatch().getDifferences(); |
| if (!feature.isMany()) { |
| Iterable<Diff> additionalCandidates = diffsInSameMatch.stream() |
| .filter(possiblyConflictingWith(diff).and(ReferenceChange.class::isInstance) |
| .and(onFeature(feature)).and(ofKind(ADD, CHANGE)))::iterator; |
| for (Diff candidate : additionalCandidates) { |
| if (comparison.getEqualityHelper().matchingValues(((ReferenceChange)candidate).getValue(), |
| diff.getValue())) { |
| conflict(candidate, PSEUDO); |
| } else { |
| conflict(candidate, REAL); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Search conflicts for containment {@link ReferenceChange} of kind {@link DifferenceKind#CHANGE}. |
| * |
| * @author <a href="mailto:laurent.delaigue@obeo.fr">Laurent Delaigue</a> |
| */ |
| public static class Change extends AbstractConflictSearch<ReferenceChange> { |
| |
| /** |
| * Constructor. |
| * |
| * @param diff |
| * The diff to search for conflicts |
| * @param index |
| * Comparison index, must not be null |
| * @param monitor |
| * the monitor to report progress to, must not be null |
| */ |
| public Change(ReferenceChange diff, ComparisonIndex index, Monitor monitor) { |
| super(diff, index, monitor); |
| } |
| |
| @Override |
| public void detectConflicts() { |
| EObject value = diff.getValue(); |
| EReference feature = diff.getReference(); |
| |
| // First let's see if non-containment diffs point to the EObject added |
| Collection<ReferenceChange> refChanges = index.getReferenceChangesByValue(value); |
| Iterable<ReferenceChange> candidates = refChanges.stream() |
| .filter(possiblyConflictingWith(diff).and(ofKind(ADD, CHANGE)))::iterator; |
| for (ReferenceChange candidate : candidates) { |
| if (candidate.getReference().isContainment()) { |
| if (candidate.getReference() == feature && candidate.getMatch() == diff.getMatch()) { |
| conflict(candidate, PSEUDO); |
| } else { |
| conflict(candidate, REAL); |
| } |
| } |
| } |
| |
| // Can conflict with other ADD or SET if isMany() == false |
| EList<Diff> diffsInSameMatch = diff.getMatch().getDifferences(); |
| if (!feature.isMany() && isAddOrSetDiff(diff)) { |
| Iterable<Diff> additionalCandidates = diffsInSameMatch.stream() |
| .filter(possiblyConflictingWith(diff).and(ReferenceChange.class::isInstance) |
| .and(onFeature(feature)))::iterator; |
| for (Diff candidate : additionalCandidates) { |
| if (comparison.getEqualityHelper().matchingValues(((ReferenceChange)candidate).getValue(), |
| diff.getValue())) { |
| conflict(candidate, PSEUDO); |
| } else { |
| conflict(candidate, REAL); |
| } |
| } |
| } else if (!isDeleteOrUnsetDiff(diff)) { |
| Iterable<Diff> additionalCandidates = diffsInSameMatch.stream() |
| .filter(possiblyConflictingWith(diff).and(ReferenceChange.class::isInstance) |
| .and(onFeature(feature)))::iterator; |
| for (Diff candidate : additionalCandidates) { |
| if (!isDeleteOrUnsetDiff(candidate) |
| && diff.getReference() == ((ReferenceChange)candidate).getReference()) { |
| // Same value added in the same container/reference couple |
| if (matchingIndices(diff.getMatch(), diff.getReference(), value, |
| ((ReferenceChange)candidate).getValue())) { |
| conflict(candidate, PSEUDO); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Search conflicts for containment {@link ReferenceChange} of kind {@link DifferenceKind#DELETE}. |
| * |
| * @author <a href="mailto:laurent.delaigue@obeo.fr">Laurent Delaigue</a> |
| */ |
| public static class Delete extends AbstractConflictSearch<ReferenceChange> { |
| |
| /** |
| * Constructor. |
| * |
| * @param diff |
| * The diff to search for conflicts |
| * @param index |
| * Comparison index, must not be null |
| * @param monitor |
| * the monitor to report progress to, must not be null |
| */ |
| public Delete(ReferenceChange diff, ComparisonIndex index, Monitor monitor) { |
| super(diff, index, monitor); |
| } |
| |
| @Override |
| public void detectConflicts() { |
| EObject value = diff.getValue(); |
| |
| // First let's see if non-containment diffs point to the EObject deleted from its parent |
| Collection<ReferenceChange> refChanges = index.getReferenceChangesByValue(value); |
| refChanges.stream().filter(possiblyConflictingWith(diff)).filter(d -> !isDeleteOrUnsetDiff(d)) |
| .forEach(d -> conflict(d, REAL)); |
| |
| // Now let's look for conflits with containment ReferenceChanges |
| EList<Diff> diffsInSameMatch = diff.getMatch().getDifferences(); |
| diffsInSameMatch.stream() |
| .filter(possiblyConflictingWith(diff).and(ReferenceChange.class::isInstance) |
| .and(valueMatches(comparison.getEqualityHelper(), value))) |
| .forEach(candidate -> { |
| if (isDeleteOrUnsetDiff(candidate)) { |
| conflict(candidate, PSEUDO); |
| } else { |
| conflict(candidate, REAL); |
| } |
| }); |
| |
| // [381143] Every Diff "under" a containment deletion conflicts with it. |
| final DiffTreeIterator diffIterator = new DiffTreeIterator(comparison.getMatch(value)); |
| diffIterator.setFilter(possiblyConflictingWith(diff)); |
| diffIterator.setPruningFilter(isContainmentDelete()); |
| |
| while (diffIterator.hasNext()) { |
| Diff extendedCandidate = diffIterator.next(); |
| if (isDeleteOrUnsetDiff(extendedCandidate)) { |
| // We do not want to create a pseudo conflict between a deleted container and its |
| // deleted content, since that would prevent us from merging the container deletion |
| // altogether (since pseudo conflicts usually mean that no action is needed). |
| // conflict(extendedCandidate, PSEUDO); |
| } else { |
| conflict(extendedCandidate, REAL); |
| } |
| } |
| |
| } |
| } |
| |
| /** |
| * Search conflicts for containment {@link ReferenceChange} of kind {@link DifferenceKind#MOVE}. |
| * |
| * @author <a href="mailto:laurent.delaigue@obeo.fr">Laurent Delaigue</a> |
| */ |
| public static class Move extends AbstractConflictSearch<ReferenceChange> { |
| |
| /** |
| * Constructor. |
| * |
| * @param diff |
| * The diff to search for conflicts |
| * @param index |
| * Comparison index, must not be null |
| * @param monitor |
| * the monitor to report progress to, must not be null |
| */ |
| public Move(ReferenceChange diff, ComparisonIndex index, Monitor monitor) { |
| super(diff, index, monitor); |
| } |
| |
| @Override |
| public void detectConflicts() { |
| EObject value = diff.getValue(); |
| EReference feature = diff.getReference(); |
| |
| // First let's see if non-containment diffs point to the EObject added |
| Collection<ReferenceChange> refChanges = index.getReferenceChangesByValue(value); |
| Iterable<ReferenceChange> candidates = refChanges.stream() |
| .filter(possiblyConflictingWith(diff).and(ofKind(MOVE))) |
| .filter(d -> d.getReference().isContainment())::iterator; |
| for (ReferenceChange candidate : candidates) { |
| // This is a containment move. It is the only case in which we could have a "move" |
| // difference in a reference where order is not significant |
| if (candidate.getReference() == feature && candidate.getMatch() == diff.getMatch()) { |
| // Same element has been moved into the same container on both sides. If we care about |
| // ordering in this new containment reference, check the indices to detect potential |
| // real conflicts. |
| FeatureFilter featureFilter = getFeatureFilter(comparison); |
| if (featureFilter == null || featureFilter.checkForOrderingChanges(feature)) { |
| if (matchingIndices(diff.getMatch(), feature, value, candidate.getValue())) { |
| conflict(candidate, PSEUDO); |
| } else { |
| conflict(candidate, REAL); |
| } |
| } else { |
| conflict(candidate, PSEUDO); |
| } |
| } else { |
| conflict(candidate, REAL); |
| } |
| } |
| |
| EList<Diff> diffsInSameMatch = diff.getMatch().getDifferences(); |
| diffsInSameMatch.stream() |
| .filter(possiblyConflictingWith(diff) |
| .and(valueMatches(comparison.getEqualityHelper(), value)) |
| .and(ReferenceChange.class::isInstance).and(onFeature(feature))) |
| .forEach(candidate -> { |
| if (matchingIndices(diff.getMatch(), diff.getReference(), value, |
| ((ReferenceChange)candidate).getValue())) { |
| conflict(candidate, PSEUDO); |
| } else { |
| conflict(candidate, REAL); |
| } |
| }); |
| } |
| } |
| } |
