import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
/**
 * Helper method that returns commits between the given old branch heads and new branch heads
 *
 * @param oldBranches previous locations of branch heads
 * @param newBranches current locations of branch heads
 * @return a list of all commits found between oldBranches and newBranches
 * @throws GitAPIException
 * @throws IOException
 */
private List<CommitHelper> getNewCommits(Map<String, BranchHelper> oldBranches, List<? extends BranchHelper> newBranches) throws GitAPIException, IOException {
    List<ObjectId> startPoints = new ArrayList<>();
    List<ObjectId> stopPoints = new ArrayList<>();

    for (BranchHelper newBranch : newBranches) {
        if (oldBranches.containsKey(newBranch.getRefName())) {
            ObjectId newBranchHeadID = newBranch.getHeadId();
            ObjectId oldBranchHeadID = oldBranches.get(newBranch.getRefName()).getHeadId();
            if (!newBranchHeadID.equals(oldBranchHeadID)) {
                startPoints.add(newBranchHeadID);
            }
            stopPoints.add(oldBranchHeadID);
        } else {
            startPoints.add(newBranch.getHeadId());
        }
    }
    PlotCommitList<PlotLane> newCommits = this.parseRawCommits(startPoints, stopPoints);
    return wrapRawCommits(newCommits);
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
/**
 * Utilizes JGit to walk through the repo and create raw commit objects - more
 * specifically, JGit objects of (super)type RevCommit. This is an expensive
 * operation and should only be called when necessary
 *
 * @return a list of raw local commits
 * @throws IOException
 */
private PlotCommitList<PlotLane> parseAllRawLocalCommits() throws IOException, GitAPIException {
    ObjectId headId = repo.resolve("HEAD");
    if (headId == null) return new PlotCommitList<>();
    List<ObjectId> examinedCommitIDs = new ArrayList<>();
    PlotCommitList<PlotLane> rawLocalCommits = parseRawCommits(headId, examinedCommitIDs);
    examinedCommitIDs.add(headId);

    List<LocalBranchHelper> branches = this.branchModel.getLocalBranchesTyped();
    for (BranchHelper branch : branches) {
        ObjectId branchId = branch.getHeadId();
        PlotCommitList<PlotLane> toAdd = parseRawCommits(branchId, examinedCommitIDs);
        if (toAdd.size() > 0) {
            rawLocalCommits.addAll(toAdd);
            examinedCommitIDs.add(toAdd.get(0).getId());
        }
    }
    return rawLocalCommits;
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
/**
 * Utilizes JGit to walk through the repo and create raw commit objects - more
 * specifically, JGit objects of (super)type RevCommit. This is an expensive
 * operation and should only be called when necessary
 *
 * @param startPoints the starting ids to parse from
 * @param stopPoints  the ids at which parsing should stop
 * @return a list of raw commits starting from each id in startPoints, excluding those beyond each id in stopPoints
 * @throws IOException
 */
private PlotCommitList<PlotLane> parseRawCommits(List<ObjectId> startPoints, List<ObjectId> stopPoints) throws IOException {
    PlotCommitList<PlotLane> plotCommitList = new PlotCommitList<>();

    PlotWalk w = new PlotWalk(repo);
    for (ObjectId stopId : stopPoints) {
        w.markUninteresting(w.parseCommit(stopId));
    }

    for (ObjectId startId : startPoints) {
        w.markStart(w.parseCommit(startId));

        PlotCommitList<PlotLane> temp = new PlotCommitList<>();
        temp.source(w);
        temp.fillTo(Integer.MAX_VALUE);

        plotCommitList.addAll(temp);
    }

    w.dispose();

    return plotCommitList;
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    try (Repository repository = CookbookHelper.openJGitCookbookRepository()) {
        try (PlotWalk revWalk = new PlotWalk(repository)) {
            ObjectId rootId = repository.resolve("refs/heads/master");
            RevCommit root = revWalk.parseCommit(rootId);
            revWalk.markStart(root);
            PlotCommitList<PlotLane> plotCommitList = new PlotCommitList<>();
            plotCommitList.source(revWalk);
            plotCommitList.fillTo(Integer.MAX_VALUE);

            System.out.println("Printing children of commit " + root);
            for (RevCommit com : revWalk) {
                System.out.println("Child: " + com);
            }

            System.out.println("Printing with next()");
            System.out.println("next: " + revWalk.next());
        }
    }
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
public PlotCommitList<PlotLane> getCommitsByTree(final String treeName) throws Exception {
    try (PlotWalk revWalk = new PlotWalk(repository)) {
        final ObjectId rootId = repository.resolve(treeName);
        final RevCommit root = revWalk.parseCommit(rootId);
        revWalk.markStart(root);

        final PlotCommitList<PlotLane> plotCommitList = new PlotCommitList<>();
        plotCommitList.source(revWalk);
        plotCommitList.fillTo(Integer.MAX_VALUE);
        revWalk.dispose();
        return plotCommitList;
    }
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
/**
 * Utilizes JGit to walk through the repo and create raw commit objects - more
 * specifically, JGit objects of (super)type RevCommit. This is an expensive
 * operation and should only be called when necessary
 *
 * @return a list of raw remote commits
 * @throws IOException
 */
private PlotCommitList<PlotLane> parseAllRawRemoteCommits() throws IOException, GitAPIException {
    List<ObjectId> examinedCommitIDs = new ArrayList<>();
    PlotCommitList<PlotLane> rawRemoteCommits = new PlotCommitList<>();

    for (BranchHelper branch : this.branchModel.getRemoteBranchesTyped()) {
        ObjectId branchId = branch.getHeadId();
        PlotCommitList<PlotLane> toAdd = parseRawCommits(branchId, examinedCommitIDs);
        if (toAdd.size() > 0) {
            rawRemoteCommits.addAll(toAdd);
            examinedCommitIDs.add(toAdd.get(0).getId());
        }
    }
    return rawRemoteCommits;
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
private PlotWalk generatePlotWalk() throws IOException {
    Stopwatch stopwatch = new Stopwatch().start();
    PlotWalk revWalk = new PlotWalk(repo());
    logStartProvider.markStartsOn(revWalk);

    PlotCommitList<PlotLane> plotCommitList = new PlotCommitList<PlotLane>();
    plotCommitList.source(revWalk);
    plotCommitList.fillTo(Integer.MAX_VALUE);
    Log.d(TAG, "generatePlotWalk duration" + stopwatch.stop());
    return revWalk;
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
public GitPlotRenderer(PlotCommitList<PlotLane> commitList) {
    // Plot to create
    plot = new GPlot();
    // List of commit IDs
    commits = new ArrayList<>();
    // Loops over the commits
    rowIndex = 0;
    for (PlotCommit<PlotLane> commit : commitList) {
        commits.add(commit);
        currentCommit = commit;
        paintCommit(commit, rowHeight);
        rowIndex++;
    }
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
@Override
public GitLog graph(String from, String to) {
    try {
        GitRange range = range(from, to, false);
        PlotWalk walk = new PlotWalk(git.getRepository());

        // Log
        walk.markStart(walk.lookupCommit(range.getFrom().getId()));
        walk.markUninteresting(walk.lookupCommit(range.getTo().getId()));
        PlotCommitList<PlotLane> commitList = new PlotCommitList<>();
        commitList.source(walk);
        commitList.fillTo(Integer.MAX_VALUE);

        // Rendering
        GitPlotRenderer renderer = new GitPlotRenderer(commitList);
        GPlot plot = renderer.getPlot();

        // Gets the commits
        List<GitCommit> commits = Lists.transform(
                renderer.getCommits(),
                this::toCommit
        );

        // OK
        return new GitLog(
                plot,
                commits
        );

    } catch (IOException e) {
        throw new GitRepositoryIOException(repository.getRemote(), e);
    }
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
private int calculateLineColumnWidth(PlotCommitList<PlotLane> plotCommits) {
    return 36 + 12 * plotCommits.stream().mapToInt(p -> p.getLane().getPosition()).max().orElse(0);
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
/**
 * Constructs a list of all local commits found by parsing the repository for raw RevCommit objects,
 * then wrapping them into a CommitHelper with the appropriate parents and children
 *
 * @return a list of CommitHelpers for all local commits
 * @throws IOException
 */
private List<CommitHelper> parseAllLocalCommits() throws IOException, GitAPIException {
    PlotCommitList<PlotLane> commitList = this.parseAllRawLocalCommits();
    return wrapRawCommits(commitList);
}
 

import org.eclipse.jgit.revplot.PlotCommitList; //导入依赖的package包/类
/**
 * Constructs a list of all remote commits found by parsing the repository for raw RevCommit objects,
 * then wrapping them into a CommitHelper with the appropriate parents and children
 *
 * @return a list of CommitHelpers for all remote commits
 * @throws IOException
 */
private List<CommitHelper> parseAllRemoteCommits() throws IOException, GitAPIException {
    PlotCommitList<PlotLane> commitList = this.parseAllRawRemoteCommits();
    return wrapRawCommits(commitList);
}