PackBitmapIndexWriterV1.java

/*
 * Copyright (C) 2012, 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.internal.storage.file;

import java.io.BufferedOutputStream;
import java.io.DataOutput;
import java.io.IOException;
import java.io.OutputStream;
import java.security.DigestOutputStream;
import java.text.MessageFormat;

import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.internal.storage.file.PackBitmapIndexBuilder.StoredEntry;
import org.eclipse.jgit.lib.Constants;

import com.googlecode.javaewah.EWAHCompressedBitmap;

/**
 * Creates the version 1 pack bitmap index files.
 *
 * @see PackBitmapIndexV1
 */
public class PackBitmapIndexWriterV1 {
    private final DigestOutputStream out;
    private final DataOutput dataOutput;

    /**
     * Creates the version 1 pack bitmap index files.
     *
     * @param dst
     *            the output stream to which the index will be written.
     */
    public PackBitmapIndexWriterV1(final OutputStream dst) {
        out = new DigestOutputStream(dst instanceof BufferedOutputStream ? dst
                : new BufferedOutputStream(dst),
                Constants.newMessageDigest());
        dataOutput = new SimpleDataOutput(out);
    }

    /**
     * Write all object entries to the index stream.
     * <p>
     * After writing the stream passed to the factory is flushed but remains
     * open. Callers are always responsible for closing the output stream.
     *
     * @param bitmaps
     *            the index data for the bitmaps
     * @param packDataChecksum
     *            checksum signature of the entire pack data content. This is
     *            traditionally the last 20 bytes of the pack file's own stream.
     * @throws java.io.IOException
     *             an error occurred while writing to the output stream, or this
     *             index format cannot store the object data supplied.
     */
    public void write(PackBitmapIndexBuilder bitmaps, byte[] packDataChecksum)
            throws IOException {
        if (bitmaps == null || packDataChecksum.length != 20)
            throw new IllegalStateException();

        writeHeader(bitmaps.getOptions(), bitmaps.getBitmapCount(),
                packDataChecksum);
        writeBody(bitmaps);
        writeFooter();

        out.flush();
    }

    private void writeHeader(
            int options, int bitmapCount, byte[] packDataChecksum)
            throws IOException {
        out.write(PackBitmapIndexV1.MAGIC);
        dataOutput.writeShort(1);
        dataOutput.writeShort(options);
        dataOutput.writeInt(bitmapCount);
        out.write(packDataChecksum);
    }

    private void writeBody(PackBitmapIndexBuilder bitmaps) throws IOException {
        writeBitmap(bitmaps.getCommits());
        writeBitmap(bitmaps.getTrees());
        writeBitmap(bitmaps.getBlobs());
        writeBitmap(bitmaps.getTags());
        writeBitmaps(bitmaps);
    }

    private void writeBitmap(EWAHCompressedBitmap bitmap) throws IOException {
        bitmap.serialize(dataOutput);
    }

    private void writeBitmaps(PackBitmapIndexBuilder bitmaps)
            throws IOException {
        int bitmapCount = 0;
        for (StoredEntry entry : bitmaps.getCompressedBitmaps()) {
            writeBitmapEntry(entry);
            bitmapCount++;
        }

        int expectedBitmapCount = bitmaps.getBitmapCount();
        if (expectedBitmapCount != bitmapCount)
            throw new IOException(MessageFormat.format(
                    JGitText.get().expectedGot,
                    String.valueOf(expectedBitmapCount),
                    String.valueOf(bitmapCount)));
    }

    private void writeBitmapEntry(StoredEntry entry) throws IOException {
        // Write object, XOR offset, and bitmap
        dataOutput.writeInt((int) entry.getObjectId());
        out.write(entry.getXorOffset());
        out.write(entry.getFlags());
        writeBitmap(entry.getBitmap());
    }

    private void writeFooter() throws IOException {
        out.on(false);
        out.write(out.getMessageDigest().digest());
    }
}