jeremias 2002/12/02 06:15:08
Modified: src/org/apache/fop/util StreamUtilities.java
Log:
style and javadocs
added new method toByteArray()
Revision Changes Path
1.2 +62 -10 xml-fop/src/org/apache/fop/util/StreamUtilities.java
Index: StreamUtilities.java
===================================================================
RCS file: /home/cvs/xml-fop/src/org/apache/fop/util/StreamUtilities.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- StreamUtilities.java 27 May 2002 10:59:08 -0000 1.1
+++ StreamUtilities.java 2 Dec 2002 14:15:08 -0000 1.2
@@ -8,6 +8,7 @@
import java.io.InputStream;
import java.io.OutputStream;
+import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.EOFException;
import java.io.DataInput;
@@ -29,6 +30,10 @@
* The process is buffered, so you shouldn't need
* BufferedInput/OutputStreams. Flushes when it's finished, but does
* not close either stream. Returns the number of bytes copied.
+ * @param source InputStream to read from
+ * @param sink OutputStream to write to
+ * @return long the total number of bytes copied
+ * @throws IOException In case of an I/O problem
*/
public static long streamCopy(InputStream source,
OutputStream sink) throws IOException {
@@ -39,8 +44,9 @@
// trough
int scoop;
while ((scoop = source.read(buffer)) >= 0) {
- if (scoop == 0)
+ if (scoop == 0) {
System.out.println("zero scoop!");
+ }
sink.write(buffer, 0, scoop);
total += scoop;
}
@@ -52,13 +58,20 @@
}
/**
+ * Method streamCopy.
+ */
+ /**
* Binary copies up to the given number of bytes from an input
* stream to an output stream. The process is buffered, so you
* shouldn't need BufferedInput/OutputStreams.
* Flushes when it's finished, but does not close either stream.
* Throws an EOFExeption if there aren't enough bytes available to
* transfer the requested amount.
- * Returns the total number of bytes copied.
+ * @param source InputStream to read from
+ * @param sink OutputStream to write to
+ * @param howMany requested amount of bytes that are to be copied
+ * @return long the total number of bytes copied
+ * @throws IOException In case of an I/O problem
*/
public static long streamCopy(InputStream source,
OutputStream sink, int howMany) throws
IOException {
@@ -70,10 +83,12 @@
int scoop;
while (left > 0) {
scoop = source.read(buffer, 0, Math.min(BUFFER_SIZE, left));
- if (scoop < 0)
+ if (scoop < 0) {
throw new EOFException(
- "Not enough bytes to feed you in IOLib.streamCopy(source, sink,
howMany); you asked for " +
- howMany + " and I only have " + (howMany - left));
+ "Not enough bytes to feed you in "
+ + "IOLib.streamCopy(source, sink, howMany); you asked for "
+ + howMany + " and I only have " + (howMany - left));
+ }
sink.write(buffer, 0, scoop);
left -= scoop;
@@ -86,13 +101,20 @@
}
/**
+ * Method streamCopyWithChecksum.
+ */
+ /**
* Binary copies up to the given number of bytes from an input
* stream to an output stream. The process is buffered, so you
* shouldn't need BufferedInput/OutputStreams.
* Flushes when it's finished, but does not close either stream.
* Throws an EOFExeption if there aren't enough bytes available
* to transfer the requested amount.
- * Returns the checksum of the bytes copied.
+ * @param source InputStream to read from
+ * @param sink OutputStream to write to
+ * @param howMany requested amount of bytes that are to be copied
+ * @return long the checksum of the bytes copied
+ * @throws IOException In case of an I/O problem
*/
public static long streamCopyWithChecksum(InputStream source,
OutputStream sink, int howMany) throws IOException {
@@ -105,8 +127,10 @@
int scoop;
while (left > 0) {
scoop = source.read(buffer, 0, Math.min(BUFFER_SIZE, left));
- if (scoop < 0)
- throw new EOFException("Not enough bytes to feed you in
IOLib.streamCopy(source, sink, howMany)");
+ if (scoop < 0) {
+ throw new EOFException("Not enough bytes to feed you in "
+ + "IOLib.streamCopy(source, sink, howMany)");
+ }
checksummer.update(buffer, 0, scoop);
sink.write(buffer, 0, scoop);
@@ -120,10 +144,17 @@
}
/**
+ * Method dataCopy.
+ */
+ /**
* Binary copies up to the given number of bytes from a DataInput
* object to an DataOutput object. The process is buffered. Since
* DataOutput doesn't support closing or flushing, it does neither.
- * Returns the total number of bytes copied.
+ * @param source DataInput to read from
+ * @param sink DataOutput to write to
+ * @param howMany requested amount of bytes that are to be copied
+ * @return long the total number of bytes copied
+ * @throws IOException In case of an I/O problem
*/
public static long dataCopy(DataInput source, DataOutput sink,
int howMany) throws IOException {
@@ -142,6 +173,27 @@
// do dishes
return howMany;
+ }
+
+
+ /**
+ * Loads the contents of the InputStream to a byte array. The InputStream
+ * isn't closed.
+ * @param in InputStream to read from
+ * @param initialTargetBufferSize initial number of bytes to allocate
+ * (expected size to avoid a lot of reallocations)
+ * @return byte[] the array of bytes requested
+ * @throws IOException In case of an I/O problem
+ */
+ public static byte[] toByteArray(InputStream in, int initialTargetBufferSize)
+ throws IOException {
+ ByteArrayOutputStream baout = new
ByteArrayOutputStream(initialTargetBufferSize);
+ try {
+ streamCopy(in, baout);
+ } finally {
+ baout.close();
+ }
+ return baout.toByteArray();
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
