ReverseWalk.java

/*
 * Copyright (C) 2011, Google Inc. and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0 which is available at
 * https://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package org.eclipse.jgit.blame;

import java.io.IOException;

import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;

final class ReverseWalk extends RevWalk {
    ReverseWalk(Repository repo) {
        super(repo);
    }

    /** {@inheritDoc} */
    @Override
    public ReverseCommit next() throws MissingObjectException,
            IncorrectObjectTypeException, IOException {
        ReverseCommit c = (ReverseCommit) super.next();
        if (c == null)
            return null;
        for (int pIdx = 0; pIdx < c.getParentCount(); pIdx++)
            ((ReverseCommit) c.getParent(pIdx)).addChild(c);
        return c;
    }

    /** {@inheritDoc} */
    @Override
    protected RevCommit createCommit(AnyObjectId id) {
        return new ReverseCommit(id);
    }

    static final class ReverseCommit extends RevCommit {
        private static final ReverseCommit[] NO_CHILDREN = {};

        private ReverseCommit[] children = NO_CHILDREN;

        ReverseCommit(AnyObjectId id) {
            super(id);
        }

        void addChild(ReverseCommit c) {
            // Always put the most recent child onto the front of the list.
            // This works correctly because our ReverseWalk parent (above)
            // runs in COMMIT_TIME_DESC order. Older commits will be popped
            // later and should go in front of the children list so they are
            // visited first by BlameGenerator when considering candidates.

            int cnt = children.length;
            switch (cnt) {
            case 0:
                children = new ReverseCommit[] { c };
                break;
            case 1:
                children = new ReverseCommit[] { c, children[0] };
                break;
            default:
                ReverseCommit[] n = new ReverseCommit[1 + cnt];
                n[0] = c;
                System.arraycopy(children, 0, n, 1, cnt);
                children = n;
                break;
            }
        }

        int getChildCount() {
            return children.length;
        }

        ReverseCommit getChild(int nth) {
            return children[nth];
        }
    }
}