/*
* 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 other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.util;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
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;
/**
* 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 FileNotFoundException
* the file does not exist.
* @throws IOException
* the file exists, but its contents cannot be read.
*/
public static final byte[] readFully(final 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 FileNotFoundException
* the file does not exist.
* @throws IOException
* the file exists, but its contents cannot be read.
*/
public static final byte[] readSome(final File path, final int limit)
throws FileNotFoundException, IOException {
FileInputStream in = new FileInputStream(path);
try {
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;
} finally {
try {
in.close();
} catch (IOException ignored) {
// do nothing
}
}
}
/**
* 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 FileNotFoundException
* the file does not exist.
* @throws IOException
* the file exists, but its contents cannot be read.
*/
public static final byte[] readFully(final File path, final int max)
throws FileNotFoundException, IOException {
final FileInputStream in = new FileInputStream(path);
try {
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;
} finally {
try {
in.close();
} catch (IOException ignored) {
// ignore any close errors, this was a read only stream
}
}
}
/**
* 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 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);
@SuppressWarnings("resource" /* java 7 */)
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 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 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 in buffer or stream, whichever is shortest
* @throws 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 ((r = fd.read(dst, off, dst.length - off)) >= 0
&& len < dst.length) {
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 IOException
* there was an error reading from the stream.
*/
public static void skipFully(final 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(final String s) {
List<String> l = new ArrayList<String>();
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;
} else { // 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 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);
}
} else {
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.
}
}