Class MergeContext

    • Constructor Detail

      • MergeContext

        protected MergeContext​(ISynchronizationScopeManager manager,
                               int type,
                               IResourceDiffTree deltaTree)
        Create a merge context.
        Parameters:
        manager - the manager that defines the scope of the synchronization
        type - the type of synchronization (ONE_WAY or TWO_WAY)
        deltaTree - the sync info tree that contains all out-of-sync resources
    • Method Detail

      • merge

        public IStatus merge​(IDiff[] deltas,
                             boolean force,
                             IProgressMonitor monitor)
                      throws CoreException
        Description copied from interface: IMergeContext
        Attempt to merge any files associated with the given diffs. This method is equivalent to calling 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.

        Specified by:
        merge in interface IMergeContext
        Parameters:
        deltas - the differences to be merged
        force - ignore any local changes when performing the merge.
        monitor - a progress monitor
        Returns:
        a status indicating success or failure. A code of MergeStatus.CONFLICTS indicates that the file contain non-mergable conflicts and must be merged manually.
        Throws:
        CoreException - if an error occurs
      • merge

        public IStatus merge​(IDiff diff,
                             boolean ignoreLocalChanges,
                             IProgressMonitor monitor)
                      throws CoreException
        Description copied from interface: IMergeContext
        Method that can be called by the model merger to attempt a file-system level merge. This is useful for cases where the model merger does not need to do any special processing to perform the merge. By default, this method attempts to use an appropriate 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.

        TODO: need to talk about ITwoWayDelta CONTENT and REPLACED
        Specified by:
        merge in interface IMergeContext
        Parameters:
        diff - the difference to be merged
        ignoreLocalChanges - ignore any local changes when performing the merge.
        monitor - a progress monitor
        Returns:
        a status indicating success or failure. A code of MergeStatus.CONFLICTS indicates that the file contain non-mergable conflicts and must be merged manually.
        Throws:
        CoreException - if an error occurs
        See Also:
        IDiffTree.addDiffChangeListener(IDiffChangeListener), IWorkspace.addResourceChangeListener(IResourceChangeListener)
      • performThreeWayMerge

        protected IStatus performThreeWayMerge​(IThreeWayDiff diff,
                                               IProgressMonitor monitor)
                                        throws CoreException
        Perform a three-way merge on the given three-way diff that contains a content conflict. By default, this method makes use of 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.
        Parameters:
        diff - the diff
        monitor - a progress monitor
        Returns:
        a status indicating the results of the merge
        Throws:
        CoreException
      • performReplace

        protected void performReplace​(IDiff diff,
                                      IProgressMonitor monitor)
                               throws CoreException
        Make the local state of the resource associated with the given diff match that of the remote. This method is invoked by the 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.
        Parameters:
        diff - the diff whose local is to be replaced
        monitor - a progress monitor
        Throws:
        CoreException
      • getMergeRule

        public 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. Subclass should override to provide the appropriate rule.
        Specified by:
        getMergeRule in interface IMergeContext
        Parameters:
        diff - the diff to be merged
        Returns:
        the scheduling rule that is required to merge the resource of the given diff
        See Also:
        IMergeContext.getMergeRule(IDiff)
      • getMergeType

        public int getMergeType()
        Description copied from interface: IMergeContext
        Return the type of merge that will be performed when using this context (either 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.
        Specified by:
        getMergeType in interface IMergeContext
        Returns:
        the type of merge that will be performed when using this context.
      • getAdapter

        public <T> T getAdapter​(Class<T> adapter)
        Description copied from class: PlatformObject
        Returns an object which is an instance of the given class associated with this object. Returns 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).

        Specified by:
        getAdapter in interface IAdaptable
        Overrides:
        getAdapter in class PlatformObject
        Type Parameters:
        T - the class type
        Parameters:
        adapter - the class to adapt to
        Returns:
        the adapted object or null
        See Also:
        IAdaptable.getAdapter(Class)