| /******************************************************************************* |
| * Copyright (c) 2013, 2017 Obeo 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: |
| * Obeo - initial API and implementation |
| * Martin Fleck - bug 507177 |
| *******************************************************************************/ |
| package org.eclipse.emf.compare.uml2.internal.postprocessor; |
| |
| import static com.google.common.base.Predicates.instanceOf; |
| |
| import com.google.common.base.Predicate; |
| import com.google.common.collect.Collections2; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Iterators; |
| import com.google.common.collect.LinkedHashMultimap; |
| import com.google.common.collect.Multimap; |
| import com.google.common.collect.SetMultimap; |
| |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.emf.compare.Comparison; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.Match; |
| import org.eclipse.emf.compare.ReferenceChange; |
| import org.eclipse.emf.compare.ResourceAttachmentChange; |
| import org.eclipse.emf.compare.internal.postprocessor.factories.AbstractChangeFactory; |
| import org.eclipse.emf.compare.internal.utils.ComparisonUtil; |
| import org.eclipse.emf.compare.internal.utils.DiffUtil; |
| import org.eclipse.emf.compare.uml2.internal.StereotypeApplicationChange; |
| import org.eclipse.emf.compare.uml2.internal.UMLDiff; |
| import org.eclipse.emf.compare.utils.EMFComparePredicates; |
| import org.eclipse.emf.compare.utils.MatchUtil; |
| import org.eclipse.emf.compare.utils.ReferenceUtil; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.EStructuralFeature.Setting; |
| import org.eclipse.emf.ecore.util.Switch; |
| import org.eclipse.uml2.common.util.UML2Util; |
| import org.eclipse.uml2.uml.util.UMLSwitch; |
| |
| /** |
| * Factory of UML difference extensions. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| public abstract class AbstractUMLChangeFactory extends AbstractChangeFactory { |
| |
| /** |
| * UML Switch to get the discriminants (if they exist) related to the given business object. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| protected class DiscriminantsGetter extends UMLSwitch<Set<EObject>> { |
| |
| @Override |
| public Set<EObject> defaultCase(EObject object) { |
| return defaultCaseForDiscriminantsGetter(this, object); |
| } |
| } |
| |
| /** |
| * Setting to define a candidate to the seeking of refining differences. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private class RefiningCandidate implements Setting { |
| |
| /** The business object containing the structural feature. */ |
| private EObject holdingObject; |
| |
| /** The structural feature. */ |
| private EStructuralFeature eStructuralFeature; |
| |
| /** |
| * Constructor to use if the origin of the target value is unknown (neither holding object nor |
| * structural feature). This candidate will be considered as a containment reference to the target |
| * value. |
| */ |
| RefiningCandidate() { |
| } |
| |
| /** |
| * Constructor. |
| * |
| * @param holdingObject |
| * The business object containing the structural feature to the target value. |
| * @param feature |
| * the structural feature to the target value. |
| */ |
| RefiningCandidate(EObject holdingObject, EStructuralFeature feature) { |
| this.holdingObject = holdingObject; |
| this.eStructuralFeature = feature; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.ecore.EStructuralFeature.Setting#getEObject() |
| */ |
| public EObject getEObject() { |
| return holdingObject; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.ecore.EStructuralFeature.Setting#getEStructuralFeature() |
| */ |
| public EStructuralFeature getEStructuralFeature() { |
| return eStructuralFeature; |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * No use. Return null. |
| * |
| * @see org.eclipse.emf.ecore.EStructuralFeature.Setting#get(boolean) |
| */ |
| public Object get(boolean resolve) { |
| return null; |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * No use. Do nothing. |
| * |
| * @see org.eclipse.emf.ecore.EStructuralFeature.Setting#set(java.lang.Object) |
| */ |
| public void set(Object newValue) { |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * No use. Return false. |
| * |
| * @see org.eclipse.emf.ecore.EStructuralFeature.Setting#isSet() |
| */ |
| public boolean isSet() { |
| return false; |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * No use. Do nothing. |
| * |
| * @see org.eclipse.emf.ecore.EStructuralFeature.Setting#unset() |
| */ |
| public void unset() { |
| } |
| |
| } |
| |
| /** |
| * It defines the predicate to keep only the differences which match with the given settings (refining |
| * candidates). |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private class DifferencesOnRefiningCandidates implements Predicate<Diff> { |
| |
| /** The comparison. */ |
| private final Comparison fComparison; |
| |
| /** The specified settings. */ |
| private final SetMultimap<Object, RefiningCandidate> fRefiningCandidates; |
| |
| /** |
| * Constructor. |
| * |
| * @param comparison |
| * The comparison. |
| * @param refiningCandidates |
| * The specified settings. |
| */ |
| DifferencesOnRefiningCandidates(Comparison comparison, |
| SetMultimap<Object, RefiningCandidate> refiningCandidates) { |
| fComparison = comparison; |
| fRefiningCandidates = refiningCandidates; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see com.google.common.base.Predicate#apply(java.lang.Object) |
| */ |
| public boolean apply(final Diff input) { |
| boolean result = false; |
| Object value = MatchUtil.getValue(input); |
| Set<RefiningCandidate> settings = fRefiningCandidates.get(value); |
| if (settings.size() > 0) { |
| // Keep the current difference if one specified candidate setting match with it at least. |
| result = Iterables.any(settings, new Predicate<EStructuralFeature.Setting>() { |
| public boolean apply(EStructuralFeature.Setting setting) { |
| boolean res = true; |
| if (setting.getEObject() != null) { |
| // Keep if match of the current difference is the same as the match of the |
| // specified |
| // holding object in the setting... |
| res = input.getMatch() == fComparison.getMatch(setting.getEObject()); |
| } |
| if (setting.getEStructuralFeature() != null) { |
| // ... and the structural feature is the same as the specified one in the |
| // setting. |
| res = res && MatchUtil.getStructuralFeature(input) == setting |
| .getEStructuralFeature(); |
| } else { |
| // If no structural feature specified, check that the reference of the |
| // difference is containment. |
| EStructuralFeature diffFeature = MatchUtil.getStructuralFeature(input); |
| res = res && DiffUtil.isContainmentReference(diffFeature); |
| } |
| return res; |
| } |
| }); |
| } |
| return result; |
| } |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * It checks that the given difference concerns the creation of an UML macroscopic change. <br> |
| * It verifies this difference is not a part of a macroscopic ADD or DELETE not to have a macroscopic |
| * ADD/DELETE plus a macroscopic CHANGE.<br> |
| * At last, the first matching difference allows to create a complete macroscopic change (with all the |
| * refining differences. So, the next matching ones will not be held to avoid to create duplicated |
| * macroscopic changes. |
| * |
| * @see org.eclipse.emf.compare.internal.postprocessor.factories.AbstractChangeFactory#handles(org.eclipse.emf.compare.Diff) |
| */ |
| @Override |
| public boolean handles(Diff input) { |
| return super.handles(input) && !isChangeOnAddOrDelete(input) && input.getRefines().isEmpty(); |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * It creates the macroscopic change and builds it. It sets its discriminant (main business object to |
| * focus). <br> |
| * For a macroscopic ADD/DELETE, it sets its eReference (the reference of the main refining difference (on |
| * the discriminant)). |
| * |
| * @see org.eclipse.emf.compare.internal.postprocessor.factories.IChangeFactory#create(org.eclipse.emf.compare.Diff) |
| */ |
| @Override |
| public Diff create(Diff input) { |
| Diff ret = super.create(input); |
| if (ret instanceof UMLDiff) { |
| ((UMLDiff)ret).setDiscriminant(getDiscriminant(input)); |
| setEReference(input, (UMLDiff)ret); |
| } |
| return ret; |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * During the building process, it sets the differences refining the macroscopic one. |
| * |
| * @see org.eclipse.emf.compare.internal.postprocessor.factories.AbstractChangeFactory#setRefiningChanges(org.eclipse.emf.compare.Diff, |
| * org.eclipse.emf.compare.DifferenceKind, org.eclipse.emf.compare.Diff) |
| */ |
| @Override |
| public void setRefiningChanges(Diff extension, DifferenceKind extensionKind, Diff refiningDiff) { |
| SetMultimap<Object, RefiningCandidate> refiningCandidates = LinkedHashMultimap.create(); |
| |
| Comparison comparison = ComparisonUtil.getComparison(refiningDiff); |
| // From each discriminant business object, ... |
| Set<EObject> discriminants = getDiscriminants(refiningDiff); |
| for (EObject discriminant : discriminants) { |
| // ... define all the business objects which may be impacted by refining differences specifying |
| // the |
| // settings (holding object and structural feature) which link them. |
| defineRefiningCandidates(discriminant, refiningCandidates); |
| // For each of these business objects, find the impacted differences, keeping only the ones |
| // matching the defined settings. |
| for (Object elt : refiningCandidates.keys()) { |
| beRefinedByCrossReferences(comparison, elt, (UMLDiff)extension, |
| new DifferencesOnRefiningCandidates(comparison, refiningCandidates)); |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.internal.postprocessor.factories.IChangeFactory#getParentMatch(org.eclipse.emf.compare.Diff) |
| */ |
| @Override |
| public Match getParentMatch(Diff input) { |
| return getParentMatch(ComparisonUtil.getComparison(input), input); |
| } |
| |
| /** |
| * Get the discriminant business objects concerned by the given difference.<br> |
| * |
| * @param input |
| * The given difference. |
| * @return The set of discriminant business objects. |
| */ |
| protected Set<EObject> getDiscriminants(Diff input) { |
| EObject value; |
| // Get the business object to focus as starting point to find all the discriminant objects. |
| if (input instanceof ReferenceChange && ((ReferenceChange)input).getReference().isContainment()) { |
| value = ((ReferenceChange)input).getValue(); |
| } else { |
| value = MatchUtil.getContainer(ComparisonUtil.getComparison(input), input); |
| } |
| return getDiscriminants(value); |
| } |
| |
| /** |
| * Get the cross referenced object (setting) matching with given predicate, from the given business |
| * object. |
| * |
| * @param object |
| * The given object from which we seek a cross referenced object. |
| * @param predicate |
| * The predicate. |
| * @return the setting containing the cross referenced object. |
| */ |
| protected Setting getInverseReferences(EObject object, Predicate<EStructuralFeature.Setting> predicate) { |
| final Iterator<EStructuralFeature.Setting> crossReferences = UML2Util.getInverseReferences(object) |
| .iterator(); |
| return Iterators.find(crossReferences, predicate, null); |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * The given reference change is related to a macroscopic ADD if... <br> |
| * - Its reference is a containment one<br> |
| * - Its value is the specified discriminant<br> |
| * - Its kind is ADD |
| * |
| * @see org.eclipse.emf.compare.internal.postprocessor.factories.AbstractChangeFactory#isRelatedToAnExtensionAdd(org.eclipse.emf.compare.ReferenceChange) |
| */ |
| @Override |
| protected boolean isRelatedToAnExtensionAdd(ReferenceChange input) { |
| return input.getReference().isContainment() && input.getValue() == getDiscriminant(input) |
| && input.getKind() == DifferenceKind.ADD; |
| } |
| |
| /** |
| * {@inheritDoc}<br> |
| * The given reference change is related to a macroscopic DELETE if... <br> |
| * - Its reference is a containment one<br> |
| * - Its value is the specified discriminant<br> |
| * - Its kind is DELETE |
| * |
| * @see org.eclipse.emf.compare.internal.postprocessor.factories.AbstractChangeFactory#isRelatedToAnExtensionDelete(org.eclipse.emf.compare.ReferenceChange) |
| */ |
| @Override |
| protected boolean isRelatedToAnExtensionDelete(ReferenceChange input) { |
| return input.getReference().isContainment() && input.getValue() == getDiscriminant(input) |
| && input.getKind() == DifferenceKind.DELETE; |
| } |
| |
| // No UML macroscopic change anymore for any changes on discriminants. |
| // /** |
| // * {@inheritDoc}<br> |
| // * The given reference change is related to a macroscopic CHANGE if discriminants are found from the |
| // * business impacted object. |
| // * |
| // * @see |
| // org.eclipse.emf.compare.internal.postprocessor.factories.AbstractChangeFactory#isRelatedToAnExtensionChange(org.eclipse.emf.compare.ReferenceChange) |
| // */ |
| // @Override |
| // protected boolean isRelatedToAnExtensionChange(ReferenceChange input) { |
| // return !getDiscriminants(MatchUtil.getContainer(input.getMatch().getComparison(), input)).isEmpty(); |
| // } |
| |
| // TODO: Add isRelatedToAnExtensionChange(AttributeChange input) |
| |
| /** |
| * Get the switch which allows to return the set of discriminants from any business object.<br> |
| * |
| * @return The switch to get the discriminants. |
| */ |
| protected abstract Switch<Set<EObject>> getDiscriminantsGetter(); |
| |
| /** |
| * Get the main discriminant business object concerned by the given difference. Usually, it will be one of |
| * the ones returned by {@link AbstractUMLChangeFactory#getDiscriminants(Diff)} |
| * |
| * @param input |
| * The difference. |
| * @return The discriminant. |
| */ |
| protected abstract EObject getDiscriminant(Diff input); |
| |
| /** |
| * Default method in discriminant getters ({@link DiscriminantsGetter}) to find discriminants. |
| * |
| * @param discriminantsGetter |
| * The specific discriminant getter. |
| * @param object |
| * The current object as starting point to the seeking of discriminants. |
| * @return The set of discriminants. |
| */ |
| protected static Set<EObject> defaultCaseForDiscriminantsGetter(Switch<Set<EObject>> discriminantsGetter, |
| EObject object) { |
| Set<EObject> result = new LinkedHashSet<EObject>(); |
| EObject parent = object.eContainer(); |
| if (parent != null) { |
| result.addAll(discriminantsGetter.doSwitch(parent)); |
| } |
| return result; |
| } |
| |
| /** |
| * Get the discriminant business objects from the given one. |
| * |
| * @param value |
| * The given business object. |
| * @return The set of discriminants. |
| */ |
| private Set<EObject> getDiscriminants(EObject value) { |
| Switch<Set<EObject>> discriminantGetter = getDiscriminantsGetter(); |
| return discriminantGetter.doSwitch(value); |
| } |
| |
| /** |
| * It defines the business objects to scan and their settings to find the matching refining differences, |
| * from the given discriminant business object. |
| * |
| * @param discriminant |
| * The given discriminant. |
| * @param refiningCandidates |
| * Map business object to the list of settings to keep during the research of refining |
| * differences. This map must not be null. |
| */ |
| private void defineRefiningCandidates(EObject discriminant, |
| Multimap<Object, RefiningCandidate> refiningCandidates) { |
| // The discriminant itself is a candidate, only on an incoming containment reference. |
| refiningCandidates.put(discriminant, new RefiningCandidate()); |
| // Delegation to a recursive method to find the other candidates. |
| defineRefiningCandidatesFrom(discriminant, refiningCandidates); |
| } |
| |
| /** |
| * It defines the business objects to scan and their settings to find the matching refining differences, |
| * from the given discriminant business object. It ignores the given object and searches candidates in all |
| * the referenced objects from it and all the attributes. A recursion is made between containment |
| * references, to scan all the children. Opposite references are taken into account for the candidates. |
| * |
| * @param discriminant |
| * The given discriminant. |
| * @param refiningCandidates |
| * Map business object to the list of settings to keep during the research of refining |
| * differences. This map must not be null. |
| */ |
| private void defineRefiningCandidatesFrom(EObject discriminant, |
| Multimap<Object, RefiningCandidate> refiningCandidates) { |
| Iterator<EStructuralFeature> outgoingFeatures = discriminant.eClass().getEAllStructuralFeatures() |
| .iterator(); |
| while (outgoingFeatures.hasNext()) { |
| EStructuralFeature outgoingFeature = outgoingFeatures.next(); |
| // For each referenced objects and attributes... |
| Iterator<Object> values = ReferenceUtil.getAsList(discriminant, outgoingFeature).iterator(); |
| while (values.hasNext()) { |
| Object value = values.next(); |
| // ... register it with its setting. |
| refiningCandidates.put(value, new RefiningCandidate(discriminant, outgoingFeature)); |
| if (outgoingFeature instanceof EReference && value instanceof EObject) { |
| if (((EReference)outgoingFeature).isContainment()) { |
| // Recursion on children |
| defineRefiningCandidatesFrom((EObject)value, refiningCandidates); |
| } else if (((EReference)outgoingFeature).getEOpposite() != null) { |
| // Take opposite references |
| refiningCandidates.put(discriminant, new RefiningCandidate((EObject)value, |
| ((EReference)outgoingFeature).getEOpposite())); |
| } |
| } |
| } |
| |
| } |
| } |
| |
| /** |
| * Get the match in which the macroscopic change should be added.<br> |
| * Take the same match of the given difference. If it is related to a macroscopic CHANGE, take the match |
| * of the discriminant. |
| * |
| * @param comparison |
| * The current comparison. |
| * @param input |
| * The difference to locate. |
| * @return The containing match. |
| */ |
| private Match getParentMatch(Comparison comparison, Diff input) { |
| if (getRelatedExtensionKind(input) == DifferenceKind.CHANGE) { |
| return comparison.getMatch(getDiscriminant(input)); |
| } else { |
| return input.getMatch(); |
| } |
| } |
| |
| /** |
| * Fill the refining link of the given refined extension (macroscopic change) with the found differences |
| * on the given object (lookup), according to the given predicate. |
| * |
| * @param comparison |
| * The comparison. |
| * @param lookup |
| * The object on which differences have to be found. |
| * @param refinedExtension |
| * The macroscopic change to set (refinedBy link) |
| * @param p |
| * The predicate. |
| */ |
| private void beRefinedByCrossReferences(Comparison comparison, Object lookup, UMLDiff refinedExtension, |
| Predicate<Diff> p) { |
| if (lookup instanceof EObject) { |
| List<Diff> crossReferences = findCrossReferences(comparison, (EObject)lookup, p); |
| refinedExtension.getRefinedBy().addAll(Collections2.filter(crossReferences, |
| EMFComparePredicates.fromSide(refinedExtension.getSource()))); |
| } |
| } |
| |
| /** |
| * Set the eReference link in the given UML difference, from the given unit difference. |
| * |
| * @param input |
| * The unit difference. |
| * @param umlDiff |
| * The UML difference (macroscopic change). |
| */ |
| private void setEReference(Diff input, UMLDiff umlDiff) { |
| if (getRelatedExtensionKind(input) == DifferenceKind.ADD |
| || getRelatedExtensionKind(input) == DifferenceKind.DELETE) { |
| if (input instanceof ReferenceChange) { |
| umlDiff.setEReference(((ReferenceChange)input).getReference()); |
| } else if (input instanceof ResourceAttachmentChange |
| && umlDiff instanceof StereotypeApplicationChange) { |
| // the resource attachment concerns the stereotype application itself. |
| // The reference is located "below" that. |
| final List<Diff> candidates = input.getMatch().getDifferences(); |
| // Little chance that there is more is that the input ... and what we seek. |
| for (Diff candidate : candidates) { |
| if (candidate instanceof ReferenceChange) { |
| umlDiff.setEReference(((ReferenceChange)candidate).getReference()); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * It checks if the given difference concerns is related to a macroscopic CHANGE within a macroscopic |
| * ADD/DELETE. |
| * |
| * @param input |
| * The difference. |
| * @return True if it is related to a CHANGE in an ADD/DELETE. |
| */ |
| protected boolean isChangeOnAddOrDelete(Diff input) { |
| if (getRelatedExtensionKind(input) == DifferenceKind.CHANGE) { |
| final Comparison comparison = ComparisonUtil.getComparison(input); |
| final EObject discriminant = getDiscriminant(input); |
| if (discriminant != null) { |
| return isChangeOnAddOrDelete(input, comparison, discriminant); |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * It checks if the given difference concerns is related to a macroscopic CHANGE within a macroscopic |
| * ADD/DELETE. |
| * |
| * @param input |
| * The given difference. |
| * @param comparison |
| * the related comparison. |
| * @param discriminant |
| * The discriminant found for the given difference. |
| * @return True if it is related to a CHANGE in an ADD/DELETE. |
| */ |
| private boolean isChangeOnAddOrDelete(Diff input, final Comparison comparison, |
| final EObject discriminant) { |
| boolean result = false; |
| Match match = comparison.getMatch(discriminant); |
| if (match != null |
| && Iterables.any(match.getDifferences(), instanceOf(ResourceAttachmentChange.class))) { |
| result = true; |
| } |
| if (!result) { |
| final List<Diff> candidates = comparison.getDifferences(discriminant); |
| for (Diff diff : candidates) { |
| if (diff == input) { |
| // ignore this one |
| } else { |
| DifferenceKind relatedExtensionKind = getRelatedExtensionKind(diff); |
| if ((relatedExtensionKind == DifferenceKind.ADD |
| || relatedExtensionKind == DifferenceKind.DELETE) |
| && getDiscriminant(diff) == discriminant) { |
| result = true; |
| break; |
| } |
| } |
| } |
| } |
| return result; |
| } |
| |
| } |
