You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by te...@apache.org on 2006/08/04 12:26:44 UTC
svn commit: r428685 -
/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PushbackInputStream.java
Author: tellison
Date: Fri Aug 4 03:26:42 2006
New Revision: 428685
URL: http://svn.apache.org/viewvc?rev=428685&view=rev
Log:
Code tidy-up / formatting.
Modified:
incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PushbackInputStream.java
Modified: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PushbackInputStream.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PushbackInputStream.java?rev=428685&r1=428684&r2=428685&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PushbackInputStream.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PushbackInputStream.java Fri Aug 4 03:26:42 2006
@@ -15,6 +15,7 @@
package java.io;
+import org.apache.harmony.luni.util.Msg;
/**
* PushbackInputStream is a filter class which allows bytes read to be pushed
@@ -25,297 +26,315 @@
*
*/
public class PushbackInputStream extends FilterInputStream {
- /**
- * The <code>byte</code> array containing the bytes to read.
- */
- protected byte[] buf;
-
- /**
- * The current position within the byte array <code>buf</code>. A value
- * equal to buf.length indicates no bytes available. A value of 0 indicates
- * the buffer is full.
- */
- protected int pos;
-
- /**
- * Constructs a new PushbackInputStream on the InputStream <code>in</code>.
- * The size of the pushback buffer is set to the default, or 1 byte.
- *
- * @param in
- * the InputStream to allow pushback operations on.
- *
- */
- public PushbackInputStream(InputStream in) {
- super(in);
- buf = (in == null) ? null : new byte[1];
- pos = 1;
- }
-
- /**
- * Constructs a new PushbackInputStream on the InputStream <code>in</code>.
- * The size of the pushback buffer is set to <code>size</code>.
- *
- * @param in
- * the InputStream to allow pushback operations on.
- * @param size
- * the size of the pushback buffer (<code>size>=0</code>).
- */
- public PushbackInputStream(InputStream in, int size) {
- super(in);
- if (size > 0) {
- buf = (in == null) ? null : new byte[size];
- pos = size;
- } else
- throw new IllegalArgumentException(org.apache.harmony.luni.util.Msg
- .getString("K0058")); //$NON-NLS-1$
- }
-
- /**
- * Answers a int representing then number of bytes that are available before
- * this PushbackInputStream will block. This method returns the number of
- * bytes available in the pushback buffer plus those available in the target
- * stream.
- *
- * @return int the number of bytes available before blocking.
- *
- * @throws java.io.IOException
- * If an error occurs in this stream.
- */
- public int available() throws IOException {
- if (buf != null)
- return buf.length - pos + in.available();
- throw new IOException();
- }
-
- /**
- * Close this PushbackInputStream. This implementation closes the target
- * stream.
- *
- * @throws IOException
- * If an error occurs attempting to close this stream.
- */
- public void close() throws IOException {
- if (in != null) {
- in.close();
- in = null;
- buf = null;
- }
- }
-
- /**
- * Answers a boolean indicating whether or not this PushbackInputStream
- * supports mark() and reset(). This implementation always answers false
- * since PushbackInputStreams do not support mark/reset.
- *
- * @return boolean indicates whether or not mark() and reset() are
- * supported.
- */
- public boolean markSupported() {
- return false;
- }
-
- /**
- * Reads a single byte from this PushbackInputStream and returns the result
- * as an int. The low-order byte is returned or -1 of the end of stream was
- * encountered. If the pushback buffer does not contain any available bytes
- * then a byte from the target input stream is returned.
- *
- * @return int The byte read or -1 if end of stream.
- *
- * @throws IOException
- * If an IOException occurs.
- */
- public int read() throws IOException {
- if (buf != null) {
- // Is there a pushback byte available?
- if (pos < buf.length)
- return (buf[pos++] & 0xFF);
- // Assume read() in the InputStream will return low-order byte or -1
- // if end of stream.
- return in.read();
- }
- throw new IOException();
- }
-
- /**
- * Reads at most <code>length</code> bytes from this PushbackInputStream
- * and stores them in byte array <code>buffer</code> starting at
- * <code>offset</code>. Answer the number of bytes actually read or -1 if
- * no bytes were read and end of stream was encountered. This implementation
- * reads bytes from the pushback buffer first, then the target stream if
- * more bytes are required to satisfy <code>count</code>.
- *
- * @param buffer
- * the byte array in which to store the read bytes.
- * @param offset
- * the offset in <code>buffer</code> to store the read bytes.
- * @param length
- * the maximum number of bytes to store in <code>buffer</code>.
- * @return the number of bytes actually read or -1 if end of stream.
- *
- * @throws IOException
- * If an IOException occurs.
- */
- public int read(byte[] buffer, int offset, int length) throws IOException {
- if (buf != null && buffer != null) {
- // avoid int overflow
- if (0 <= offset && offset <= buffer.length && 0 <= length
- && length <= buffer.length - offset) {
- int copiedBytes = 0, copyLength = 0, newOffset = offset;
- // Are there pushback bytes available?
- if (pos < buf.length) {
- copyLength = (buf.length - pos >= length) ? length
- : buf.length - pos;
- System.arraycopy(buf, pos, buffer, newOffset, copyLength);
- newOffset += copyLength;
- copiedBytes += copyLength;
- // Use up the bytes in the local buffer
- pos += copyLength;
- }
- // Have we copied enough?
- if (copyLength == length)
- return length;
- int inCopied = in.read(buffer, newOffset, length - copiedBytes);
- if (inCopied > 0)
- return inCopied + copiedBytes;
- if (copiedBytes == 0)
- return inCopied;
- return copiedBytes;
- }
- throw new ArrayIndexOutOfBoundsException();
- } else if (buf == null) {
- throw new IOException();
- }
- throw new NullPointerException();
- }
-
- /**
- * Skips <code>count</code> number of bytes in this PushbackInputStream.
- * Subsequent <code>read()</code>'s will not return these bytes unless
- * <code>reset()</code> is used. This implementation skips
- * <code>count</code> number of bytes in the buffer and/or the target
- * stream.
- *
- * @param count
- * the number of bytes to skip.
- * @return the number of bytes actually skipped.
- *
- * @throws IOException
- * If the stream is already closed or another IOException
- * occurs.
- */
- public long skip(long count) throws IOException {
- if (in != null) {
- if (count <= 0) {
- return 0;
- }
- int numSkipped = 0;
- if (pos < buf.length) {
- numSkipped += (count < buf.length - pos) ? count : buf.length
- - pos;
- pos += numSkipped;
- }
- if (numSkipped < count) {
- numSkipped += in.skip(count - numSkipped);
- }
- return numSkipped;
- }
- throw new IOException(org.apache.harmony.luni.util.Msg.getString("K0059")); //$NON-NLS-1$
- }
-
- /**
- * Push back all the bytes in <code>buffer</code>. The bytes are pushed
- * so that they would be read back buffer[0], buffer[1], etc. If the push
- * back buffer cannot handle the entire contents of <code>buffer</code>,
- * an IOException will be thrown. Some of the buffer may already be in the
- * buffer after the exception is thrown.
- *
- * @param buffer
- * the byte array containing bytes to push back into the stream.
- *
- * @throws IOException
- * If the pushback buffer becomes, or is, full.
- */
- public void unread(byte[] buffer) throws IOException {
- unread(buffer, 0, buffer.length);
- }
-
- /**
- * Push back <code>length</code> number of bytes in <code>buffer</code>
- * starting at <code>offset</code>. The bytes are pushed so that they
- * would be read back buffer[offset], buffer[offset+1], etc. If the push
- * back buffer cannot handle the bytes copied from <code>buffer</code>,
- * an IOException will be thrown. Some of the bytes may already be in the
- * buffer after the exception is thrown.
- *
- * @param buffer
- * the byte array containing bytes to push back into the stream.
- * @param offset
- * the location to start taking bytes to push back.
- * @param length
- * the number of bytes to push back.
- *
- * @throws IOException
- * If the pushback buffer becomes, or is, full.
- */
- public void unread(byte[] buffer, int offset, int length)
- throws IOException {
- if (length > pos)
- // Pushback buffer full
- throw new IOException(org.apache.harmony.luni.util.Msg.getString("K007e"));
- // avoid int overflow
- if (0 <= offset && offset <= buffer.length && 0 <= length
- && length <= buffer.length - offset) {
- for (int i = offset + length - 1; i >= offset; i--)
- unread(buffer[i]);
- } else
- throw new ArrayIndexOutOfBoundsException();
- }
-
- /**
- * Push back one <code>byte</code>. Takes the byte <code>oneByte</code>
- * and puts in in the local buffer of bytes to read back before accessing
- * the target input stream.
- *
- * @param oneByte
- * the byte to push back into the stream.
- *
- * @throws IOException
- * If the pushback buffer is already full.
- */
- public void unread(int oneByte) throws IOException {
- if (buf != null) {
- if (pos != 0)
- buf[--pos] = (byte) oneByte;
- else
- throw new IOException(org.apache.harmony.luni.util.Msg.getString("K007e")); //$NON-NLS-1$
- } else
- throw new IOException();
- }
-
- /**
- * Make a mark of the current position in the stream but the mark method
- * does nothing.
- *
- * @param readlimit
- * the maximum number of bytes that are able to be read before the
- * mark becomes invalid
- * @override the method mark in FilterInputStream
- */
- public void mark(int readlimit) {
- return;
- }
-
- /**
- * Reset current position to the mark made previously int the stream, but
- * the reset method will throw IOException and do nothing else if called.
- *
- * @override the method reset in FilterInputStream
- * @throws IOException
- * If the method is called
- */
-
- public void reset() throws IOException {
- throw new IOException();
- }
+ /**
+ * The <code>byte</code> array containing the bytes to read.
+ */
+ protected byte[] buf;
+
+ /**
+ * The current position within the byte array <code>buf</code>. A value
+ * equal to buf.length indicates no bytes available. A value of 0 indicates
+ * the buffer is full.
+ */
+ protected int pos;
+
+ /**
+ * Constructs a new PushbackInputStream on the InputStream <code>in</code>.
+ * The size of the pushback buffer is set to the default, or 1 byte.
+ *
+ * @param in
+ * the InputStream to allow pushback operations on.
+ *
+ */
+ public PushbackInputStream(InputStream in) {
+ super(in);
+ buf = (in == null) ? null : new byte[1];
+ pos = 1;
+ }
+
+ /**
+ * Constructs a new PushbackInputStream on the InputStream <code>in</code>.
+ * The size of the pushback buffer is set to <code>size</code>.
+ *
+ * @param in
+ * the InputStream to allow pushback operations on.
+ * @param size
+ * the size of the pushback buffer (<code>size>=0</code>).
+ */
+ public PushbackInputStream(InputStream in, int size) {
+ super(in);
+ if (size > 0) {
+ buf = (in == null) ? null : new byte[size];
+ pos = size;
+ } else {
+ throw new IllegalArgumentException(Msg.getString("K0058")); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Answers a int representing then number of bytes that are available before
+ * this PushbackInputStream will block. This method returns the number of
+ * bytes available in the pushback buffer plus those available in the target
+ * stream.
+ *
+ * @return int the number of bytes available before blocking.
+ *
+ * @throws java.io.IOException
+ * If an error occurs in this stream.
+ */
+ @Override
+ public int available() throws IOException {
+ if (buf != null) {
+ return buf.length - pos + in.available();
+ }
+ throw new IOException();
+ }
+
+ /**
+ * Close this PushbackInputStream. This implementation closes the target
+ * stream.
+ *
+ * @throws IOException
+ * If an error occurs attempting to close this stream.
+ */
+ @Override
+ public void close() throws IOException {
+ if (in != null) {
+ in.close();
+ in = null;
+ buf = null;
+ }
+ }
+
+ /**
+ * Answers a boolean indicating whether or not this PushbackInputStream
+ * supports mark() and reset(). This implementation always answers false
+ * since PushbackInputStreams do not support mark/reset.
+ *
+ * @return boolean indicates whether or not mark() and reset() are
+ * supported.
+ */
+ @Override
+ public boolean markSupported() {
+ return false;
+ }
+
+ /**
+ * Reads a single byte from this PushbackInputStream and returns the result
+ * as an int. The low-order byte is returned or -1 of the end of stream was
+ * encountered. If the pushback buffer does not contain any available bytes
+ * then a byte from the target input stream is returned.
+ *
+ * @return int The byte read or -1 if end of stream.
+ *
+ * @throws IOException
+ * If an IOException occurs.
+ */
+ @Override
+ public int read() throws IOException {
+ if (buf != null) {
+ // Is there a pushback byte available?
+ if (pos < buf.length) {
+ return (buf[pos++] & 0xFF);
+ }
+ // Assume read() in the InputStream will return low-order byte or -1
+ // if end of stream.
+ return in.read();
+ }
+ throw new IOException();
+ }
+
+ /**
+ * Reads at most <code>length</code> bytes from this PushbackInputStream
+ * and stores them in byte array <code>buffer</code> starting at
+ * <code>offset</code>. Answer the number of bytes actually read or -1 if
+ * no bytes were read and end of stream was encountered. This implementation
+ * reads bytes from the pushback buffer first, then the target stream if
+ * more bytes are required to satisfy <code>count</code>.
+ *
+ * @param buffer
+ * the byte array in which to store the read bytes.
+ * @param offset
+ * the offset in <code>buffer</code> to store the read bytes.
+ * @param length
+ * the maximum number of bytes to store in <code>buffer</code>.
+ * @return the number of bytes actually read or -1 if end of stream.
+ *
+ * @throws IOException
+ * If an IOException occurs.
+ */
+ @Override
+ public int read(byte[] buffer, int offset, int length) throws IOException {
+ if (buf != null && buffer != null) {
+ // avoid int overflow
+ if (0 <= offset && offset <= buffer.length && 0 <= length
+ && length <= buffer.length - offset) {
+ int copiedBytes = 0, copyLength = 0, newOffset = offset;
+ // Are there pushback bytes available?
+ if (pos < buf.length) {
+ copyLength = (buf.length - pos >= length) ? length
+ : buf.length - pos;
+ System.arraycopy(buf, pos, buffer, newOffset, copyLength);
+ newOffset += copyLength;
+ copiedBytes += copyLength;
+ // Use up the bytes in the local buffer
+ pos += copyLength;
+ }
+ // Have we copied enough?
+ if (copyLength == length) {
+ return length;
+ }
+ int inCopied = in.read(buffer, newOffset, length - copiedBytes);
+ if (inCopied > 0) {
+ return inCopied + copiedBytes;
+ }
+ if (copiedBytes == 0) {
+ return inCopied;
+ }
+ return copiedBytes;
+ }
+ throw new ArrayIndexOutOfBoundsException();
+ } else if (buf == null) {
+ throw new IOException();
+ }
+ throw new NullPointerException();
+ }
+
+ /**
+ * Skips <code>count</code> number of bytes in this PushbackInputStream.
+ * Subsequent <code>read()</code>'s will not return these bytes unless
+ * <code>reset()</code> is used. This implementation skips
+ * <code>count</code> number of bytes in the buffer and/or the target
+ * stream.
+ *
+ * @param count
+ * the number of bytes to skip.
+ * @return the number of bytes actually skipped.
+ *
+ * @throws IOException
+ * If the stream is already closed or another IOException
+ * occurs.
+ */
+ @Override
+ public long skip(long count) throws IOException {
+ if (in != null) {
+ if (count <= 0) {
+ return 0;
+ }
+ int numSkipped = 0;
+ if (pos < buf.length) {
+ numSkipped += (count < buf.length - pos) ?
+ count : buf.length - pos;
+ pos += numSkipped;
+ }
+ if (numSkipped < count) {
+ numSkipped += in.skip(count - numSkipped);
+ }
+ return numSkipped;
+ }
+ throw new IOException(Msg.getString("K0059")); //$NON-NLS-1$
+ }
+
+ /**
+ * Push back all the bytes in <code>buffer</code>. The bytes are pushed
+ * so that they would be read back buffer[0], buffer[1], etc. If the push
+ * back buffer cannot handle the entire contents of <code>buffer</code>,
+ * an IOException will be thrown. Some of the buffer may already be in the
+ * buffer after the exception is thrown.
+ *
+ * @param buffer
+ * the byte array containing bytes to push back into the stream.
+ *
+ * @throws IOException
+ * If the pushback buffer becomes, or is, full.
+ */
+ public void unread(byte[] buffer) throws IOException {
+ unread(buffer, 0, buffer.length);
+ }
+
+ /**
+ * Push back <code>length</code> number of bytes in <code>buffer</code>
+ * starting at <code>offset</code>. The bytes are pushed so that they
+ * would be read back buffer[offset], buffer[offset+1], etc. If the push
+ * back buffer cannot handle the bytes copied from <code>buffer</code>,
+ * an IOException will be thrown. Some of the bytes may already be in the
+ * buffer after the exception is thrown.
+ *
+ * @param buffer
+ * the byte array containing bytes to push back into the stream.
+ * @param offset
+ * the location to start taking bytes to push back.
+ * @param length
+ * the number of bytes to push back.
+ *
+ * @throws IOException
+ * If the pushback buffer becomes, or is, full.
+ */
+ public void unread(byte[] buffer, int offset, int length)
+ throws IOException {
+ if (length > pos) {
+ // Pushback buffer full
+ throw new IOException(Msg.getString("K007e")); //$NON-NLS-1$
+ }
+ // avoid int overflow
+ if (0 <= offset && offset <= buffer.length && 0 <= length
+ && length <= buffer.length - offset) {
+ for (int i = offset + length - 1; i >= offset; i--) {
+ unread(buffer[i]);
+ }
+ } else {
+ throw new ArrayIndexOutOfBoundsException();
+ }
+ }
+
+ /**
+ * Push back one <code>byte</code>. Takes the byte <code>oneByte</code>
+ * and puts in in the local buffer of bytes to read back before accessing
+ * the target input stream.
+ *
+ * @param oneByte
+ * the byte to push back into the stream.
+ *
+ * @throws IOException
+ * If the pushback buffer is already full.
+ */
+ public void unread(int oneByte) throws IOException {
+ if (buf != null) {
+ if (pos != 0) {
+ buf[--pos] = (byte) oneByte;
+ } else {
+ throw new IOException(Msg.getString("K007e")); //$NON-NLS-1$
+ }
+ } else {
+ throw new IOException();
+ }
+ }
+
+ /**
+ * Make a mark of the current position in the stream but the mark method
+ * does nothing.
+ *
+ * @param readlimit
+ * the maximum number of bytes that are able to be read before
+ * the mark becomes invalid
+ * @override the method mark in FilterInputStream
+ */
+ @Override
+ public void mark(int readlimit) {
+ return;
+ }
+
+ /**
+ * Reset current position to the mark made previously int the stream, but
+ * the reset method will throw IOException and do nothing else if called.
+ *
+ * @override the method reset in FilterInputStream
+ * @throws IOException
+ * If the method is called
+ */
+
+ @Override
+ public void reset() throws IOException {
+ throw new IOException();
+ }
}