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 >= 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.
}
}