Package org.eclipse.emf.compare.merge
Class AbstractMerger
- java.lang.Object
-
- org.eclipse.emf.compare.merge.AbstractMerger
-
- All Implemented Interfaces:
IMergeCriterionAware
,IMergeOptionAware
,IMerger
,IMerger2
- Direct Known Subclasses:
AttributeChangeMerger
,ConflictMerger
,FeatureMapChangeMerger
,PseudoConflictMerger
,ReferenceChangeMerger
,ResourceAttachmentChangeMerger
,ResourceLocationChangeMerger
public abstract class AbstractMerger extends Object implements IMerger2, IMergeOptionAware, IMergeCriterionAware
Abstract implementation of anIMerger
. This can be used as a base implementation to avoid re-implementing the whole contract.- Since:
- 3.0
-
-
Nested Class Summary
-
Nested classes/interfaces inherited from interface org.eclipse.emf.compare.merge.IMerger
IMerger.Registry, IMerger.Registry2, IMerger.RegistryImpl
-
-
Field Summary
Fields Modifier and Type Field Description protected Map<Object,Object>
mergeOptions
The map of all merge options that this merger should be aware of.static 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.
-
Constructor Summary
Constructors Constructor Description AbstractMerger()
Default constructor.
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description protected void
accept(Diff diff, boolean rightToLeft)
Accept the given difference.protected <E> void
addAt(List<E> list, E value, int insertionIndex)
Adds the givenvalue
into the givenlist
at the givenindex
.boolean
apply(IMergeCriterion criterion)
Default implementation of apply for mergers that extends this class.protected void
copyDiff(Diff target, Monitor monitor, boolean rightToLeft)
Executes a copy in the given merge direction.void
copyLeftToRight(Diff target, Monitor monitor)
Executes the copy from left to right.void
copyRightToLeft(Diff target, Monitor monitor)
Executes the copy from right to left.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).Set<Diff>
getDirectMergeDependencies(Diff diff, boolean mergeRightToLeft)
Retrieves the set of directly required diffs needed in order to merge the current one.Set<Diff>
getDirectResultingMerges(Diff target, boolean mergeRightToLeft)
Returns all differences that will be merged because of our merging the giventarget
difference.Set<Diff>
getDirectResultingRejections(Diff target, boolean rightToLeft)
Returns the set of all differences that need to be rejected iftarget
is merged in the given direction.protected Set<Diff>
getImpliedMerges(Diff target, boolean mergeRightToLeft)
Returns all differences that are automatically set to the targetsstate
if the given target diff is merged.protected Set<Diff>
getLogicallyResultingMerges(Diff diff, boolean mergeRightToLeft)
Returns a set of differences that should be logically merged with the given diff.Map<Object,Object>
getMergeOptions()
Get the map of options that the merger will have to take into account.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.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.int
getRanking()
Returns the ranking of this merger.IMerger.Registry
getRegistry()
Get the registry.static boolean
isAccepting(Diff diff, boolean mergeRightToLeft)
Checks whether the given merge direction will result in accepting this difference based on the difference'ssource
.protected boolean
isAdd(ReferenceChange diff, boolean rightToLeft)
Specifies whether the givendiff
will add a value in the target model for the current merging.static boolean
isInTerminalState(Diff target)
Returns whether the given difference is in a terminal state or not.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.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.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.protected void
reject(Diff diff, boolean rightToLeft)
Reject the given difference.void
setMergeOptions(Map<Object,Object> options)
Set the map of options that the merger will have to take into account.void
setRanking(int r)
Set the ranking of this merger.void
setRegistry(IMerger.Registry registry)
Set the registry containing this merger.-
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
-
Methods inherited from interface org.eclipse.emf.compare.merge.IMerger
isMergerFor
-
-
-
-
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
-
-
Method Detail
-
getRanking
public int getRanking()
Returns the ranking of this merger.- Specified by:
getRanking
in interfaceIMerger
- Returns:
- The ranking.
- See Also:
IMerger.getRanking()
-
setRanking
public void setRanking(int r)
Set the ranking of this merger.- Specified by:
setRanking
in interfaceIMerger
- Parameters:
r
- The ranking.- See Also:
IMerger.setRanking(int)
-
getRegistry
public IMerger.Registry getRegistry()
Get the registry.- Specified by:
getRegistry
in interfaceIMerger
- Returns:
- The registry.
- See Also:
IMerger.getRegistry()
-
setRegistry
public void setRegistry(IMerger.Registry registry)
Set the registry containing this merger.- Specified by:
setRegistry
in interfaceIMerger
- Parameters:
registry
- The merger registry.- See Also:
IMerger.setRegistry(org.eclipse.emf.compare.merge.IMerger.Registry)
-
apply
public boolean apply(IMergeCriterion criterion)
Default implementation of apply for mergers that extends this class. Will acceptnull
or AdditiveMergeCriterion.INSTANCE.- Specified by:
apply
in interfaceIMergeCriterionAware
- Parameters:
criterion
- The merge criterion- Returns:
true
if the given criterion is null or is AdditiveMergeCriterion.INSTANCE.- Since:
- 3.4
-
getMergeOptions
public Map<Object,Object> getMergeOptions()
Get the map of options that the merger will have to take into account.- Specified by:
getMergeOptions
in interfaceIMergeOptionAware
- Returns:
- the map of options.
- See Also:
IMergeOptionAware.getMergeOptions()
-
setMergeOptions
public void setMergeOptions(Map<Object,Object> options)
Set the map of options that the merger will have to take into account.- Specified by:
setMergeOptions
in interfaceIMergeOptionAware
- Parameters:
options
- the map of options.- Since:
- 3.3
- See Also:
IMergeOptionAware.setMergeOptions(java.util.Map)
-
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'srequirements
or any other diff that we need to merge before the given one.- Specified by:
getDirectMergeDependencies
in interfaceIMerger2
- 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 giventarget
difference. This may include the diff'simplications
, the diff'sequivalences
, the diff'srefinements
or any other diff that we need to merge together with the given diff.- Specified by:
getDirectResultingMerges
in interfaceIMerger2
- 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 iftarget
is merged in the given direction.- Specified by:
getDirectResultingRejections
in interfaceIMerger2
- 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 tomerge dependencies
, it is not structurally necessary to merge these diffs before the given diff. This may include the diff'simplications
, the diff'srefinement
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 targetsstate
if the given target diff is merged. This may include the diff'simplications
, the diff'sequivalences
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 mergedtarget
. - Since:
- 3.5
-
copyDiff
protected void copyDiff(Diff target, Monitor monitor, boolean rightToLeft)
Executes a copy in the given merge direction. This method is a generalization ofcopyLeftToRight(Diff, Monitor)
andcopyRightToLeft(Diff, Monitor)
.- Parameters:
target
- The difference to handle.monitor
- Monitor.rightToLeft
- Merge direction.- Since:
- 3.5
-
copyLeftToRight
public void copyLeftToRight(Diff target, Monitor monitor)
Executes the copy from left to right.- Specified by:
copyLeftToRight
in interfaceIMerger
- Parameters:
target
- The difference to handle.monitor
- Monitor.- Since:
- 3.1
- See Also:
IMerger.copyLeftToRight(org.eclipse.emf.compare.Diff, org.eclipse.emf.common.util.Monitor)
-
copyRightToLeft
public void copyRightToLeft(Diff target, Monitor monitor)
Executes the copy from right to left.- Specified by:
copyRightToLeft
in interfaceIMerger
- Parameters:
target
- The difference to handle.monitor
- Monitor.- Since:
- 3.1
- See Also:
IMerger.copyRightToLeft(org.eclipse.emf.compare.Diff, org.eclipse.emf.common.util.Monitor)
-
accept
protected void accept(Diff diff, boolean rightToLeft)
Accept the given difference. This may be overridden by clients.- Parameters:
diff
- the difference to mergerightToLeft
- 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 mergerightToLeft
- 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 diffregistry
- The registry of mergers where to look for mergerscriterion
- 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 givendiff
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 inrightToLeft
and thesource of the diff
. Therefore, this method delegates toisLeftAddOrRightDelete(ReferenceChange)
andisLeftDeleteOrRightAdd(ReferenceChange)
.- Parameters:
diff
- The difference to check.rightToLeft
- Direction of the merge.- Returns:
true
ifdiff
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
ifdiff
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
ifdiff
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'ssource
.| LEFT | RIGHT --------------------+-------+------- Merge Left to Right | true | false Merge Right to Left | false | true
- Parameters:
diff
- differencemergeRightToLeft
- 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 givenvalue
into the givenlist
at the givenindex
. Anindex
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 whichvalue
should be added.value
- The value we need to add tolist
.insertionIndex
- The index at whichvalue
should be inserted intolist
.-1
if it should be appended at the end of the list.
-
-