public abstract class MergeContext extends SynchronizationContext implements IMergeContext
IResourceMappingMerger
.
It provides access to the ancestor and remote resource mapping contexts
so that resource mapping mergers can attempt head-less auto-merges.
The ancestor context is only required for merges while the remote
is required for both merge and replace.IResourceMappingMerger
THREE_WAY, TWO_WAY
Modifier | Constructor and Description |
---|---|
protected |
MergeContext(ISynchronizationScopeManager manager,
int type,
IResourceDiffTree deltaTree)
Create a merge context.
|
Modifier and Type | Method and Description |
---|---|
protected void |
ensureParentsExist(IResource resource,
IProgressMonitor monitor)
Ensure that the parent folders of the given resource exist.
|
Object |
getAdapter(Class adapter)
Returns an object which is an instance of the given class
associated with this object.
|
ISchedulingRule |
getMergeRule(IDiff diff)
Default implementation that returns the resource itself if it exists
and the first existing parent if the resource does not exist.
|
ISchedulingRule |
getMergeRule(IDiff[] deltas)
Return the scheduling rule that is required to merge (or reject) the resources
associated with the given diffs.
|
int |
getMergeType()
Return the type of merge that will be performed when using this
context (either
ISynchronizationContext.TWO_WAY or
ISynchronizationContext.THREE_WAY ). |
protected abstract void |
makeInSync(IDiff diff,
IProgressMonitor monitor)
Method that is invoked from
performReplace(IDiff, IProgressMonitor) after the local has been
changed to match the remote. |
void |
markAsMerged(IDiff[] nodes,
boolean inSyncHint,
IProgressMonitor monitor)
Mark the files associated with the given diff nodes as being merged.
|
IStatus |
merge(IDiff[] deltas,
boolean force,
IProgressMonitor monitor)
Attempt to merge any files associated with the given diffs.
|
IStatus |
merge(IDiff diff,
boolean ignoreLocalChanges,
IProgressMonitor monitor)
Method that can be called by the model merger to attempt a file-system
level merge.
|
protected void |
performReplace(IDiff diff,
IProgressMonitor monitor)
Make the local state of the resource associated with the given diff match
that of the remote.
|
protected IStatus |
performThreeWayMerge(IThreeWayDiff diff,
IProgressMonitor monitor)
Perform a three-way merge on the given three-way diff that contains a content conflict.
|
void |
reject(IDiff[] diffs,
IProgressMonitor monitor)
Reject the changes associated with the given diffs.
|
void |
run(IWorkspaceRunnable runnable,
ISchedulingRule rule,
int flags,
IProgressMonitor monitor)
|
dispose, getCache, getDiffTree, getScope, getScopeManager, getType, refresh
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
markAsMerged, reject
dispose, getCache, getDiffTree, getScope, getType, refresh, refresh
protected MergeContext(ISynchronizationScopeManager manager, int type, IResourceDiffTree deltaTree)
type
- public void reject(IDiff[] diffs, IProgressMonitor monitor) throws CoreException
IMergeContext
IMergeContext.reject(IDiff, IProgressMonitor)
for
each diff.reject
in interface IMergeContext
diffs
- the diffsmonitor
- a progress monitorCoreException
public void markAsMerged(IDiff[] nodes, boolean inSyncHint, IProgressMonitor monitor) throws CoreException
IMergeContext
IMergeContext.markAsMerged(IDiff, boolean, IProgressMonitor)
for each diff but gives the context the opportunity to optimize the
operation for multiple files.
This method will batch change notification by using the
IMergeContext.run(IWorkspaceRunnable, ISchedulingRule, int, IProgressMonitor)
method. The rule for he method will be obtained using
IMergeContext.getMergeRule(IDiff)
and the flags will be
IResource.NONE
meaning that intermittent change events may
occur. Clients may wrap the call in an outer run that either uses a
broader scheduling rule or the IWorkspace.AVOID_UPDATES
flag.
markAsMerged
in interface IMergeContext
nodes
- the nodes to be marked as mergedinSyncHint
- a hint to the context that the model persisted in the
file is in-sync.monitor
- a progress monitorCoreException
- if errors occurpublic IStatus merge(IDiff[] deltas, boolean force, IProgressMonitor monitor) throws CoreException
IMergeContext
IMergeContext.merge(IDiff, boolean, IProgressMonitor)
for each diff
individually but gives the context a chance to perform a more optimal
merge involving multiple resources.
This method will batch change notification by using the
IMergeContext.run(IWorkspaceRunnable, ISchedulingRule, int, IProgressMonitor)
method. The rule for he method will be obtained using
IMergeContext.getMergeRule(IDiff)
and the flags will be
IResource.NONE
meaning that intermittent change events may
occur. Clients may wrap the call in an outer run that either uses a
broader scheduling rule or the IWorkspace.AVOID_UPDATES
flag.
merge
in interface IMergeContext
deltas
- the differences to be mergedforce
- ignore any local changes when performing the merge.monitor
- a progress monitorMergeStatus.CONFLICTS
indicates that the file
contain non-mergable conflicts and must be merged manually.CoreException
- if an error occurspublic IStatus merge(IDiff diff, boolean ignoreLocalChanges, IProgressMonitor monitor) throws CoreException
IMergeContext
IStorageMerger
to merge the
files covered by the provided traversals. If a storage merger cannot be
found, the text merger is used. If this behavior is not desired,
sub-classes of MergeContext
may override this method.
This method does a best-effort attempt to merge of the file associated
with the given diff. A file that could not be merged will be indicated in
the returned status. If the status returned has the code
MergeStatus.CONFLICTS
, the list of failed files can be
obtained by calling the MergeStatus#getConflictingFiles()
method.
It is not expected that clients of this API will associate special meaning with the existence of a folder other than the fact that it contains files. The sync delta tree should still include folder changes so that clients that have a one-to-one correspondence between their model objects and folders can decorate these elements appropriately. However, clients of this API will only be expected to perform operations on file deltas and will expect folders to be created as needed to contain the files (i.e. implementations of this method should ignore any folder deltas in the provided deltas). Clients will also expect local folders that have incoming folder deletions to be removed once all the folder's children have been removed using merge.
There are two special cases where merge is meaningful for folders. First, a merge on a local added empty folder with force set should delete the folder. However, the folder should not be deleted if it has any local children unless merge is called for those resources first and they end up being deleted as a result. Second, a merge on an incoming folder addition should create the empty folder locally.
It is not expected that clients of this API will be capable of dealing with namespace conflicts. Implementors should ensure that any namespace conflicts are dealt with before the merger is invoked.
The deltas provided to this method should be those obtained from the tree (ISynchronizationContext.getDiffTree()
)
of this context. Any resource changes triggered by this merge will be
reported through the resource delta mechanism and the change notification
mechanisms of the delta tree associated with this context.
For two-way merging, as indicated by either the
ISynchronizationContext.getType()
or IMergeContext.getMergeType()
methods, clients can either accept changes using the
IMergeContext.merge(IDiff[], boolean, IProgressMonitor)
method or reject them
using IMergeContext.markAsMerged(IDiff, boolean, IProgressMonitor)
.
Three-way changes are a bit more complicated. The following list
summarizes how particular remote file changes can be handled. The delta
kind and flags mentioned in the descriptions are obtained the remote
change (see IThreeWayDiff.getRemoteChange()
), whereas conflicts
are indicated by the three-way delta itself.
IDiff.ADD
and the delta is also a
move (i.e. the ITwoWayDiff.MOVE_FROM
is set). The merge can
either use the IMergeContext.merge(IDiff[], boolean, IProgressMonitor)
method
to accept the rename or perform an
IFile.move(IPath, boolean, boolean, IProgressMonitor)
where the
source file is obtained using ITwoWayDiff.getFromPath()
and the
destination is the path of the delta (IDiff.getPath()
). This
later approach is helpful in the case where the local file and remote
file both contain content changes (i.e. the file can be moved by the
model and then the contents can be merged by the model). IDiff.REMOVE
and the delta is also a
move (i.e. the ITwoWayDiff.MOVE_TO
is set). The merge can either
use the IMergeContext.merge(IDiff[], boolean, IProgressMonitor)
method to
accept the rename or perform an
IFile.move(IPath, boolean, boolean, IProgressMonitor)
where the
source file is obtained using IDiff.getPath()
and the destination
is obtained from ITwoWayDiff.getToPath()
. This later approach is
helpful in the case where the local file and remote file both contain
content changes (i.e. the file can be moved by the model and then the
contents can be merged by the model). IDiff.ADD
and it is not part of a
move, the merger must use the
IMergeContext.merge(IDiff[], boolean, IProgressMonitor)
method to accept this
change. If there is a conflicting addition, the force flag can be set to
override the local change. If the model wishes to keep the local changes,
they can overwrite the file after merging it. Models should consult the
flags to see if the remote change is a rename (ITwoWayDiff.MOVE_FROM
).
IDiff.REMOVE
and it is not part of a
move, the merger can use the
IMergeContext.merge(IDiff[], boolean, IProgressMonitor)
method but could also
perform the delete manually using any of the IFile
delete
methods. In the case where there are local changes to the file being
deleted, the model may either choose to merge using the force flag (thus
removing the file and the local changes) or call
IMergeContext.markAsMerged(IDiff, boolean, IProgressMonitor)
on the file
which will convert the incoming deletion to an outgoing addition.IDiff.CHANGE
and there is no
conflict, the model is advised to use the
IMergeContext.merge(IDiff[], boolean, IProgressMonitor)
method to merge these
changes as this is the most efficient means to do so. However, the model
can choose to perform the merge themselves and then invoke
IMergeContext.markAsMerged(IDiff, boolean, IProgressMonitor)
with the
inSyncHint
set to true
but this will be
less efficient. IDiff.CHANGE
and there is a conflict,
the model can use the IMergeContext.merge(IDiff[], boolean, IProgressMonitor)
method to merge these changes. If the force flag is not set, an
auto-merge is attempted using an appropriate IStorageMerger
. If
the force flag is set, the local changes are discarded. The model can
choose to attempt the merge themselves and, if it is successful, invoke
IMergeContext.markAsMerged(IDiff, boolean, IProgressMonitor)
with the
inSyncHint
set to false
which will make the
file an outgoing change. merge
in interface IMergeContext
diff
- the difference to be mergedignoreLocalChanges
- ignore any local changes when performing the merge.monitor
- a progress monitorMergeStatus.CONFLICTS
indicates that the file
contain non-mergable conflicts and must be merged manually.CoreException
- if an error occursIDiffTree.addDiffChangeListener(IDiffChangeListener)
,
IWorkspace.addResourceChangeListener(IResourceChangeListener)
protected IStatus performThreeWayMerge(IThreeWayDiff diff, IProgressMonitor monitor) throws CoreException
IStorageMerger
instances registered
with the storageMergers
extension point. Note that the ancestor
of the given diff may be missing. Some IStorageMerger
instances
can still merge without an ancestor so we need to consult the
appropriate merger to find out.diff
- the diffmonitor
- a progress monitorCoreException
protected void performReplace(IDiff diff, IProgressMonitor monitor) throws CoreException
merge(IDiff, boolean, IProgressMonitor)
method. By default, it
either overwrites the local contexts with the remote contents if both
exist, deletes the local if the remote does not exists or adds the local
if the local doesn't exist but the remote does. It then calls
makeInSync(IDiff, IProgressMonitor)
to give subclasses a change
to make the file associated with the diff in-sync.diff
- the diff whose local is to be replacedmonitor
- a progress monitorCoreException
protected abstract void makeInSync(IDiff diff, IProgressMonitor monitor) throws CoreException
performReplace(IDiff, IProgressMonitor)
after the local has been
changed to match the remote. Subclasses may override
performReplace(IDiff, IProgressMonitor)
or this method in order
to properly reconcile the synchronization state. This method is also
invoked from merge(IDiff, boolean, IProgressMonitor)
if deletion
conflicts are encountered. It can also be invoked from that same method if
a folder is created due to an incoming folder addition.diff
- the diff whose local is now in-syncmonitor
- a progress monitorCoreException
protected void ensureParentsExist(IResource resource, IProgressMonitor monitor) throws CoreException
performReplace(IDiff, IProgressMonitor)
for files that are being merged that do not exist locally.
By default, this method creates the parents using
IFolder.create(boolean, boolean, IProgressMonitor)
.
Subclasses may override.resource
- a resourcemonitor
- a progress monitorCoreException
- if an error occurspublic void run(IWorkspaceRunnable runnable, ISchedulingRule rule, int flags, IProgressMonitor monitor) throws CoreException
run
in interface IMergeContext
runnable
- a workspace runnablerule
- a scheduling rule to be obtained while the runnable is runflags
- flags indicating when updates occur (either
IResource.NONE
or
IWorkspace.AVOID_UPDATE
.monitor
- a progress monitorCoreException
- if an error occursIMergeContext.run(org.eclipse.core.resources.IWorkspaceRunnable, org.eclipse.core.runtime.jobs.ISchedulingRule, int, org.eclipse.core.runtime.IProgressMonitor)
public ISchedulingRule getMergeRule(IDiff diff)
getMergeRule
in interface IMergeContext
diff
- the diff to be mergedIMergeContext.getMergeRule(IDiff)
public ISchedulingRule getMergeRule(IDiff[] deltas)
IMergeContext
IMergeContext.markAsMerged(IDiff[], boolean, IProgressMonitor)
and IMergeContext.reject(IDiff[], IProgressMonitor)
.getMergeRule
in interface IMergeContext
deltas
- the diffs being mergedpublic int getMergeType()
IMergeContext
ISynchronizationContext.TWO_WAY
or
ISynchronizationContext.THREE_WAY
). In most cases,
this type which match that returned by ISynchronizationContext.getType()
.
However, for some THREE_WAY synchronizations, the merge type may
be TWO_WAY which indicates that clients of the context should
ignore local changes when performing merges. This capability is
provided to support replace operations that support three-way
preview but ignore local changes when replacing.getMergeType
in interface IMergeContext
public Object getAdapter(Class adapter)
PlatformObject
null
if
no such object can be found.
This implementation of the method declared by IAdaptable
passes the request along to the platform's adapter manager; roughly
Platform.getAdapterManager().getAdapter(this, adapter)
.
Subclasses may override this method (however, if they do so, they
should invoke the method on their superclass to ensure that the
Platform's adapter manager is consulted).
getAdapter
in interface IAdaptable
getAdapter
in class PlatformObject
adapter
- the class to adapt tonull
IAdaptable.getAdapter(Class)
Copyright (c) 2000, 2015 Eclipse Contributors and others. All rights reserved.Guidelines for using Eclipse APIs.