NoteParser.java

/*
 * Copyright (C) 2010, 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.notes;

import static org.eclipse.jgit.lib.Constants.OBJECT_ID_STRING_LENGTH;
import static org.eclipse.jgit.lib.Constants.encodeASCII;
import static org.eclipse.jgit.lib.FileMode.TREE;
import static org.eclipse.jgit.util.RawParseUtils.parseHexInt4;

import java.io.IOException;

import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.lib.AbbreviatedObjectId;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.MutableObjectId;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;

/** Custom tree parser to select note bucket type and load it. */
final class NoteParser extends CanonicalTreeParser {
    /**
     * Parse a tree object into a {@link NoteBucket} instance.
     *
     * The type of note tree is automatically detected by examining the items
     * within the tree, and allocating the proper storage type based on the
     * first note-like entry encountered. Since the method parses by guessing
     * the type on the first element, malformed note trees can be read as the
     * wrong type of tree.
     *
     * This method is not recursive, it parses the one tree given to it and
     * returns the bucket. If there are subtrees for note storage, they are
     * setup as lazy pointers that will be resolved at a later time.
     *
     * @param prefix
     *            common hex digits that all notes within this tree share. The
     *            root tree has {@code prefix.length() == 0}, the first-level
     *            subtrees should be {@code prefix.length()==2}, etc.
     * @param treeId
     *            the tree to read from the repository.
     * @param reader
     *            reader to access the tree object.
     * @return bucket to holding the notes of the specified tree.
     * @throws IOException
     *             {@code treeId} cannot be accessed.
     */
    static InMemoryNoteBucket parse(AbbreviatedObjectId prefix,
            final ObjectId treeId, final ObjectReader reader)
            throws IOException {
        return new NoteParser(prefix, reader, treeId).parse();
    }

    private final int prefixLen;

    private final int pathPadding;

    private NonNoteEntry firstNonNote;

    private NonNoteEntry lastNonNote;

    private NoteParser(AbbreviatedObjectId prefix, ObjectReader r, ObjectId t)
            throws IncorrectObjectTypeException, IOException {
        super(encodeASCII(prefix.name()), r, t);
        prefixLen = prefix.length();

        // Our path buffer has a '/' that we don't want after the prefix.
        // Drop it by shifting the path down one position.
        pathPadding = 0 < prefixLen ? 1 : 0;
        if (0 < pathPadding)
            System.arraycopy(path, 0, path, pathPadding, prefixLen);
    }

    private InMemoryNoteBucket parse() {
        InMemoryNoteBucket r = parseTree();
        r.nonNotes = firstNonNote;
        return r;
    }

    private InMemoryNoteBucket parseTree() {
        for (; !eof(); next(1)) {
            if (pathLen == pathPadding + OBJECT_ID_STRING_LENGTH && isHex())
                return parseLeafTree();

            else if (getNameLength() == 2 && isHex() && isTree())
                return parseFanoutTree();

            else
                storeNonNote();
        }

        // If we cannot determine the style used, assume its a leaf.
        return new LeafBucket(prefixLen);
    }

    private LeafBucket parseLeafTree() {
        final LeafBucket leaf = new LeafBucket(prefixLen);
        final MutableObjectId idBuf = new MutableObjectId();

        for (; !eof(); next(1)) {
            if (parseObjectId(idBuf))
                leaf.parseOneEntry(idBuf, getEntryObjectId());
            else
                storeNonNote();
        }

        return leaf;
    }

    private boolean parseObjectId(MutableObjectId id) {
        if (pathLen == pathPadding + OBJECT_ID_STRING_LENGTH) {
            try {
                id.fromString(path, pathPadding);
                return true;
            } catch (ArrayIndexOutOfBoundsException notHex) {
                return false;
            }
        }
        return false;
    }

    private FanoutBucket parseFanoutTree() {
        final FanoutBucket fanout = new FanoutBucket(prefixLen);

        for (; !eof(); next(1)) {
            final int cell = parseFanoutCell();
            if (0 <= cell)
                fanout.setBucket(cell, getEntryObjectId());
            else
                storeNonNote();
        }

        return fanout;
    }

    private int parseFanoutCell() {
        if (getNameLength() == 2 && isTree()) {
            try {
                return (parseHexInt4(path[pathOffset + 0]) << 4)
                        | parseHexInt4(path[pathOffset + 1]);
            } catch (ArrayIndexOutOfBoundsException notHex) {
                return -1;
            }
        }
        return -1;
    }

    private void storeNonNote() {
        ObjectId id = getEntryObjectId();
        FileMode fileMode = getEntryFileMode();

        byte[] name = new byte[getNameLength()];
        getName(name, 0);

        NonNoteEntry ent = new NonNoteEntry(name, fileMode, id);
        if (firstNonNote == null)
            firstNonNote = ent;
        if (lastNonNote != null)
            lastNonNote.next = ent;
        lastNonNote = ent;
    }

    private boolean isTree() {
        return TREE.equals(mode);
    }

    private boolean isHex() {
        try {
            for (int i = pathOffset; i < pathLen; i++)
                parseHexInt4(path[i]);
            return true;
        } catch (ArrayIndexOutOfBoundsException fail) {
            return false;
        }
    }
}