Java NullOutputStream.INSTANCE属性代码示例

private void fillLastModifiedCommits(ObjectId start, String basePath) throws IOException, GitAPIException {
    Map<String, ObjectId> objects = lastModifiedCommits.get(start);
    if (objects == null) {
        objects = new TreeMap<>();
    }
    DiffFormatter diffFmt = new DiffFormatter(NullOutputStream.INSTANCE);
    diffFmt.setRepository(getGitRepository());
    LogCommand log = new Git(getGitRepository()).log();
    if (!basePath.isEmpty()) {
        log.addPath(basePath);
    }
    for(RevCommit c: log.call()) {
        final RevTree a = c.getParentCount() > 0 ? c.getParent(0).getTree() : null;
        final RevTree b = c.getTree();

        for(DiffEntry diff: diffFmt.scan(a, b)) {
            objects.put(diff.getNewPath(), c.getId());
        }
    }
    lastModifiedCommits.put(start, objects);
}
 

private Map<String, Change<?>> blockingPreviewDiff(Revision baseRevision, Iterable<Change<?>> changes) {
    requireNonNull(baseRevision, "baseRevision");
    requireNonNull(changes, "changes");
    baseRevision = blockingNormalize(baseRevision);

    try (ObjectReader reader = jGitRepository.newObjectReader();
         RevWalk revWalk = new RevWalk(reader);
         DiffFormatter diffFormatter = new DiffFormatter(NullOutputStream.INSTANCE)) {

        final ObjectId baseTreeId = toTreeId(revWalk, baseRevision);
        final DirCache dirCache = DirCache.newInCore();
        final int numEdits = applyChanges(baseRevision, baseTreeId, dirCache, changes);
        if (numEdits == 0) {
            return Collections.emptyMap();
        }

        CanonicalTreeParser p = new CanonicalTreeParser();
        p.reset(reader, baseTreeId);
        diffFormatter.setRepository(jGitRepository);
        List<DiffEntry> result = diffFormatter.scan(p, new DirCacheIterator(dirCache));
        return toChangeMap(result);
    } catch (IOException e) {
        throw new StorageException("failed to perform a dry-run diff", e);
    }
}
 

/**
 * Compares the old tree and the new tree to get the list of the affected files.
 */
private List<DiffEntry> compareTrees(ObjectId prevTreeId, ObjectId nextTreeId, TreeFilter filter) {
    try (DiffFormatter diffFormatter = new DiffFormatter(NullOutputStream.INSTANCE)) {
        diffFormatter.setRepository(jGitRepository);
        diffFormatter.setPathFilter(filter);

        return diffFormatter.scan(prevTreeId, nextTreeId);
    } catch (IOException e) {
        throw new StorageException("failed to compare two trees: " + prevTreeId + " vs. " + nextTreeId, e);
    }
}
 

public static List<DiffEntry> diff(Repository repository, AnyObjectId oldRevId, AnyObjectId newRevId) {
	List<DiffEntry> diffs = new ArrayList<>();
	try (	DiffFormatter diffFormatter = new DiffFormatter(NullOutputStream.INSTANCE);
			RevWalk revWalk = new RevWalk(repository);
			ObjectReader reader = repository.newObjectReader();) {
    	diffFormatter.setRepository(repository);
    	diffFormatter.setDetectRenames(true);
    	diffFormatter.setDiffComparator(RawTextComparator.DEFAULT);
    	
    	CanonicalTreeParser oldTreeParser = new CanonicalTreeParser();
    	if (!oldRevId.equals(ObjectId.zeroId()))
    		oldTreeParser.reset(reader, revWalk.parseCommit(oldRevId).getTree());
    	
    	CanonicalTreeParser newTreeParser = new CanonicalTreeParser();
    	if (!newRevId.equals(ObjectId.zeroId()))
    		newTreeParser.reset(reader, revWalk.parseCommit(newRevId).getTree());
    	
    	for (DiffEntry entry: diffFormatter.scan(oldTreeParser, newTreeParser)) {
    		if (!Objects.equal(entry.getOldPath(), entry.getNewPath())
    				|| !Objects.equal(entry.getOldMode(), entry.getNewMode())
    				|| entry.getOldId()==null || !entry.getOldId().isComplete()
    				|| entry.getNewId()== null || !entry.getNewId().isComplete()
    				|| !entry.getOldId().equals(entry.getNewId())) {
    			diffs.add(entry);
    		}
    	}
	} catch (IOException e) {
		throw new RuntimeException(e);
	}			
	return diffs;
}
 

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;
}