diff options
Diffstat (limited to 'libjava/classpath/java/io/PipedReader.java')
| -rw-r--r-- | libjava/classpath/java/io/PipedReader.java | 223 |
1 files changed, 111 insertions, 112 deletions
diff --git a/libjava/classpath/java/io/PipedReader.java b/libjava/classpath/java/io/PipedReader.java index 8a3363a..4f449ff 100644 --- a/libjava/classpath/java/io/PipedReader.java +++ b/libjava/classpath/java/io/PipedReader.java @@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. - + GNU Classpath 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 @@ -37,20 +37,20 @@ exception statement from your version. */ package java.io; -// NOTE: This implementation is very similar to that of PipedInputStream. -// If you fix a bug in here, chances are you should make a similar change to +// NOTE: This implementation is very similar to that of PipedInputStream. +// If you fix a bug in here, chances are you should make a similar change to // the PipedInputStream code. /** - * An input stream that reads characters from a piped writer to which it is - * connected. + * An input stream that reads characters from a piped writer to which it is + * connected. * <p> * Data is read and written to an internal buffer. It is highly recommended * that the <code>PipedReader</code> and connected <code>PipedWriter</code> * be part of different threads. If they are not, there is a possibility * that the read and write operations could deadlock their thread. * - * @specnote The JDK implementation appears to have some undocumented + * @specnote The JDK implementation appears to have some undocumented * functionality where it keeps track of what thread is writing * to pipe and throws an IOException if that thread susequently * dies. This behaviour seems dubious and unreliable - we don't @@ -60,7 +60,7 @@ package java.io; */ public class PipedReader extends Reader { - /** PipedWriter to which this is connected. Null only if this + /** PipedWriter to which this is connected. Null only if this * Reader hasn't been connected yet. */ PipedWriter source; @@ -80,7 +80,7 @@ public class PipedReader extends Reader /** * The index into buffer where the next char from the connected - * <code>PipedWriter</code> will be written. If this variable is + * <code>PipedWriter</code> will be written. If this variable is * equal to <code>out</code>, then the buffer is full. If set to < 0, * the buffer is empty. */ @@ -95,8 +95,8 @@ public class PipedReader extends Reader char[] read_buf = new char[1]; /** - * Creates a new <code>PipedReader</code> that is not connected to a - * <code>PipedWriter</code>. It must be connected before chars can + * Creates a new <code>PipedReader</code> that is not connected to a + * <code>PipedWriter</code>. It must be connected before chars can * be read from this stream. */ public PipedReader() @@ -105,7 +105,7 @@ public class PipedReader extends Reader /** * This constructor creates a new <code>PipedReader</code> and connects - * it to the passed in <code>PipedWriter</code>. The stream is then + * it to the passed in <code>PipedWriter</code>. The stream is then * ready for reading. * * @param source The <code>PipedWriter</code> to connect this stream to @@ -118,28 +118,28 @@ public class PipedReader extends Reader } /** - * This method connects this stream to the passed in + * This method connects this stream to the passed in * <code>PipedWriter</code>. * This stream is then ready for reading. If this stream is already * connected or has been previously closed, then an exception is thrown * * @param source The <code>PipedWriter</code> to connect this stream to * - * @exception IOException If this PipedReader or <code>source</code> + * @exception IOException If this PipedReader or <code>source</code> * has been connected already. */ public void connect(PipedWriter source) throws IOException { - // The JDK (1.3) does not appear to check for a previously closed + // The JDK (1.3) does not appear to check for a previously closed // connection here. - + if (this.source != null || source.sink != null) throw new IOException ("Already connected"); - + source.sink = this; this.source = source; } - + /** * This method is used by the connected <code>PipedWriter</code> to * write chars into the buffer. @@ -152,67 +152,67 @@ public class PipedReader extends Reader * @specnote This code should be in PipedWriter.write, but we * put it here in order to support that bizarre recieve(int) * method. - */ + */ void receive(char[] buf, int offset, int len) throws IOException { synchronized (lock) { if (closed) - throw new IOException ("Pipe closed"); + throw new IOException ("Pipe closed"); int bufpos = offset; int copylen; while (len > 0) - { + { try - { - while (in == out) - { - // The pipe is full. Wake up any readers and wait for them. - lock.notifyAll(); - lock.wait(); - // The pipe could have been closed while we were waiting. - if (closed) - throw new IOException ("Pipe closed"); - } - } - catch (InterruptedException ix) - { + { + while (in == out) + { + // The pipe is full. Wake up any readers and wait for them. + lock.notifyAll(); + lock.wait(); + // The pipe could have been closed while we were waiting. + if (closed) + throw new IOException ("Pipe closed"); + } + } + catch (InterruptedException ix) + { throw new InterruptedIOException (); - } - - if (in < 0) // The pipe is empty. - in = 0; - - // Figure out how many chars from buf can be copied without - // overrunning out or going past the length of the buffer. - if (in < out) - copylen = Math.min (len, out - in); - else - copylen = Math.min (len, buffer.length - in); - - // Copy chars until the pipe is filled, wrapping if necessary. - System.arraycopy(buf, bufpos, buffer, in, copylen); - len -= copylen; - bufpos += copylen; - in += copylen; - if (in == buffer.length) - in = 0; - } + } + + if (in < 0) // The pipe is empty. + in = 0; + + // Figure out how many chars from buf can be copied without + // overrunning out or going past the length of the buffer. + if (in < out) + copylen = Math.min (len, out - in); + else + copylen = Math.min (len, buffer.length - in); + + // Copy chars until the pipe is filled, wrapping if necessary. + System.arraycopy(buf, bufpos, buffer, in, copylen); + len -= copylen; + bufpos += copylen; + in += copylen; + if (in == buffer.length) + in = 0; + } // Notify readers that new data is in the pipe. lock.notifyAll(); } } - + /** * This method reads chars from the stream into a caller supplied buffer. - * It starts storing chars at position <code>offset</code> into the + * It starts storing chars at position <code>offset</code> into the * buffer and - * reads a maximum of <code>len</code> chars. Note that this method + * reads a maximum of <code>len</code> chars. Note that this method * can actually - * read fewer than <code>len</code> chars. The actual number of chars + * read fewer than <code>len</code> chars. The actual number of chars * read is * returned. A -1 is returned to indicated that no chars can be read * because the end of the stream was reached. If the stream is already @@ -231,12 +231,12 @@ public class PipedReader extends Reader int r = read(read_buf, 0, 1); return r != -1 ? read_buf[0] : -1; } - + /** - * This method reads characters from the stream into a caller supplied - * buffer. It starts storing chars at position <code>offset</code> into - * the buffer and reads a maximum of <code>len</code> chars. Note that - * this method can actually read fewer than <code>len</code> chars. + * This method reads characters from the stream into a caller supplied + * buffer. It starts storing chars at position <code>offset</code> into + * the buffer and reads a maximum of <code>len</code> chars. Note that + * this method can actually read fewer than <code>len</code> chars. * The actual number of chars read is * returned. A -1 is returned to indicated that no chars can be read * because the end of the stream was reached - ie close() was called on the @@ -250,102 +250,102 @@ public class PipedReader extends Reader * * @exception IOException If <code>close()</code> was called on this Piped * Reader. - */ + */ public int read(char[] buf, int offset, int len) throws IOException { synchronized (lock) { if (source == null) - throw new IOException ("Not connected"); + throw new IOException ("Not connected"); if (closed) - throw new IOException ("Pipe closed"); + throw new IOException ("Pipe closed"); // Don't block if nothing was requested. if (len == 0) return 0; - // If the buffer is empty, wait until there is something in the pipe + // If the buffer is empty, wait until there is something in the pipe // to read. try - { - while (in < 0) - { - if (source.closed) - return -1; - lock.wait(); - } - } + { + while (in < 0) + { + if (source.closed) + return -1; + lock.wait(); + } + } catch (InterruptedException ix) - { + { throw new InterruptedIOException(); - } + } int total = 0; int copylen; while (true) - { - // Figure out how many chars from the pipe can be copied without - // overrunning in or going past the length of buf. - if (out < in) - copylen = Math.min (len, in - out); - else - copylen = Math.min (len, buffer.length - out); + { + // Figure out how many chars from the pipe can be copied without + // overrunning in or going past the length of buf. + if (out < in) + copylen = Math.min (len, in - out); + else + copylen = Math.min (len, buffer.length - out); System.arraycopy (buffer, out, buf, offset, copylen); - offset += copylen; - len -= copylen; - out += copylen; - total += copylen; + offset += copylen; + len -= copylen; + out += copylen; + total += copylen; - if (out == buffer.length) - out = 0; + if (out == buffer.length) + out = 0; - if (out == in) - { - // Pipe is now empty. - in = -1; - out = 0; - } + if (out == in) + { + // Pipe is now empty. + in = -1; + out = 0; + } // If output buffer is filled or the pipe is empty, we're done. - if (len == 0 || in == -1) - { - // Notify any waiting Writer that there is now space - // to write. - lock.notifyAll(); - return total; - } - } + if (len == 0 || in == -1) + { + // Notify any waiting Writer that there is now space + // to write. + lock.notifyAll(); + return total; + } + } } } - + public boolean ready() throws IOException { - // The JDK 1.3 implementation does not appear to check for the closed or + // The JDK 1.3 implementation does not appear to check for the closed or // unconnected stream conditions here. However, checking for a // closed stream is explicitly required by the JDK 1.2 and 1.3 // documentation (for Reader.close()), so we do it. - + synchronized (lock) { if (closed) - throw new IOException("Pipe closed"); + throw new IOException("Pipe closed"); if (in < 0) - return false; + return false; int count; if (out < in) - count = in - out; + count = in - out; else - count = (buffer.length - out) - in; + count = (buffer.length - out) - in; return (count > 0); } } - + /** * This methods closes the stream so that no more data can be read * from it. @@ -362,4 +362,3 @@ public class PipedReader extends Reader } } } - |