harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r428685 - /incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PushbackInputStream.java
Date Fri, 04 Aug 2006 10:26:44 GMT
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();
+    }
 }



Mime
View raw message