001 /* PipedReader.java -- Read portion of piped character streams.
002 Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038 package java.io;
039
040 // NOTE: This implementation is very similar to that of PipedInputStream.
041 // If you fix a bug in here, chances are you should make a similar change to
042 // the PipedInputStream code.
043
044 /**
045 * An input stream that reads characters from a piped writer to which it is
046 * connected.
047 * <p>
048 * Data is read and written to an internal buffer. It is highly recommended
049 * that the <code>PipedReader</code> and connected <code>PipedWriter</code>
050 * be part of different threads. If they are not, there is a possibility
051 * that the read and write operations could deadlock their thread.
052 *
053 * @specnote The JDK implementation appears to have some undocumented
054 * functionality where it keeps track of what thread is writing
055 * to pipe and throws an IOException if that thread susequently
056 * dies. This behaviour seems dubious and unreliable - we don't
057 * implement it.
058 *
059 * @author Aaron M. Renn (arenn@urbanophile.com)
060 */
061 public class PipedReader extends Reader
062 {
063 /** PipedWriter to which this is connected. Null only if this
064 * Reader hasn't been connected yet. */
065 PipedWriter source;
066
067 /** Set to true if close() has been called on this Reader. */
068 boolean closed;
069
070 /**
071 * The size of the internal buffer used for input/output.
072 */
073 static final int PIPE_SIZE = 2048;
074
075 /**
076 * This is the internal circular buffer used for storing chars written
077 * to the pipe and from which chars are read by this stream
078 */
079 char[] buffer = new char[PIPE_SIZE];
080
081 /**
082 * The index into buffer where the next char from the connected
083 * <code>PipedWriter</code> will be written. If this variable is
084 * equal to <code>out</code>, then the buffer is full. If set to < 0,
085 * the buffer is empty.
086 */
087 int in = -1;
088
089 /**
090 * This index into the buffer where chars will be read from.
091 */
092 int out = 0;
093
094 /** Buffer used to implement single-argument read/receive */
095 char[] read_buf = new char[1];
096
097 /**
098 * Creates a new <code>PipedReader</code> that is not connected to a
099 * <code>PipedWriter</code>. It must be connected before chars can
100 * be read from this stream.
101 */
102 public PipedReader()
103 {
104 }
105
106 /**
107 * This constructor creates a new <code>PipedReader</code> and connects
108 * it to the passed in <code>PipedWriter</code>. The stream is then
109 * ready for reading.
110 *
111 * @param source The <code>PipedWriter</code> to connect this stream to
112 *
113 * @exception IOException If <code>source</code> is already connected.
114 */
115 public PipedReader(PipedWriter source) throws IOException
116 {
117 connect(source);
118 }
119
120 /**
121 * This method connects this stream to the passed in
122 * <code>PipedWriter</code>.
123 * This stream is then ready for reading. If this stream is already
124 * connected or has been previously closed, then an exception is thrown
125 *
126 * @param source The <code>PipedWriter</code> to connect this stream to
127 *
128 * @exception IOException If this PipedReader or <code>source</code>
129 * has been connected already.
130 */
131 public void connect(PipedWriter source) throws IOException
132 {
133 // The JDK (1.3) does not appear to check for a previously closed
134 // connection here.
135
136 if (this.source != null || source.sink != null)
137 throw new IOException ("Already connected");
138
139 source.sink = this;
140 this.source = source;
141 }
142
143 /**
144 * This method is used by the connected <code>PipedWriter</code> to
145 * write chars into the buffer.
146 *
147 * @param buf The array containing chars to write to this stream
148 * @param offset The offset into the array to start writing from
149 * @param len The number of chars to write.
150 *
151 * @exception IOException If an error occurs
152 * @specnote This code should be in PipedWriter.write, but we
153 * put it here in order to support that bizarre recieve(int)
154 * method.
155 */
156 void receive(char[] buf, int offset, int len)
157 throws IOException
158 {
159 synchronized (lock)
160 {
161 if (closed)
162 throw new IOException ("Pipe closed");
163
164 int bufpos = offset;
165 int copylen;
166
167 while (len > 0)
168 {
169 try
170 {
171 while (in == out)
172 {
173 // The pipe is full. Wake up any readers and wait for them.
174 lock.notifyAll();
175 lock.wait();
176 // The pipe could have been closed while we were waiting.
177 if (closed)
178 throw new IOException ("Pipe closed");
179 }
180 }
181 catch (InterruptedException ix)
182 {
183 throw new InterruptedIOException ();
184 }
185
186 if (in < 0) // The pipe is empty.
187 in = 0;
188
189 // Figure out how many chars from buf can be copied without
190 // overrunning out or going past the length of the buffer.
191 if (in < out)
192 copylen = Math.min (len, out - in);
193 else
194 copylen = Math.min (len, buffer.length - in);
195
196 // Copy chars until the pipe is filled, wrapping if necessary.
197 System.arraycopy(buf, bufpos, buffer, in, copylen);
198 len -= copylen;
199 bufpos += copylen;
200 in += copylen;
201 if (in == buffer.length)
202 in = 0;
203 }
204 // Notify readers that new data is in the pipe.
205 lock.notifyAll();
206 }
207 }
208
209 /**
210 * This method reads chars from the stream into a caller supplied buffer.
211 * It starts storing chars at position <code>offset</code> into the
212 * buffer and
213 * reads a maximum of <code>len</code> chars. Note that this method
214 * can actually
215 * read fewer than <code>len</code> chars. The actual number of chars
216 * read is
217 * returned. A -1 is returned to indicated that no chars can be read
218 * because the end of the stream was reached. If the stream is already
219 * closed, a -1 will again be returned to indicate the end of the stream.
220 * <p>
221 * This method will block if no char is available to be read.
222 */
223 public int read() throws IOException
224 {
225 // Method operates by calling the multichar overloaded read method
226 // Note that read_buf is an internal instance variable. I allocate it
227 // there to avoid constant reallocation overhead for applications that
228 // call this method in a loop at the cost of some unneeded overhead
229 // if this method is never called.
230
231 int r = read(read_buf, 0, 1);
232 return r != -1 ? read_buf[0] : -1;
233 }
234
235 /**
236 * This method reads characters from the stream into a caller supplied
237 * buffer. It starts storing chars at position <code>offset</code> into
238 * the buffer and reads a maximum of <code>len</code> chars. Note that
239 * this method can actually read fewer than <code>len</code> chars.
240 * The actual number of chars read is
241 * returned. A -1 is returned to indicated that no chars can be read
242 * because the end of the stream was reached - ie close() was called on the
243 * connected PipedWriter.
244 * <p>
245 * This method will block if no chars are available to be read.
246 *
247 * @param buf The buffer into which chars will be stored
248 * @param offset The index into the buffer at which to start writing.
249 * @param len The maximum number of chars to read.
250 *
251 * @exception IOException If <code>close()</code> was called on this Piped
252 * Reader.
253 */
254 public int read(char[] buf, int offset, int len)
255 throws IOException
256 {
257 synchronized (lock)
258 {
259 if (source == null)
260 throw new IOException ("Not connected");
261 if (closed)
262 throw new IOException ("Pipe closed");
263
264 // Don't block if nothing was requested.
265 if (len == 0)
266 return 0;
267
268 // If the buffer is empty, wait until there is something in the pipe
269 // to read.
270 try
271 {
272 while (in < 0)
273 {
274 if (source.closed)
275 return -1;
276 lock.wait();
277 }
278 }
279 catch (InterruptedException ix)
280 {
281 throw new InterruptedIOException();
282 }
283
284 int total = 0;
285 int copylen;
286
287 while (true)
288 {
289 // Figure out how many chars from the pipe can be copied without
290 // overrunning in or going past the length of buf.
291 if (out < in)
292 copylen = Math.min (len, in - out);
293 else
294 copylen = Math.min (len, buffer.length - out);
295
296 System.arraycopy (buffer, out, buf, offset, copylen);
297 offset += copylen;
298 len -= copylen;
299 out += copylen;
300 total += copylen;
301
302 if (out == buffer.length)
303 out = 0;
304
305 if (out == in)
306 {
307 // Pipe is now empty.
308 in = -1;
309 out = 0;
310 }
311
312 // If output buffer is filled or the pipe is empty, we're done.
313 if (len == 0 || in == -1)
314 {
315 // Notify any waiting Writer that there is now space
316 // to write.
317 lock.notifyAll();
318 return total;
319 }
320 }
321 }
322 }
323
324 public boolean ready() throws IOException
325 {
326 // The JDK 1.3 implementation does not appear to check for the closed or
327 // unconnected stream conditions here. However, checking for a
328 // closed stream is explicitly required by the JDK 1.2 and 1.3
329 // documentation (for Reader.close()), so we do it.
330
331 synchronized (lock)
332 {
333 if (closed)
334 throw new IOException("Pipe closed");
335
336 if (in < 0)
337 return false;
338
339 int count;
340 if (out < in)
341 count = in - out;
342 else
343 count = (buffer.length - out) - in;
344
345 return (count > 0);
346 }
347 }
348
349 /**
350 * This methods closes the stream so that no more data can be read
351 * from it.
352 *
353 * @exception IOException If an error occurs
354 */
355 public void close() throws IOException
356 {
357 synchronized (lock)
358 {
359 closed = true;
360 // Wake any thread which may be in receive() waiting to write data.
361 lock.notifyAll();
362 }
363 }
364 }