Package org.eclipse.jgit.merge

Class ResolveMerger

  • Direct Known Subclasses:
    RecursiveMerger
    public class ResolveMerger
extends ThreeWayMerger
    A three-way merger performing a content-merge if necessary

    • Field Detail

      • tw

        protected NameConflictTreeWalk tw
        The tree walk which we'll iterate over to merge entries.
        Since:
        3.4

      • commitNames

        protected String[] commitNames
        string versions of a list of commit SHA1s
        Since:
        3.0

      • builder

        protected DirCacheBuilder builder
        Builder to update the cache during this merge.
        Since:
        3.4

      • resultTree

        protected ObjectId resultTree
        merge result as tree
        Since:
        3.0

      • unmergedPaths

        protected List<String> unmergedPaths
        Paths that could not be merged by this merger because of an unsolvable conflict.
        Since:
        3.4

      • modifiedFiles

        protected List<String> modifiedFiles
        Files modified during this merge operation.
        Since:
        3.4

      • toBeCheckedOut

        protected Map<String,​DirCacheEntry> toBeCheckedOut
        If the merger has nothing to do for a file but check it out at the end of the operation, it can be added here.
        Since:
        3.4

      • toBeDeleted

        protected List<String> toBeDeleted
        Paths in this list will be deleted from the local copy at the end of the operation.
        Since:
        3.4

      • mergeResults

        protected Map<String,​MergeResult<? extends Sequence>> mergeResults
        Low-level textual merge results. Will be passed on to the callers in case of conflicts.
        Since:
        3.4

      • enterSubtree

        protected boolean enterSubtree
        Updated as we merge entries of the tree walk. Tells us whether we should recurse into the entry if it is a subtree.
        Since:
        3.4

      • inCore

        protected boolean inCore
        Set to true if this merge should work in-memory. The repos dircache and workingtree are not touched by this method. Eventually needed files are created as temporary files and a new empty, in-memory dircache will be used instead the repo's one. Often used for bare repos where the repo doesn't even have a workingtree and dircache.
        Since:
        3.0

      • implicitDirCache

        protected boolean implicitDirCache
        Set to true if this merger should use the default dircache of the repository and should handle locking and unlocking of the dircache. If this merger should work in-core or if an explicit dircache was specified during construction then this field is set to false.
        Since:
        3.0

      • dircache

        protected DirCache dircache
        Directory cache
        Since:
        3.0

      • workingTreeIterator

        protected WorkingTreeIterator workingTreeIterator
        The iterator to access the working tree. If set to null this merger will not touch the working tree.
        Since:
        3.0

      • mergeAlgorithm

        protected MergeAlgorithm mergeAlgorithm
        our merge algorithm
        Since:
        3.0

    • Constructor Detail

      • ResolveMerger

        protected ResolveMerger​(Repository local,
                        boolean inCore)
        Constructor for ResolveMerger.
        Parameters:
        local - the Repository.
        inCore - a boolean.

      • ResolveMerger

        protected ResolveMerger​(Repository local)
        Constructor for ResolveMerger.
        Parameters:
        local - the Repository.

      • ResolveMerger

        protected ResolveMerger​(ObjectInserter inserter,
                        Config config)
        Constructor for ResolveMerger.
        Parameters:
        inserter - an ObjectInserter object.
        config - the repository configuration
        Since:
        4.8

    • Method Detail

      • setContentMergeStrategy

        public void setContentMergeStrategy​(ContentMergeStrategy strategy)
        Sets the content merge strategy for content conflicts.
        Parameters:
        strategy - ContentMergeStrategy to use
        Since:
        5.12

      • processEntry

        protected boolean processEntry​(CanonicalTreeParser base,
                               CanonicalTreeParser ours,
                               CanonicalTreeParser theirs,
                               DirCacheBuildIterator index,
                               WorkingTreeIterator work,
                               boolean ignoreConflicts,
                               Attributes attributes)
                        throws MissingObjectException,
                               IncorrectObjectTypeException,
                               CorruptObjectException,
                               IOException
        Processes one path and tries to merge taking git attributes in account. This method will do all trivial (not content) merges and will also detect if a merge will fail. The merge will fail when one of the following is true
        • the index entry does not match the entry in ours. When merging one branch into the current HEAD, ours will point to HEAD and theirs will point to the other branch. It is assumed that the index matches the HEAD because it will only not match HEAD if it was populated before the merge operation. But the merge commit should not accidentally contain modifications done before the merge. Check the git read-tree documentation for further explanations.
        • A conflict was detected and the working-tree file is dirty. When a conflict is detected the content-merge algorithm will try to write a merged version into the working-tree. If the file is dirty we would override unsaved data.
        Parameters:
        base - the common base for ours and theirs
        ours - the ours side of the merge. When merging a branch into the HEAD ours will point to HEAD
        theirs - the theirs side of the merge. When merging a branch into the current HEAD theirs will point to the branch which is merged into HEAD.
        index - the index entry
        work - the file in the working tree
        ignoreConflicts - see mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)
        attributes - the attributes defined for this entry
        Returns:
        false if the merge will fail because the index entry didn't match ours or the working-dir file was dirty and a conflict occurred
        Throws:
        MissingObjectException
        IncorrectObjectTypeException
        CorruptObjectException
        IOException
        Since:
        4.9

      • setCommitNames

        public void setCommitNames​(String[] commitNames)
        Set the names of the commits as they would appear in conflict markers
        Parameters:
        commitNames - the names of the commits as they would appear in conflict markers

      • getCommitNames

        public String[] getCommitNames()
        Get the names of the commits as they would appear in conflict markers.
        Returns:
        the names of the commits as they would appear in conflict markers.

      • getUnmergedPaths

        public List<String> getUnmergedPaths()
        Get the paths with conflicts. This is a subset of the files listed by getModifiedFiles()
        Returns:
        the paths with conflicts. This is a subset of the files listed by getModifiedFiles()

      • getModifiedFiles

        public List<String> getModifiedFiles()
        Get the paths of files which have been modified by this merge.
        Returns:
        the paths of files which have been modified by this merge. A file will be modified if a content-merge works on this path or if the merge algorithm decides to take the theirs-version. This is a superset of the files listed by getUnmergedPaths().

      • getToBeCheckedOut

        public Map<String,​DirCacheEntry> getToBeCheckedOut()
        Get a map which maps the paths of files which have to be checked out because the merge created new fully-merged content for this file into the index.
        Returns:
        a map which maps the paths of files which have to be checked out because the merge created new fully-merged content for this file into the index. This means: the merge wrote a new stage 0 entry for this path.

      • getFailingPaths

        public Map<String,​ResolveMerger.MergeFailureReason> getFailingPaths()
        Get list of paths causing this merge to fail (not stopped because of a conflict).
        Returns:
        lists paths causing this merge to fail (not stopped because of a conflict). null is returned if this merge didn't fail.

      • failed

        public boolean failed()
        Returns whether this merge failed (i.e. not stopped because of a conflict)
        Returns:
        true if a failure occurred, false otherwise

      • setDirCache

        public void setDirCache​(DirCache dc)
        Sets the DirCache which shall be used by this merger. If the DirCache is not set explicitly and if this merger doesn't work in-core, this merger will implicitly get and lock a default DirCache. If the DirCache is explicitly set the caller is responsible to lock it in advance. Finally the merger will call DirCache.commit() which requires that the DirCache is locked. If the mergeImpl() returns without throwing an exception the lock will be released. In case of exceptions the caller is responsible to release the lock.
        Parameters:
        dc - the DirCache to set

      • setWorkingTreeIterator

        public void setWorkingTreeIterator​(WorkingTreeIterator workingTreeIterator)
        Sets the WorkingTreeIterator to be used by this merger. If no WorkingTreeIterator is set this merger will ignore the working tree and fail if a content merge is necessary.

        TODO: enhance WorkingTreeIterator to support write operations. Then this merger will be able to merge with a different working tree abstraction.

        Parameters:
        workingTreeIterator - the workingTreeIt to set

      • mergeTrees

        protected boolean mergeTrees​(AbstractTreeIterator baseTree,
                             RevTree headTree,
                             RevTree mergeTree,
                             boolean ignoreConflicts)
                      throws IOException
        The resolve conflict way of three way merging
        Parameters:
        baseTree - a AbstractTreeIterator object.
        headTree - a RevTree object.
        mergeTree - a RevTree object.
        ignoreConflicts - Controls what to do in case a content-merge is done and a conflict is detected. The default setting for this should be false. In this case the working tree file is filled with new content (containing conflict markers) and the index is filled with multiple stages containing BASE, OURS and THEIRS content. Having such non-0 stages is the sign to git tools that there are still conflicts for that path.

        If true is specified the behavior is different. In case a conflict is detected the working tree file is again filled with new content (containing conflict markers). But also stage 0 of the index is filled with that content. No other stages are filled. Means: there is no conflict on that path but the new content (including conflict markers) is stored as successful merge result. This is needed in the context of RecursiveMerger where when determining merge bases we don't want to deal with content-merge conflicts.

        Returns:
        whether the trees merged cleanly
        Throws:
        IOException
        Since:
        3.5