import org.apache.poi.EmptyFileException;
public final class IOUtils {
+ private static final POILogger logger = POILogFactory.getLogger( IOUtils.class );
- private static final POILogger logger = POILogFactory
- .getLogger( IOUtils.class );
-
- private IOUtils() {
- // no instances of this class
- }
-
- /**
- * Peeks at the first 8 bytes of the stream. Returns those bytes, but
- * with the stream unaffected. Requires a stream that supports mark/reset,
- * or a PushbackInputStream. If the stream has >0 but <8 bytes,
- * remaining bytes will be zero.
- * @throws EmptyFileException if the stream is empty
- */
- public static byte[] peekFirst8Bytes(InputStream stream) throws IOException, EmptyFileException {
+ private IOUtils() {
+ // no instances of this class
+ }
+
+ /**
+ * Peeks at the first 8 bytes of the stream. Returns those bytes, but
+ * with the stream unaffected. Requires a stream that supports mark/reset,
+ * or a PushbackInputStream. If the stream has >0 but <8 bytes,
+ * remaining bytes will be zero.
+ * @throws EmptyFileException if the stream is empty
+ */
+ public static byte[] peekFirst8Bytes(InputStream stream) throws IOException, EmptyFileException {
// We want to peek at the first 8 bytes
- stream.mark(8);
+ stream.mark(8);
byte[] header = new byte[8];
int read = IOUtils.readFully(stream, header);
-
+
if (read < 1)
throw new EmptyFileException();
} else {
stream.reset();
}
-
+
return header;
- }
-
- /**
- * Reads all the data from the input stream, and returns the bytes read.
- */
- public static byte[] toByteArray(InputStream stream) throws IOException {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
-
- byte[] buffer = new byte[4096];
- int read = 0;
- while (read != -1) {
- read = stream.read(buffer);
- if (read > 0) {
- baos.write(buffer, 0, read);
- }
- }
-
- return baos.toByteArray();
- }
-
- /**
- * Returns an array (that shouldn't be written to!) of the
- * ByteBuffer. Will be of the requested length, or possibly
- * longer if that's easier.
- */
- public static byte[] toByteArray(ByteBuffer buffer, int length) {
- if(buffer.hasArray() && buffer.arrayOffset() == 0) {
- // The backing array should work out fine for us
- return buffer.array();
- }
-
- byte[] data = new byte[length];
- buffer.get(data);
- return data;
- }
-
- /**
- * Helper method, just calls <tt>readFully(in, b, 0, b.length)</tt>
- */
- public static int readFully(InputStream in, byte[] b) throws IOException {
- return readFully(in, b, 0, b.length);
- }
-
- /**
- * Same as the normal <tt>in.read(b, off, len)</tt>, but tries to ensure
- * that the entire len number of bytes is read.
- * If the end of file is reached before any bytes are read, returns -1. If
- * the end of the file is reached after some bytes are read, returns the
- * number of bytes read. If the end of the file isn't reached before len
- * bytes have been read, will return len bytes.
- */
- public static int readFully(InputStream in, byte[] b, int off, int len) throws IOException {
- int total = 0;
- while (true) {
- int got = in.read(b, off + total, len - total);
- if (got < 0) {
- return (total == 0) ? -1 : total;
- }
- total += got;
- if (total == len) {
- return total;
- }
- }
- }
-
- /**
- * Same as the normal <tt>channel.read(b)</tt>, but tries to ensure
- * that the entire len number of bytes is read.
- * <p>
- * If the end of file is reached before any bytes are read, returns -1. If
- * the end of the file is reached after some bytes are read, returns the
- * number of bytes read. If the end of the file isn't reached before len
- * bytes have been read, will return len bytes.
- */
- public static int readFully(ReadableByteChannel channel, ByteBuffer b) throws IOException {
- int total = 0;
- while (true) {
- int got = channel.read(b);
- if (got < 0) {
- return (total == 0) ? -1 : total;
- }
- total += got;
- if (total == b.capacity() || b.position() == b.capacity()) {
- return total;
- }
- }
- }
-
- /**
- * Copies all the data from the given InputStream to the OutputStream. It
- * leaves both streams open, so you will still need to close them once done.
- */
- public static void copy(InputStream inp, OutputStream out) throws IOException {
- byte[] buff = new byte[4096];
- int count;
- while ((count = inp.read(buff)) != -1) {
- if (count > 0) {
- out.write(buff, 0, count);
- }
- }
- }
+ }
+
+ /**
+ * Reads all the data from the input stream, and returns the bytes read.
+ */
+ public static byte[] toByteArray(InputStream stream) throws IOException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+ byte[] buffer = new byte[4096];
+ int read = 0;
+ while (read != -1) {
+ read = stream.read(buffer);
+ if (read > 0) {
+ baos.write(buffer, 0, read);
+ }
+ }
+
+ return baos.toByteArray();
+ }
+
+ /**
+ * Returns an array (that shouldn't be written to!) of the
+ * ByteBuffer. Will be of the requested length, or possibly
+ * longer if that's easier.
+ */
+ public static byte[] toByteArray(ByteBuffer buffer, int length) {
+ if(buffer.hasArray() && buffer.arrayOffset() == 0) {
+ // The backing array should work out fine for us
+ return buffer.array();
+ }
+
+ byte[] data = new byte[length];
+ buffer.get(data);
+ return data;
+ }
+
+ /**
+ * Helper method, just calls <tt>readFully(in, b, 0, b.length)</tt>
+ */
+ public static int readFully(InputStream in, byte[] b) throws IOException {
+ return readFully(in, b, 0, b.length);
+ }
+
+ /**
+ * Same as the normal <tt>in.read(b, off, len)</tt>, but tries to ensure
+ * that the entire len number of bytes is read.
+ * <p>
+ * If the end of file is reached before any bytes are read, returns -1. If
+ * the end of the file is reached after some bytes are read, returns the
+ * number of bytes read. If the end of the file isn't reached before len
+ * bytes have been read, will return len bytes.
+ */
+ public static int readFully(InputStream in, byte[] b, int off, int len) throws IOException {
+ int total = 0;
+ while (true) {
+ int got = in.read(b, off + total, len - total);
+ if (got < 0) {
+ return (total == 0) ? -1 : total;
+ }
+ total += got;
+ if (total == len) {
+ return total;
+ }
+ }
+ }
+
+ /**
+ * Same as the normal <tt>channel.read(b)</tt>, but tries to ensure
+ * that the entire len number of bytes is read.
+ * If the end of file is reached before any bytes are read, returns -1. If
+ * the end of the file is reached after some bytes are read, returns the
+ * number of bytes read. If the end of the file isn't reached before len
+ * bytes have been read, will return len bytes.
+ */
+ public static int readFully(ReadableByteChannel channel, ByteBuffer b) throws IOException {
+ int total = 0;
+ while (true) {
+ int got = channel.read(b);
+ if (got < 0) {
+ return (total == 0) ? -1 : total;
+ }
+ total += got;
+ if (total == b.capacity() || b.position() == b.capacity()) {
+ return total;
+ }
+ }
+ }
+
+ /**
+ * Copies all the data from the given InputStream to the OutputStream. It
+ * leaves both streams open, so you will still need to close them once done.
+ */
+ public static void copy(InputStream inp, OutputStream out) throws IOException {
+ byte[] buff = new byte[4096];
+ int count;
+ while ((count = inp.read(buff)) != -1) {
+ if (count > 0) {
+ out.write(buff, 0, count);
+ }
+ }
+ }
public static long calculateChecksum(byte[] data) {
Checksum sum = new CRC32();
* @param closeable
* resource to close
*/
- public static void closeQuietly( final Closeable closeable )
- {
- try
- {
+ public static void closeQuietly( final Closeable closeable ) {
+ try {
closeable.close();
- }
- catch ( Exception exc )
- {
+ } catch ( Exception exc ) {
logger.log( POILogger.ERROR, "Unable to close resource: " + exc,
exc );
}
projects / poi.git / commitdiff