IoUtils.java
/*
* $Source$
* $Revision$
*
* Copyright (C) 2000 William Chesters
*
* Part of Melati (http://melati.org), a framework for the rapid
* development of clean, maintainable web applications.
*
* Melati is free software; Permission is granted to copy, distribute
* and/or modify this software under the terms either:
*
* a) the GNU General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version,
*
* or
*
* b) any version of the Melati Software License, as published
* at http://melati.org
*
* You should have received a copy of the GNU General Public License and
* the Melati Software License along with this program;
* if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
* GNU General Public License and visit http://melati.org to obtain the
* Melati Software License.
*
* Feel free to contact the Developers of Melati (http://melati.org),
* if you would like to work out a different arrangement than the options
* outlined here. It is our intention to allow Melati to be used by as
* wide an audience as possible.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* Contact details for copyright holder:
*
* William Chesters <williamc At paneris.org>
* http://paneris.org/~williamc
* Obrechtstraat 114, 2517VX Den Haag, The Netherlands
*/
package org.melati.util;
import java.io.Writer;
import java.io.FileWriter;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
/**
* IO utilities.
*/
public final class IoUtils {
private IoUtils() {
// Utility classes should not have a public or default constructor.
}
/**
* Read into a byte array.
*
* Not sure this is really optimal.
*
* @param i the inputStream
* @param estimate approximately how big
* @param limit will not be bigger than
* @return a byte array no bigger than limit
* @throws IOException
*/
public static byte[] slurp(InputStream i, int estimate, int limit)
throws IOException {
try {
byte[] b = new byte[estimate];
int p = 0;
for (;;) {
int g = i.read(b, p, Math.min(b.length, limit) - p);
if (g == -1) break;
p += g;
if (p >= limit) break;
if (p >= b.length) {
byte[] c = new byte[2 * b.length];
System.arraycopy(b, 0, c, 0, p);
b = c;
}
}
if (p == b.length)
return b;
else {
byte[] c = new byte[p];
System.arraycopy(b, 0, c, 0, p);
return c;
}
}
finally {
try { i.close(); } catch (Exception e) {
// Ignore
e = null; // shut PMD up
}
}
}
/**
* Read into a byte array.
*
* Used in bibliomania.
*
* @param i the inputStream
* @param estimate approximately how big
* @return a byte array no bigger than Integer.MAX_VALUE
* @throws IOException
*/
public static byte[] slurp(InputStream i, int estimate) throws IOException {
return slurp(i, estimate, Integer.MAX_VALUE);
}
/**
* Read an url into a byte array.
*
* Used in bibliomania.
*
* @param url the url to read
* @param estimate approximately how big
* @return a byte array no bigger than Integer.MAX_VALUE
* @throws IOException
*/
public static byte[] slurp(URL url, int estimate) throws IOException {
return slurp(url.openStream(), estimate);
}
/**
* Read an url into a byte array, with a limit.
*
* Used in bibliomania.
*
* @param url the url to read
* @param estimate approximately how big
* @param max limit
* @return a byte array no bigger than max
* @throws IOException
*/
public static byte[] slurp(URL url, int estimate, int max)
throws IOException {
return slurp(url.openStream(), estimate, max);
}
/**
* Read a file into a byte array.
*
* Used in bibliomania.
*
* @param f file to read
* @param estimate approximately how big
* @return a byte array no bigger than Integer.MAX_VALUE
* @throws IOException
*/
public static byte[] slurp(File f, int estimate) throws IOException {
return slurp(new FileInputStream(f), estimate);
}
/**
* Read from a Reader into a byte array.
*
* Not used elsewhere as of 30/11/2006.
*
* @param i Reader to read
* @param estimate approximately how big
* @param limit max size
* @return a byte array no bigger than limit
* @throws IOException
*/
public static char[] slurp(Reader i, int estimate, int limit)
throws IOException {
try {
char[] b = new char[estimate];
int p = 0;
for (;;) {
int g = i.read(b, p, Math.min(b.length, limit) - p);
if (g == -1) break;
p += g;
if (p >= limit) break;
if (p >= b.length) {
char[] c = new char[2 * b.length];
System.arraycopy(b, 0, c, 0, p);
b = c;
}
}
if (p == b.length)
return b;
else {
char[] c = new char[p];
System.arraycopy(b, 0, c, 0, p);
return c;
}
}
finally {
try { i.close(); } catch (Exception e) {
//Ignore
e = null; // shut PMD up
}
}
}
/**
* Read from a Reader into a byte array.
*
* Used in bibliomania.
*
* @param i Reader to read
* @param estimate approximately how big
* @return a byte array no bigger than Integer.MAX_VALUE
* @throws IOException
*/
public static char[] slurp(Reader i, int estimate) throws IOException {
return slurp(i, estimate, Integer.MAX_VALUE);
}
/**
* Read the output of a system command into a byte array.
*
* Warning: potentially inefficient.
* Not used elsewhere as of 30/11/2006.
*
* @param command the command to run
* @param estimate approximately how big
* @param limit max size
* @return a byte array no bigger than limit
* @throws IOException
*/
public static byte[] slurpOutputOf_bytes(String[] command,
int estimate, int limit)
throws IOException {
Process proc = Runtime.getRuntime().exec(command);
byte[] output = IoUtils.slurp(proc.getInputStream(), estimate, limit);
byte[] errors = IoUtils.slurp(proc.getErrorStream(), estimate, limit);
try {
if (proc.waitFor() != 0)
throw new ProcessFailedException(command[0] + " failed",
new String(errors));
return output;
}
catch (InterruptedException e) {
throw new IOException("interrupted while waiting for " +
command[0] + " to complete");
}
}
/**
* Read the output of a system command into a byte array.
*
* Warning: potentially inefficient.
* Not used elsewhere as of 30/11/2006.
*
* @param command the command to run
* @param estimate approximately how big
* @param limit max size
* @return a String no bigger than limit
* @throws IOException
*/
public static String slurpOutputOf(String[] command, int estimate, int limit)
throws IOException {
return new String(slurpOutputOf_bytes(command, estimate, limit));
}
/**
* Copy from an InputStream to an OutputStream.
* Not used elsewhere as of 30/11/2006.
*
* @param i the InputStream
* @param buf the size of buffer to use
* @param o the OutputStream
* @throws IOException
*/
public static void copy(InputStream i, int buf, OutputStream o)
throws IOException {
byte b[] = new byte[buf];
for (;;) {
int g = i.read(b);
if (g == -1) break;
o.write(b, 0, g);
}
}
/**
* Copy from a Reader to a Writer.
* Not used elsewhere as of 30/11/2006.
*
* @param i the Reader
* @param buf the size of buffer to use
* @param o the Writer
* @throws IOException
*/
public static void copy(Reader i, int buf, Writer o)
throws IOException {
char b[] = new char[buf];
for (;;) {
int g = i.read(b);
if (g == -1) break;
o.write(b, 0, g);
}
}
/**
* Copy from one file to another.
*
* Used in bibliomania.
* @param from input file
* @param buf the size of buffer to use
* @param to output file
* @throws IOException
*/
public static void copy(File from, int buf, File to) throws IOException {
FileReader i = new FileReader(from);
try {
FileWriter o = new FileWriter(to);
try {
copy(i, buf, o);
}
finally {
try { o.close(); } catch (Exception e) {
//Ignore
e = null; // shut PMD up
}
}
}
finally {
try { i.close(); } catch (Exception e) {
//Ignore
e = null; // shut PMD up
}
}
}
}