import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
public static String getSubmoduleCommitId(Repository repository, String path, RevCommit commit) {
	String commitId = null;
	try (TreeWalk tw = new TreeWalk(repository)) {
		tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
		tw.reset(commit.getTree());
		while (tw.next()) {
			if (tw.isSubtree() && !path.equals(tw.getPathString())) {
				tw.enterSubtree();
				continue;
			}
			if (FileMode.GITLINK == tw.getFileMode(0)) {
				commitId = tw.getObjectId(0).getName();
				break;
			}
		}
	} catch (Throwable t) {
		error(t, repository, "{0} can't find {1} in commit {2}", path, commit.name());
	}
	return commitId;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
public static String getSubmoduleCommitId(Repository repository, String path, RevCommit commit) {
	String commitId = null;
	RevWalk rw = new RevWalk(repository);
	TreeWalk tw = new TreeWalk(repository);
	tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
	try {
		tw.reset(commit.getTree());
		while (tw.next()) {
			if (tw.isSubtree() && !path.equals(tw.getPathString())) {
				tw.enterSubtree();
				continue;
			}
			if (FileMode.GITLINK == tw.getFileMode(0)) {
				commitId = tw.getObjectId(0).getName();
				break;
			}
		}
	} catch (Throwable t) {
		error(t, repository, "{0} can't find {1} in commit {2}", path, commit.name());
	} finally {
		rw.dispose();
		tw.release();
	}
	return commitId;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
/**
 * Retrieves the raw byte content of a file in the specified tree.
 * 
 * @param repository
 * @param tree
 *            if null, the RevTree from HEAD is assumed.
 * @param path
 * @return content as a byte []
 */
public static byte[] getByteContent(Repository repository, RevTree tree, final String path, boolean throwError) {
	RevWalk rw = new RevWalk(repository);
	byte[] content = null;
	try (TreeWalk tw = new TreeWalk(repository)) {
		tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
		if (tree == null) {
			ObjectId object = getDefaultBranch(repository);
			if (object == null) {
				return null;
			}
			RevCommit commit = rw.parseCommit(object);
			tree = commit.getTree();
		}
		tw.reset(tree);
		while (tw.next()) {
			if (tw.isSubtree() && !path.equals(tw.getPathString())) {
				tw.enterSubtree();
				continue;
			}
			ObjectId entid = tw.getObjectId(0);
			FileMode entmode = tw.getFileMode(0);
			if (entmode != FileMode.GITLINK) {
				ObjectLoader ldr = repository.open(entid, Constants.OBJ_BLOB);
				content = ldr.getCachedBytes();
			}
		}
	} catch (Throwable t) {
		if (throwError) {
			error(t, repository, "{0} can't find {1} in tree {2}", path, tree.name());
		}
	} finally {
		rw.close();
		rw.dispose();
	}
	return content;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
@Override
protected void run () throws GitException {
    Repository repository = getRepository();
    TreeWalk walk = new TreeWalk(repository);
    try {
        walk.reset();
        walk.setRecursive(true);
        walk.addTree(Utils.findCommit(repository, revisionFirst).getTree());
        walk.addTree(Utils.findCommit(repository, revisionSecond).getTree());
        Collection<PathFilter> pathFilters = Utils.getPathFilters(repository.getWorkTree(), roots);
        if (pathFilters.isEmpty()) {
            walk.setFilter(AndTreeFilter.create(TreeFilter.ANY_DIFF, PathFilter.ANY_DIFF));
        } else {
            walk.setFilter(AndTreeFilter.create(new TreeFilter[] { 
                TreeFilter.ANY_DIFF,
                PathFilter.ANY_DIFF,
                PathFilterGroup.create(pathFilters)
            }));
        }
        List<GitRevisionInfo.GitFileInfo> infos = Utils.getDiffEntries(repository, walk, getClassFactory());
        for (GitRevisionInfo.GitFileInfo info : infos) {
            statuses.put(info.getFile(), info);
        }
    } catch (IOException ex) {
        throw new GitException(ex);
    } finally {
        walk.release();
    }
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
private void applyCriteria (RevWalk walk, SearchCriteria criteria,
        final RevFlag partOfResultFlag, DiffConfig diffConfig) {
    File[] files = criteria.getFiles();
    if (files.length > 0) {
        Collection<PathFilter> pathFilters = Utils.getPathFilters(getRepository().getWorkTree(), files);
        if (!pathFilters.isEmpty()) {
            if (criteria.isFollow() && pathFilters.size() == 1) {
                walk.setTreeFilter(FollowFilter.create(pathFilters.iterator().next().getPath(), diffConfig));
            } else {
                walk.setTreeFilter(AndTreeFilter.create(TreeFilter.ANY_DIFF, PathFilterGroup.create(pathFilters)));
            }
        }
    }
    RevFilter filter;
    if (criteria.isIncludeMerges()) {
        filter = RevFilter.ALL;
    } else {
        filter = RevFilter.NO_MERGES;
    }
    filter = AndRevFilter.create(filter, new CancelRevFilter(monitor));
    filter = AndRevFilter.create(filter, new RevFilter() {

        @Override
        public boolean include (RevWalk walker, RevCommit cmit) {
            return cmit.has(partOfResultFlag);
        }

        @Override
        public RevFilter clone () {
            return this;
        }

        @Override
        public boolean requiresCommitBody () {
            return false;
        }            
        
    });
    
    String username = criteria.getUsername();
    if (username != null && !(username = username.trim()).isEmpty()) {
        filter = AndRevFilter.create(filter, OrRevFilter.create(CommitterRevFilter.create(username), AuthorRevFilter.create(username)));
    }
    String message = criteria.getMessage();
    if (message != null && !(message = message.trim()).isEmpty()) {
        filter = AndRevFilter.create(filter, MessageRevFilter.create(message));
    }
    Date from  = criteria.getFrom();
    Date to  = criteria.getTo();
    if (from != null && to != null) {
        filter = AndRevFilter.create(filter, CommitTimeRevFilter.between(from, to));
    } else if (from != null) {
        filter = AndRevFilter.create(filter, CommitTimeRevFilter.after(from));
    } else if (to != null) {
        filter = AndRevFilter.create(filter, CommitTimeRevFilter.before(to));
    }
    // this must be at the end, limit filter must apply as the last
    if (criteria.getLimit() != -1) {
        filter = AndRevFilter.create(filter, MaxCountRevFilter.create(criteria.getLimit()));
    }
    walk.setRevFilter(filter);
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
public void checkout () throws IOException, GitException {
    TreeWalk treeWalk = new TreeWalk(repository);
    Collection<String> relativePaths = Utils.getRelativePaths(repository.getWorkTree(), roots);
    if (!relativePaths.isEmpty()) {
        treeWalk.setFilter(PathFilterGroup.createFromStrings(relativePaths));
    }
    treeWalk.setRecursive(true);
    treeWalk.reset();
    treeWalk.addTree(new DirCacheIterator(cache));
    treeWalk.addTree(new FileTreeIterator(repository));
    String lastAddedPath = null;
    ObjectReader od = repository.newObjectReader();
    try {
    while (treeWalk.next() && !monitor.isCanceled()) {
        File path = new File(repository.getWorkTree(), treeWalk.getPathString());
        if (treeWalk.getPathString().equals(lastAddedPath)) {
            // skip conflicts
            continue;
        } else {
            lastAddedPath = treeWalk.getPathString();
        }
        DirCacheIterator dit = treeWalk.getTree(0, DirCacheIterator.class);
        FileTreeIterator fit = treeWalk.getTree(1, FileTreeIterator.class);
        if (dit != null && (recursively || directChild(roots, repository.getWorkTree(), path)) && (fit == null || fit.isModified(dit.getDirCacheEntry(), checkContent, od))) {
            // update entry
            listener.notifyFile(path, treeWalk.getPathString());
            checkoutEntry(repository, path, dit.getDirCacheEntry(), od);
        }
    }
    } finally {
        od.release();
        treeWalk.release();
    }
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
public boolean isTracked(String path) throws IOException {
    ObjectId objectId = localRepo.resolve(Constants.HEAD);
    RevTree tree;
    RevWalk walk = null;
    if (objectId != null) {
      walk = new RevWalk(localRepo);
      tree = walk.parseTree(objectId);
    }
    else {
      tree = null;
    }

    try (TreeWalk treeWalk = new TreeWalk(localRepo)) {
        treeWalk.setRecursive(true);
        if (tree != null)
          treeWalk.addTree(tree);
        else
          treeWalk.addTree(new EmptyTreeIterator());

        treeWalk.addTree(new DirCacheIterator(localRepo.readDirCache()));
        treeWalk.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
        return treeWalk.next();
    }
    finally {
        if (walk != null)
            walk.close();
    }
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
@Nullable
private static Config getBaseConfig(@NotNull Repository repository, @NotNull String configFileName) throws IOException, ConfigInvalidException {
	final Config baseConfig;
	if (repository.isBare()) {
		// read bugtraq config directly from the repository
		String content = null;
		RevWalk rw = new RevWalk(repository);
		try (TreeWalk tw = new TreeWalk(repository)) {
			tw.setFilter(PathFilterGroup.createFromStrings(configFileName));
			Ref head = repository.getRef(Constants.HEAD);
			if (head == null) {
				return null;
			}
			head = head.getTarget();
			if (head == null) {
				return null;
			}
			ObjectId headId = head.getObjectId();
			if (headId == null) {
				return null;
			}
			RevCommit commit = rw.parseCommit(headId);
			RevTree tree = commit.getTree();
			tw.reset(tree);
			while (tw.next()) {
				ObjectId entid = tw.getObjectId(0);
				FileMode entmode = tw.getFileMode(0);
				if (FileMode.REGULAR_FILE == entmode) {
					ObjectLoader ldr = repository.open(entid, Constants.OBJ_BLOB);
					content = new String(ldr.getCachedBytes(), commit.getEncoding());
					break;
				}
			}
		} finally {
			rw.close();
			rw.dispose();
		}

		if (content == null) {
			// config not found
			baseConfig = null;
		} else {
			// parse the config
			Config config = new Config();
			config.fromText(content);
			baseConfig = config;
		}
	} else {
		// read bugtraq config from work tree
		final File baseFile = new File(repository.getWorkTree(), configFileName);
		if (baseFile.isFile()) {
			FileBasedConfig fileConfig = new FileBasedConfig(baseFile, repository.getFS());
			fileConfig.load();
			baseConfig = fileConfig;
		} else {
			baseConfig = null;
		}
	}
	return baseConfig;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
/**
 * Retrieves the raw byte content of a file in the specified tree.
 * 
 * @param repository
 * @param tree
 *            if null, the RevTree from HEAD is assumed.
 * @param path
 * @return content as a byte []
 */
public static byte[] getByteContent(Repository repository, RevTree tree, final String path, boolean throwError) {
	RevWalk rw = new RevWalk(repository);
	TreeWalk tw = new TreeWalk(repository);
	tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
	byte[] content = null;
	try {
		if (tree == null) {
			ObjectId object = getDefaultBranch(repository);
			RevCommit commit = rw.parseCommit(object);
			tree = commit.getTree();
		}
		tw.reset(tree);
		while (tw.next()) {
			if (tw.isSubtree() && !path.equals(tw.getPathString())) {
				tw.enterSubtree();
				continue;
			}
			ObjectId entid = tw.getObjectId(0);
			FileMode entmode = tw.getFileMode(0);
			if (entmode != FileMode.GITLINK) {
				RevObject ro = rw.lookupAny(entid, entmode.getObjectType());
				rw.parseBody(ro);
				ByteArrayOutputStream os = new ByteArrayOutputStream();
				ObjectLoader ldr = repository.open(ro.getId(), Constants.OBJ_BLOB);
				byte[] tmp = new byte[4096];
				InputStream in = ldr.openStream();
				int n;
				while ((n = in.read(tmp)) > 0) {
					os.write(tmp, 0, n);
				}
				in.close();
				content = os.toByteArray();
			}
		}
	} catch (Throwable t) {
		if (throwError) {
			error(t, repository, "{0} can't find {1} in tree {2}", path, tree.name());
		}
	} finally {
		rw.dispose();
		tw.release();
	}
	return content;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
@Override
  protected void run() throws GitException {
      Repository repository = getRepository();
      DiffFormatter formatter = new DiffFormatter(out);
      formatter.setRepository(repository);
      ObjectReader or = null;
      String workTreePath = repository.getWorkTree().getAbsolutePath();
      try {
          Collection<PathFilter> pathFilters = Utils.getPathFilters(repository.getWorkTree(), roots);
          if (!pathFilters.isEmpty()) {
              formatter.setPathFilter(PathFilterGroup.create(pathFilters));
          }
          if (repository.getConfig().get(WorkingTreeOptions.KEY).getAutoCRLF() != CoreConfig.AutoCRLF.FALSE) {
              // work-around for autocrlf
              formatter.setDiffComparator(new AutoCRLFComparator());
          }
          or = repository.newObjectReader();
          AbstractTreeIterator firstTree = getIterator(firstCommit, or);
          AbstractTreeIterator secondTree = getIterator(secondCommit, or);
          List<DiffEntry> diffEntries;
          if (secondTree instanceof WorkingTreeIterator) {
              // remote when fixed in JGit, see ExportDiffTest.testDiffRenameDetectionProblem
              formatter.setDetectRenames(false);
              diffEntries = formatter.scan(firstTree, secondTree);
              formatter.setDetectRenames(true);
              RenameDetector detector = formatter.getRenameDetector();
              detector.reset();
              detector.addAll(diffEntries);
diffEntries = detector.compute(new ContentSource.Pair(ContentSource.create(or), ContentSource.create((WorkingTreeIterator) secondTree)), NullProgressMonitor.INSTANCE);
          } else {
              formatter.setDetectRenames(true);
              diffEntries = formatter.scan(firstTree, secondTree);
          }
          for (DiffEntry ent : diffEntries) {
              if (monitor.isCanceled()) {
                  break;
              }
              listener.notifyFile(new File(workTreePath + File.separator + ent.getNewPath()), ent.getNewPath());
              formatter.format(ent);
          }
          formatter.flush();
      } catch (IOException ex) {
          throw new GitException(ex);
      } finally {
          if (or != null) {
              or.release();
          }
          formatter.release();
      }
  }
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
private void mergeConflicts (List<String> conflicts, DirCache cache) throws GitException {
    DirCacheBuilder builder = cache.builder();
    DirCacheBuildIterator dci = new DirCacheBuildIterator(builder);
    TreeWalk walk = new TreeWalk(getRepository());
    ObjectDatabase od = null;
    DiffAlgorithm.SupportedAlgorithm diffAlg = getRepository().getConfig().getEnum(
                    ConfigConstants.CONFIG_DIFF_SECTION, null,
                    ConfigConstants.CONFIG_KEY_ALGORITHM,
                    DiffAlgorithm.SupportedAlgorithm.HISTOGRAM);
    MergeAlgorithm merger = new MergeAlgorithm(DiffAlgorithm.getAlgorithm(diffAlg));
    try {
        od = getRepository().getObjectDatabase();
        walk.addTree(dci);
        walk.setFilter(PathFilterGroup.create(Utils.getPathFilters(conflicts)));
        String lastPath = null;
        DirCacheEntry[] entries = new DirCacheEntry[3];
        walk.setRecursive(true);
        while (walk.next()) {
            DirCacheEntry e = walk.getTree(0, DirCacheIterator.class).getDirCacheEntry();
            String path = e.getPathString();
            if (lastPath != null && !lastPath.equals(path)) {
                resolveEntries(merger, lastPath, entries, od, builder);
            }
            if (e.getStage() == 0) {
                DirCacheIterator c = walk.getTree(0, DirCacheIterator.class);
                builder.add(c.getDirCacheEntry());
            } else {
                entries[e.getStage() - 1] = e;
                lastPath = path;
            }
        }
        resolveEntries(merger, lastPath, entries, od, builder);
        builder.commit();
    } catch (IOException ex) {
        throw new GitException(ex);
    } finally {
        walk.release();
        if (od != null) {
            od.close();
        }
    }
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
public void testAddMixedLineEndings () throws Exception {
    File f = new File(workDir, "f");
    String content = "";
    for (int i = 0; i < 10000; ++i) {
        content += i + "\r\n";
    }
    write(f, content);
    File[] files = new File[] { f };
    GitClient client = getClient(workDir);
    client.add(files, NULL_PROGRESS_MONITOR);
    client.commit(files, "commit", null, null, NULL_PROGRESS_MONITOR);
    
    Map<File, GitStatus> statuses = client.getStatus(files, NULL_PROGRESS_MONITOR);
    assertEquals(1, statuses.size());
    assertStatus(statuses, workDir, f, true, Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, false);
    
    // lets turn autocrlf on
    StoredConfig cfg = repository.getConfig();
    cfg.setString(ConfigConstants.CONFIG_CORE_SECTION, null, ConfigConstants.CONFIG_KEY_AUTOCRLF, "true");
    cfg.save();
    
    // when this starts failing, remove the work around
    ObjectInserter inserter = repository.newObjectInserter();
    TreeWalk treeWalk = new TreeWalk(repository);
    treeWalk.setFilter(PathFilterGroup.createFromStrings("f"));
    treeWalk.setRecursive(true);
    treeWalk.reset();
    treeWalk.addTree(new FileTreeIterator(repository));
    while (treeWalk.next()) {
        String path = treeWalk.getPathString();
        assertEquals("f", path);
        WorkingTreeIterator fit = treeWalk.getTree(0, WorkingTreeIterator.class);
        InputStream in = fit.openEntryStream();
        try {
            inserter.insert(Constants.OBJ_BLOB, fit.getEntryLength(), in);
            fail("this should fail, remove the work around");
        } catch (EOFException ex) {
            assertEquals("Input did not match supplied length. 10000 bytes are missing.", ex.getMessage());
        } finally {
            in.close();
            inserter.release();
        }
        break;
    }
    
    // no err should occur
    write(f, content + "hello");
    statuses = client.getStatus(files, NULL_PROGRESS_MONITOR);
    assertEquals(1, statuses.size());
    assertStatus(statuses, workDir, f, true, Status.STATUS_NORMAL, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, false);
    client.add(files, NULL_PROGRESS_MONITOR);
    statuses = client.getStatus(files, NULL_PROGRESS_MONITOR);
    assertEquals(1, statuses.size());
    assertStatus(statuses, workDir, f, true, Status.STATUS_MODIFIED, Status.STATUS_NORMAL, Status.STATUS_MODIFIED, false);
    client.commit(files, "message", null, null, NULL_PROGRESS_MONITOR);
    statuses = client.getStatus(files, NULL_PROGRESS_MONITOR);
    assertEquals(1, statuses.size());
    assertStatus(statuses, workDir, f, true, Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, false);
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
@Nonnull
public static List<RevCommit> getFileRevisions(String path, AnyObjectId start, int skip, int limit, ObjectReader reader) throws IOException {
  path = normalizeNodePath(path);
  TreeFilter filter = AndTreeFilter.create(PathFilterGroup.createFromStrings(path), ANY_DIFF);
  return getHistory(start, skip, limit, filter, reader);
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
private List<DiffCommitFile> getCommitDiffFiles(RevCommit revCommit, String pattern)
    throws IOException {
  List<DiffEntry> diffs;
  TreeFilter filter = null;
  if (!isNullOrEmpty(pattern)) {
    filter =
        AndTreeFilter.create(
            PathFilterGroup.createFromStrings(Collections.singleton(pattern)),
            TreeFilter.ANY_DIFF);
  }
  List<DiffCommitFile> commitFilesList = new ArrayList<>();
  try (TreeWalk tw = new TreeWalk(repository)) {
    tw.setRecursive(true);
    // get the current commit parent in order to compare it with the current commit
    // and to get the list of DiffEntry.
    if (revCommit.getParentCount() > 0) {
      RevCommit parent = parseCommit(revCommit.getParent(0));
      tw.reset(parent.getTree(), revCommit.getTree());
      if (filter != null) {
        tw.setFilter(filter);
      } else {
        tw.setFilter(TreeFilter.ANY_DIFF);
      }
      diffs = DiffEntry.scan(tw);
    } else {
      // If the current commit has no parents (which means it is the initial commit),
      // then create an empty tree and compare it to the current commit to get the
      // list of DiffEntry.
      try (RevWalk rw = new RevWalk(repository);
          DiffFormatter diffFormat = new DiffFormatter(NullOutputStream.INSTANCE)) {
        diffFormat.setRepository(repository);
        if (filter != null) {
          diffFormat.setPathFilter(filter);
        }
        diffs =
            diffFormat.scan(
                new EmptyTreeIterator(),
                new CanonicalTreeParser(null, rw.getObjectReader(), revCommit.getTree()));
      }
    }
  }
  if (diffs != null) {
    commitFilesList.addAll(
        diffs
            .stream()
            .map(
                diff ->
                    newDto(DiffCommitFile.class)
                        .withOldPath(diff.getOldPath())
                        .withNewPath(diff.getNewPath())
                        .withChangeType(diff.getChangeType().name()))
            .collect(toList()));
  }
  return commitFilesList;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
@Override
public final void writeTo(OutputStream out) throws IOException {
  DiffFormatter formatter = new DiffFormatter(new BufferedOutputStream(out));
  formatter.setRepository(repository);
  List<String> rawFileFilter = params.getFileFilter();
  TreeFilter pathFilter =
      (rawFileFilter != null && rawFileFilter.size() > 0)
          ? PathFilterGroup.createFromStrings(rawFileFilter)
          : TreeFilter.ALL;
  formatter.setPathFilter(AndTreeFilter.create(TreeFilter.ANY_DIFF, pathFilter));

  try {
    String commitA = params.getCommitA();
    String commitB = params.getCommitB();
    boolean cached = params.isCached();

    List<DiffEntry> diff;
    if (commitA == null && commitB == null && !cached) {
      diff = indexToWorkingTree(formatter);
    } else if (commitA != null && commitB == null && !cached) {
      diff = commitToWorkingTree(commitA, formatter);
    } else if (commitA == null && commitB != null) {
      diff = emptyToCommit(commitB, formatter);
    } else if (commitB == null) {
      diff = commitToIndex(commitA, formatter);
    } else {
      diff = commitToCommit(commitA, commitB, formatter);
    }

    DiffType type = params.getType();
    if (type == DiffType.NAME_ONLY) {
      writeNames(diff, out);
    } else if (type == DiffType.NAME_STATUS) {
      writeNamesAndStatus(diff, out);
    } else {
      writeRawDiff(diff, formatter);
    }
  } catch (GitException e) {
    LOG.error(e.getMessage());
  } finally {
    formatter.close();
    repository.close();
  }
}
 

import org.eclipse.jgit.treewalk.filter.PathFilterGroup; //导入依赖的package包/类
private List<String> copy(
    Set<String> paths, PatchSet.Id old, RevisionResource resource, Account.Id userId)
    throws IOException, PatchListNotAvailableException, OrmException {
  Project.NameKey project = resource.getChange().getProject();
  try (Repository git = gitManager.openRepository(project);
      ObjectReader reader = git.newObjectReader();
      RevWalk rw = new RevWalk(reader);
      TreeWalk tw = new TreeWalk(reader)) {
    Change change = resource.getChange();
    PatchSet patchSet = psUtil.get(db.get(), resource.getNotes(), old);
    if (patchSet == null) {
      throw new PatchListNotAvailableException(
          String.format(
              "patch set %s of change %s not found", old.get(), change.getId().get()));
    }

    PatchList oldList = patchListCache.get(change, patchSet);

    PatchList curList = patchListCache.get(change, resource.getPatchSet());

    int sz = paths.size();
    List<String> pathList = Lists.newArrayListWithCapacity(sz);

    tw.setFilter(PathFilterGroup.createFromStrings(paths));
    tw.setRecursive(true);
    int o = tw.addTree(rw.parseCommit(oldList.getNewId()).getTree());
    int c = tw.addTree(rw.parseCommit(curList.getNewId()).getTree());

    int op = -1;
    if (oldList.getOldId() != null) {
      op = tw.addTree(rw.parseTree(oldList.getOldId()));
    }

    int cp = -1;
    if (curList.getOldId() != null) {
      cp = tw.addTree(rw.parseTree(curList.getOldId()));
    }

    while (tw.next()) {
      String path = tw.getPathString();
      if (tw.getRawMode(o) != 0
          && tw.getRawMode(c) != 0
          && tw.idEqual(o, c)
          && paths.contains(path)) {
        // File exists in previously reviewed oldList and in curList.
        // File content is identical.
        pathList.add(path);
      } else if (op >= 0
          && cp >= 0
          && tw.getRawMode(o) == 0
          && tw.getRawMode(c) == 0
          && tw.getRawMode(op) != 0
          && tw.getRawMode(cp) != 0
          && tw.idEqual(op, cp)
          && paths.contains(path)) {
        // File was deleted in previously reviewed oldList and curList.
        // File exists in ancestor of oldList and curList.
        // File content is identical in ancestors.
        pathList.add(path);
      }
    }
    accountPatchReviewStore
        .get()
        .markReviewed(resource.getPatchSet().getId(), userId, pathList);
    return pathList;
  }
}