Package org.eclipse.emf.compare.merge

Class ReferenceChangeMerger

java.lang.Object
org.eclipse.emf.compare.merge.AbstractMerger
org.eclipse.emf.compare.merge.ReferenceChangeMerger
All Implemented Interfaces:
IMergeCriterionAware, IMergeOptionAware, IMerger, IMerger2
Direct Known Subclasses:
AdditiveReferenceChangeMerger
public class ReferenceChangeMerger extends AbstractMerger
This specific implementation of AbstractMerger will be used to merge reference changes.

  • Constructor Details

    • ReferenceChangeMerger

      public ReferenceChangeMerger()

  • Method Details

    • isMergerFor

      public boolean isMergerFor(Diff target)
      Check if the merger is a good candidate to merge the given difference.
      Parameters:
      target - The given target difference.
      Returns:
      True if it is the good candidate, false otherwise.
      See Also:

    • apply

      public boolean apply(IMergeCriterion criterion)
      Description copied from class: AbstractMerger
      Default implementation of apply for mergers that extends this class. Will accept null or AdditiveMergeCriterion.INSTANCE.
      Specified by:
      apply in interface IMergeCriterionAware
      Overrides:
      apply in class AbstractMerger
      Parameters:
      criterion - The merge criterion
      Returns:
      true if the given criterion is null or is AdditiveMergeCriterion.INSTANCE.

    • reject

      protected void reject(Diff diff, boolean rightToLeft)
      Merge the given difference rejecting it.
      Overrides:
      reject in class AbstractMerger
      Parameters:
      diff - The difference to merge.
      rightToLeft - The direction of the merge.

    • accept

      protected void accept(Diff diff, boolean rightToLeft)
      Merge the given difference accepting it.
      Overrides:
      accept in class AbstractMerger
      Parameters:
      diff - The difference to merge.
      rightToLeft - The direction of the merge.

    • moveElement

      protected void moveElement(ReferenceChange diff, boolean rightToLeft)
      This will be called when trying to copy a "MOVE" diff.
      Parameters:
      diff - The diff we are currently merging.
      rightToLeft - Whether we should move the value in the left or right side.

    • doMove

      protected void doMove(ReferenceChange diff, Comparison comparison, EObject expectedContainer, EObject expectedValue, boolean rightToLeft)
      This will do the actual work of moving the element into its reference. All sanity checks were made in #moveElement(boolean) and no more verification will be made here.
      Parameters:
      diff - The diff we are currently merging.
      comparison - Comparison holding this Diff.
      expectedContainer - The container in which we are reorganizing a reference.
      expectedValue - The value that is to be moved within its reference.
      rightToLeft - Whether we should move the value in the left or right side.

    • addInTarget

      protected void addInTarget(ReferenceChange diff, boolean rightToLeft)
      This will be called when we need to create an element in the target side.

      All necessary sanity checks have been made to ensure that the current operation is one that should create an object in its side or add an objet to a reference. In other words, either :

      • We are copying from right to left and
        • we are copying an addition to the right side (we need to create the same object in the left), or
        • we are copying a deletion from the left side (we need to revert the deletion).
      • We are copying from left to right and
        • we are copying a deletion from the right side (we need to revert the deletion), or
        • we are copying an addition to the left side (we need to create the same object in the right).

      Parameters:
      diff - The diff we are currently merging.
      rightToLeft - Tells us whether we are to add an object on the left or right side.

    • removeFromTarget

      protected void removeFromTarget(ReferenceChange diff, boolean rightToLeft)
      This will be called when we need to remove an element from the target side.

      All necessary sanity checks have been made to ensure that the current operation is one that should delete an object. In other words, we are :

      • Copying from right to left and either
        • we are copying a deletion from the right side (we need to remove the same object in the left) or,
        • we are copying an addition to the left side (we need to revert the addition).
      • Copying from left to right and either
        • we are copying an addition to the right side (we need to revert the addition), or.
        • we are copying a deletion from the left side (we need to remove the same object in the right).

      Parameters:
      diff - The diff we are currently merging.
      rightToLeft - Tells us whether we are to add an object on the left or right side.

    • resetInTarget

      protected void resetInTarget(ReferenceChange diff, boolean rightToLeft)
      This will be called by the merge operations in order to reset a reference to its original value, be that the left or right side.

      Should never be called on multi-valued references.

      Parameters:
      diff - The diff we are currently merging.
      rightToLeft - Tells us the direction of this merge operation.

    • checkImpliedDiffsOrdering

      protected void checkImpliedDiffsOrdering(ReferenceChange diff, boolean rightToLeft)
      In the case of many-to-many eOpposite references, EMF will simply report the difference made on one side of the equivalence to the other, without considering ordering in any way. In such cases, we'll iterate over our equivalences after the merge, and double-check the ordering ourselves, fixing it as needed.

      Note that both implied and equivalent diffs will be double-checked from here.

      Parameters:
      diff - The diff we are currently merging.
      rightToLeft - Direction of the merge.
      Since:
      3.1

    • findMatchIn

      protected EObject findMatchIn(Comparison comparison, List<EObject> list, EObject element)
      Seeks a match of the given element in the given list, using the equality helper to find it. This is only used when moving or deleting proxies for now.
      Parameters:
      comparison - The comparison which Diff we are currently merging.
      list - The list from which we seek a value.
      element - The value for which we need a match in list.
      Returns:
      The match of element in list, null if none.

    • findInsertionIndex

      protected int findInsertionIndex(Comparison comparison, Diff diff, boolean rightToLeft)
      This will be used by the distinct merge actions in order to find the index at which a value should be inserted in its target list. See DiffUtil.findInsertionIndex(Comparison, Diff, boolean) for more on this.

      Sub-classes can override this if the insertion order is irrelevant. A return value of -1 will be considered as "no index" and the value will be inserted at the end of its target list.

      Parameters:
      comparison - This will be used in order to retrieve the Match for EObjects when comparing them.
      diff - The diff which merging will trigger the need for an insertion index in its target list.
      rightToLeft - true if the merging will be done into the left list, so that we should consider the right model as the source and the left as the target.
      Returns:
      The index at which this diff's value should be inserted into the 'target' list, as inferred from rightToLeft. -1 if the value should be inserted at the end of its target list.
      See Also: