Class AbstractMerger

    • Field Detail

      • SUB_DIFF_AWARE_OPTION

        public static final String SUB_DIFF_AWARE_OPTION
        The key of the merge option that allows to the mergers to consider sub-diffs of a diff as a whole.
        See Also:
        Constant Field Values
      • mergeOptions

        protected Map<Object,​Object> mergeOptions
        The map of all merge options that this merger should be aware of.
        Since:
        3.4
    • Constructor Detail

      • AbstractMerger

        public AbstractMerger()
        Default constructor.
    • Method Detail

      • apply

        public boolean apply​(IMergeCriterion criterion)
        Default implementation of apply for mergers that extends this class. Will accept null or AdditiveMergeCriterion.INSTANCE.
        Specified by:
        apply in interface IMergeCriterionAware
        Parameters:
        criterion - The merge criterion
        Returns:
        true if the given criterion is null or is AdditiveMergeCriterion.INSTANCE.
        Since:
        3.4
      • getDirectMergeDependencies

        public Set<Diff> getDirectMergeDependencies​(Diff diff,
                                                    boolean mergeRightToLeft)
        Retrieves the set of directly required diffs needed in order to merge the current one. This may includes the diff's requirements or any other diff that we need to merge before the given one.
        Specified by:
        getDirectMergeDependencies in interface IMerger2
        Parameters:
        diff - The diff which direct requirements we need.
        mergeRightToLeft - The direction in which we're considering a merge.
        Returns:
        The set of directly required diffs in order to merge the current one.
        Since:
        3.2
      • getDirectResultingMerges

        public Set<Diff> getDirectResultingMerges​(Diff target,
                                                  boolean mergeRightToLeft)
        Returns all differences that will be merged because of our merging the given target difference. This may include the diff's implications, the diff's equivalences, the diff's refinements or any other diff that we need to merge together with the given diff.
        Specified by:
        getDirectResultingMerges in interface IMerger2
        Parameters:
        target - The difference we're considering merging.
        mergeRightToLeft - The direction in which we're considering a merge.
        Returns:
        The Set of all differences that will be merged because we've merged target.
        Since:
        3.2
      • getDirectResultingRejections

        public Set<Diff> getDirectResultingRejections​(Diff target,
                                                      boolean rightToLeft)
        Returns the set of all differences that need to be rejected if target is merged in the given direction.
        Specified by:
        getDirectResultingRejections in interface IMerger2
        Parameters:
        target - The difference we're considering merging.
        rightToLeft - The direction in which we're considering a merge.
        Returns:
        The Set of all differences that will be rejected if we are to merge merged target.
        Since:
        3.2
      • getLogicallyResultingMerges

        protected Set<Diff> getLogicallyResultingMerges​(Diff diff,
                                                        boolean mergeRightToLeft)
        Returns a set of differences that should be logically merged with the given diff. As opposed to merge dependencies, it is not structurally necessary to merge these diffs before the given diff. This may include the diff's implications, the diff's refinement or any other diff that should be logically merged with the given diff.
        Parameters:
        diff - The difference we're considering merging.
        mergeRightToLeft - The direction in which we're considering a merge.
        Returns:
        The Set of all differences that will be merged because we've merged diff.
        Since:
        3.5
      • getImpliedMerges

        protected Set<Diff> getImpliedMerges​(Diff target,
                                             boolean mergeRightToLeft)
        Returns all differences that are automatically set to the targets state if the given target diff is merged. This may include the diff's implications, the diff's equivalences or any other diff that requires no merging by itself.
        Parameters:
        target - The difference we're considering merging.
        mergeRightToLeft - The direction in which we're considering a merge.
        Returns:
        The Set of all differences that will be set to MERGED because we've merged target.
        Since:
        3.5
      • accept

        protected void accept​(Diff diff,
                              boolean rightToLeft)
        Accept the given difference. This may be overridden by clients.
        Parameters:
        diff - the difference to merge
        rightToLeft - the direction of the merge
        Since:
        3.1
      • reject

        protected void reject​(Diff diff,
                              boolean rightToLeft)
        Reject the given difference. This may be overridden by clients.
        Parameters:
        diff - the difference to merge
        rightToLeft - the direction of the merge
        Since:
        3.1
      • mergeDiff

        protected void mergeDiff​(Diff diff,
                                 boolean rightToLeft,
                                 Monitor monitor)
        This can be used by mergers to merge another (required, equivalent...) difference using the right merger for that diff.
        Parameters:
        diff - The diff we need to merge.
        rightToLeft - Direction of that merge.
        monitor - The monitor we should use to report progress.
      • getMergerDelegate

        protected DelegatingMerger getMergerDelegate​(Diff diff)
        Find the best merger for diff and wrap it in a delegate that will take the current merge criterion into account. The current merge criterion should be stored in the merger's mergeOptions map using IMergeCriterion.OPTION_MERGE_CRITERION as a key.
        Parameters:
        diff - The diff
        Returns:
        the best merger to use for merging the diff
        Since:
        3.4
      • getMergerDelegate

        public static DelegatingMerger getMergerDelegate​(Diff diff,
                                                         IMerger.Registry2 registry,
                                                         IMergeCriterion criterion)
        Find the best merger for diff and wrap it in a delegate that will take the given merge criterion into account. This is NOT Thread-safe!
        Parameters:
        diff - The diff
        registry - The registry of mergers where to look for mergers
        criterion - The merge criterion to use
        Returns:
        The best merger for diff and criterion, wrapped in a delegate to deal with setting/restoring the criterion in the merger used.
        Since:
        3.4
      • isInTerminalState

        public static boolean isInTerminalState​(Diff target)
        Returns whether the given difference is in a terminal state or not. Differences that are in a terminal state, i.e., either MERGED or DISCARDED, do not need to be handled by the merger.
        Parameters:
        target - difference
        Returns:
        true if the target should be merged, false otherwise.
        Since:
        3.5
      • isAdd

        protected boolean isAdd​(ReferenceChange diff,
                                boolean rightToLeft)
        Specifies whether the given diff will add a value in the target model for the current merging.

        To check whether the diff is an addition, we have to check the direction of the merge, specified in rightToLeft and the source of the diff. Therefore, this method delegates to isLeftAddOrRightDelete(ReferenceChange) and isLeftDeleteOrRightAdd(ReferenceChange).

        Parameters:
        diff - The difference to check.
        rightToLeft - Direction of the merge.
        Returns:
        true if diff will add a value with this merge, false otherwise.
        Since:
        3.2
      • isUnset

        protected boolean isUnset​(ReferenceChange diff,
                                  boolean mergeRightToLeft)
        Checks whether the given diff will result in the unsetting of a reference in the given merge direction.
        Parameters:
        diff - The difference to check.
        mergeRightToLeft - Direction of the merge.
        Returns:
        true if diff will unset a value with this merge, false if this will either "set" or "change" values... or if the given diff is affecting a multi-valued reference.
      • isSet

        protected boolean isSet​(ReferenceChange diff,
                                boolean mergeRightToLeft)
        Checks whether the given diff will result in the setting of a reference in the given merge direction.
        Parameters:
        diff - The difference to check.
        mergeRightToLeft - Direction of the merge.
        Returns:
        true if diff will set a value with this merge, false if this will either "unset" or "change" values... or if the given diff is affecting a multi-valued reference.
        Since:
        3.5
      • isAccepting

        public static boolean isAccepting​(Diff diff,
                                          boolean mergeRightToLeft)
        Checks whether the given merge direction will result in accepting this difference based on the difference's source.
                             | LEFT  | RIGHT
         --------------------+-------+-------
         Merge Left to Right | true  | false
         Merge Right to Left | false | true
         
        Parameters:
        diff - difference
        mergeRightToLeft - merge direction
        Returns:
        true if the merge source direction matches the difference source, false otherwise.
        Since:
        3.5
        See Also:
        isRejecting(Diff, boolean)
      • createCopy

        protected EObject createCopy​(EObject referenceObject)
        This will create a copy of the given EObject that can be used as the target of an addition (or the reverting of a deletion).

        The target will be self-contained and will have no reference towards any other EObject set (neither containment nor "classic" references). All of its attributes' values will match the given referenceObject's.

        Parameters:
        referenceObject - The EObject for which we'll create a copy.
        Returns:
        A self-contained copy of referenceObject.
        See Also:
        EMFCompareCopier.copy(EObject)
      • addAt

        protected <E> void addAt​(List<E> list,
                                 E value,
                                 int insertionIndex)
        Adds the given value into the given list at the given index. An index lower than zero or greater than the list's size will mean that the value should be appended at the end of the list.
        Type Parameters:
        E - Type of objects contained in the list.
        Parameters:
        list - The list into which value should be added.
        value - The value we need to add to list.
        insertionIndex - The index at which value should be inserted into list. -1 if it should be appended at the end of the list.