IO.java

/*
 * Copyright (C) 2008-2009, Google Inc.
 * Copyright (C) 2009, Robin Rosenberg <robin.rosenberg@dewire.com>
 * Copyright (C) 2006-2008, Shawn O. Pearce <spearce@spearce.org> 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.util;

import java.io.EOFException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.nio.ByteBuffer;
import java.nio.channels.ReadableByteChannel;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.util.io.SilentFileInputStream;

/**
 * Input/Output utilities
 */
public class IO {

    /**
     * Read an entire local file into memory as a byte array.
     *
     * @param path
     *            location of the file to read.
     * @return complete contents of the requested local file.
     * @throws java.io.FileNotFoundException
     *             the file does not exist.
     * @throws java.io.IOException
     *             the file exists, but its contents cannot be read.
     */
    public static final byte[] readFully(File path)
            throws FileNotFoundException, IOException {
        return IO.readFully(path, Integer.MAX_VALUE);
    }

    /**
     * Read at most limit bytes from the local file into memory as a byte array.
     *
     * @param path
     *            location of the file to read.
     * @param limit
     *            maximum number of bytes to read, if the file is larger than
     *            only the first limit number of bytes are returned
     * @return complete contents of the requested local file. If the contents
     *         exceeds the limit, then only the limit is returned.
     * @throws java.io.FileNotFoundException
     *             the file does not exist.
     * @throws java.io.IOException
     *             the file exists, but its contents cannot be read.
     */
    public static final byte[] readSome(File path, int limit)
            throws FileNotFoundException, IOException {
        try (SilentFileInputStream in = new SilentFileInputStream(path)) {
            byte[] buf = new byte[limit];
            int cnt = 0;
            for (;;) {
                int n = in.read(buf, cnt, buf.length - cnt);
                if (n <= 0)
                    break;
                cnt += n;
            }
            if (cnt == buf.length)
                return buf;
            byte[] res = new byte[cnt];
            System.arraycopy(buf, 0, res, 0, cnt);
            return res;
        }
    }

    /**
     * Read an entire local file into memory as a byte array.
     *
     * @param path
     *            location of the file to read.
     * @param max
     *            maximum number of bytes to read, if the file is larger than
     *            this limit an IOException is thrown.
     * @return complete contents of the requested local file.
     * @throws java.io.FileNotFoundException
     *             the file does not exist.
     * @throws java.io.IOException
     *             the file exists, but its contents cannot be read.
     */
    public static final byte[] readFully(File path, int max)
            throws FileNotFoundException, IOException {
        try (SilentFileInputStream in = new SilentFileInputStream(path)) {
            long sz = Math.max(path.length(), 1);
            if (sz > max)
                throw new IOException(MessageFormat.format(
                        JGitText.get().fileIsTooLarge, path));

            byte[] buf = new byte[(int) sz];
            int valid = 0;
            for (;;) {
                if (buf.length == valid) {
                    if (buf.length == max) {
                        int next = in.read();
                        if (next < 0)
                            break;

                        throw new IOException(MessageFormat.format(
                                JGitText.get().fileIsTooLarge, path));
                    }

                    byte[] nb = new byte[Math.min(buf.length * 2, max)];
                    System.arraycopy(buf, 0, nb, 0, valid);
                    buf = nb;
                }
                int n = in.read(buf, valid, buf.length - valid);
                if (n < 0)
                    break;
                valid += n;
            }
            if (valid < buf.length) {
                byte[] nb = new byte[valid];
                System.arraycopy(buf, 0, nb, 0, valid);
                buf = nb;
            }
            return buf;
        }
    }

    /**
     * Read an entire input stream into memory as a ByteBuffer.
     *
     * Note: The stream is read to its end and is not usable after calling this
     * method. The caller is responsible for closing the stream.
     *
     * @param in
     *            input stream to be read.
     * @param sizeHint
     *            a hint on the approximate number of bytes contained in the
     *            stream, used to allocate temporary buffers more efficiently
     * @return complete contents of the input stream. The ByteBuffer always has
     *         a writable backing array, with {@code position() == 0} and
     *         {@code limit()} equal to the actual length read. Callers may rely
     *         on obtaining the underlying array for efficient data access. If
     *         {@code sizeHint} was too large, the array may be over-allocated,
     *         resulting in {@code limit() < array().length}.
     * @throws java.io.IOException
     *             there was an error reading from the stream.
     */
    public static ByteBuffer readWholeStream(InputStream in, int sizeHint)
            throws IOException {
        byte[] out = new byte[sizeHint];
        int pos = 0;
        while (pos < out.length) {
            int read = in.read(out, pos, out.length - pos);
            if (read < 0)
                return ByteBuffer.wrap(out, 0, pos);
            pos += read;
        }

        int last = in.read();
        if (last < 0)
            return ByteBuffer.wrap(out, 0, pos);

        try (TemporaryBuffer.Heap tmp = new TemporaryBuffer.Heap(
                Integer.MAX_VALUE)) {
            tmp.write(out);
            tmp.write(last);
            tmp.copy(in);
            return ByteBuffer.wrap(tmp.toByteArray());
        }
    }

    /**
     * Read the entire byte array into memory, or throw an exception.
     *
     * @param fd
     *            input stream to read the data from.
     * @param dst
     *            buffer that must be fully populated, [off, off+len).
     * @param off
     *            position within the buffer to start writing to.
     * @param len
     *            number of bytes that must be read.
     * @throws EOFException
     *             the stream ended before dst was fully populated.
     * @throws java.io.IOException
     *             there was an error reading from the stream.
     */
    public static void readFully(final InputStream fd, final byte[] dst,
            int off, int len) throws IOException {
        while (len > 0) {
            final int r = fd.read(dst, off, len);
            if (r <= 0)
                throw new EOFException(JGitText.get().shortReadOfBlock);
            off += r;
            len -= r;
        }
    }

    /**
     * Read as much of the array as possible from a channel.
     *
     * @param channel
     *            channel to read data from.
     * @param dst
     *            buffer that must be fully populated, [off, off+len).
     * @param off
     *            position within the buffer to start writing to.
     * @param len
     *            number of bytes that should be read.
     * @return number of bytes actually read.
     * @throws java.io.IOException
     *             there was an error reading from the channel.
     */
    public static int read(ReadableByteChannel channel, byte[] dst, int off,
            int len) throws IOException {
        if (len == 0)
            return 0;
        int cnt = 0;
        while (0 < len) {
            int r = channel.read(ByteBuffer.wrap(dst, off, len));
            if (r <= 0)
                break;
            off += r;
            len -= r;
            cnt += r;
        }
        return cnt != 0 ? cnt : -1;
    }

    /**
     * Read the entire byte array into memory, unless input is shorter
     *
     * @param fd
     *            input stream to read the data from.
     * @param dst
     *            buffer that must be fully populated, [off, off+len).
     * @param off
     *            position within the buffer to start writing to.
     * @return number of bytes read
     * @throws java.io.IOException
     *             there was an error reading from the stream.
     */
    public static int readFully(InputStream fd, byte[] dst, int off)
            throws IOException {
        int r;
        int len = 0;
        while (off < dst.length
                && (r = fd.read(dst, off, dst.length - off)) >= 0) {
            off += r;
            len += r;
        }
        return len;
    }

    /**
     * Skip an entire region of an input stream.
     * <p>
     * The input stream's position is moved forward by the number of requested
     * bytes, discarding them from the input. This method does not return until
     * the exact number of bytes requested has been skipped.
     *
     * @param fd
     *            the stream to skip bytes from.
     * @param toSkip
     *            total number of bytes to be discarded. Must be &gt;= 0.
     * @throws EOFException
     *             the stream ended before the requested number of bytes were
     *             skipped.
     * @throws java.io.IOException
     *             there was an error reading from the stream.
     */
    public static void skipFully(InputStream fd, long toSkip)
            throws IOException {
        while (toSkip > 0) {
            final long r = fd.skip(toSkip);
            if (r <= 0)
                throw new EOFException(JGitText.get().shortSkipOfBlock);
            toSkip -= r;
        }
    }

    /**
     * Divides the given string into lines.
     *
     * @param s
     *            the string to read
     * @return the string divided into lines
     * @since 2.0
     */
    public static List<String> readLines(String s) {
        List<String> l = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '\n') {
                l.add(sb.toString());
                sb.setLength(0);
                continue;
            }
            if (c == '\r') {
                if (i + 1 < s.length()) {
                    c = s.charAt(++i);
                    l.add(sb.toString());
                    sb.setLength(0);
                    if (c != '\n') {
                        sb.append(c);
                    }
                    continue;
                }
                // EOF
                l.add(sb.toString());
                break;
            }
            sb.append(c);
        }
        l.add(sb.toString());
        return l;
    }

    /**
     * Read the next line from a reader.
     * <p>
     * Like {@link java.io.BufferedReader#readLine()}, but only treats
     * {@code \n} as end-of-line, and includes the trailing newline.
     *
     * @param in
     *            the reader to read from.
     * @param sizeHint
     *            hint for buffer sizing; 0 or negative for default.
     * @return the next line from the input, always ending in {@code \n} unless
     *         EOF was reached.
     * @throws java.io.IOException
     *             there was an error reading from the stream.
     * @since 4.1
     */
    public static String readLine(Reader in, int sizeHint) throws IOException {
        if (in.markSupported()) {
            if (sizeHint <= 0) {
                sizeHint = 1024;
            }
            StringBuilder sb = new StringBuilder(sizeHint);
            char[] buf = new char[sizeHint];
            while (true) {
                in.mark(sizeHint);
                int n = in.read(buf);
                if (n < 0) {
                    in.reset();
                    return sb.toString();
                }
                for (int i = 0; i < n; i++) {
                    if (buf[i] == '\n') {
                        resetAndSkipFully(in, ++i);
                        sb.append(buf, 0, i);
                        return sb.toString();
                    }
                }
                if (n > 0) {
                    sb.append(buf, 0, n);
                }
                resetAndSkipFully(in, n);
            }
        }
        StringBuilder buf = sizeHint > 0 ? new StringBuilder(sizeHint)
                : new StringBuilder();
        int i;
        while ((i = in.read()) != -1) {
            char c = (char) i;
            buf.append(c);
            if (c == '\n') {
                break;
            }
        }
        return buf.toString();
    }

    private static void resetAndSkipFully(Reader fd, long toSkip) throws IOException {
        fd.reset();
        while (toSkip > 0) {
            long r = fd.skip(toSkip);
            if (r <= 0) {
                throw new EOFException(JGitText.get().shortSkipOfBlock);
            }
            toSkip -= r;
        }
    }

    private IO() {
        // Don't create instances of a static only utility.
    }
}