Fix for PR java.io/204:
* java/io/PipedInputStream.java, java/io/PipedReader.java, java/io/PipedOutputStream.java, java/io/PipedWriter.java: Imported from Classpath. From-SVN: r33300
This commit is contained in:
Tom Tromey
Tom Tromey
parent
21caf59006
commit
d3474943bf
5 changed files with 1433 additions and 570 deletions
|
|
@ -1,210 +1,519 @@
|
|||
// PipedReader.java - Piped character stream.
|
||||
/* PipedReader.java -- Input stream that reads from an output stream
|
||||
Copyright (C) 1998, 1999 Free Software Foundation, Inc.
|
||||
|
||||
/* Copyright (C) 1998, 1999 Free Software Foundation
|
||||
This file is part of GNU Classpath.
|
||||
|
||||
This file is part of libgcj.
|
||||
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
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; see the file COPYING. If not, write to the
|
||||
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA.
|
||||
|
||||
As a special exception, if you link this library with other files to
|
||||
produce an executable, this library does not by itself cause the
|
||||
resulting executable to be covered by the GNU General Public License.
|
||||
This exception does not however invalidate any other reasons why the
|
||||
executable file might be covered by the GNU General Public License. */
|
||||
|
||||
This software is copyrighted work licensed under the terms of the
|
||||
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
||||
details. */
|
||||
|
||||
package java.io;
|
||||
|
||||
/**
|
||||
* @author Tom Tromey <tromey@cygnus.com>
|
||||
* @date September 25, 1998
|
||||
*/
|
||||
|
||||
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
|
||||
* "The Java Language Specification", ISBN 0-201-63451-1
|
||||
* Status: Complete to 1.1.
|
||||
*/
|
||||
|
||||
* This class is an input stream that reads its chars from an output stream
|
||||
* 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.
|
||||
*
|
||||
* @version 0.0
|
||||
*
|
||||
* @author Aaron M. Renn (arenn@urbanophile.com)
|
||||
*/
|
||||
public class PipedReader extends Reader
|
||||
{
|
||||
public void close () throws IOException
|
||||
{
|
||||
closed = true;
|
||||
}
|
||||
|
||||
public void connect (PipedWriter src) throws IOException
|
||||
{
|
||||
if (closed)
|
||||
throw new IOException ("already closed");
|
||||
if (writer != null)
|
||||
{
|
||||
if (writer == src)
|
||||
return;
|
||||
throw new IOException ("already connected");
|
||||
}
|
||||
try
|
||||
{
|
||||
writer = src;
|
||||
writer.connect(this);
|
||||
}
|
||||
catch (IOException e)
|
||||
{
|
||||
writer = null;
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
/*************************************************************************/
|
||||
|
||||
public PipedReader ()
|
||||
{
|
||||
super ();
|
||||
writer = null;
|
||||
closed = false;
|
||||
in = -1;
|
||||
out = 0;
|
||||
pipeBuffer = new char[1024];
|
||||
}
|
||||
/*
|
||||
* Class Variables
|
||||
*/
|
||||
|
||||
public PipedReader (PipedWriter src) throws IOException
|
||||
{
|
||||
super ();
|
||||
closed = false;
|
||||
in = -1;
|
||||
out = 0;
|
||||
pipeBuffer = new char[1024];
|
||||
connect (src);
|
||||
}
|
||||
/**
|
||||
* The size of the internal buffer used for input/output. Note that this
|
||||
* can be overriden by setting the system property
|
||||
* <code>gnu.java.io.PipedReader.pipe_size</code> to the desired size shown
|
||||
* in chars. This is not a standard part of the class library. Note that
|
||||
* since this variable is <code>final</code>, it cannot be changed to refect
|
||||
* the size specified in the property.
|
||||
* <p>
|
||||
* The value for this variable is 2048.
|
||||
*/
|
||||
private static final int PIPE_SIZE = 2048;
|
||||
|
||||
public int read (char buf[], int offset, int count) throws IOException
|
||||
{
|
||||
if (closed)
|
||||
throw new IOException ("closed");
|
||||
if (count < 0)
|
||||
throw new ArrayIndexOutOfBoundsException ();
|
||||
int toCopy = count;
|
||||
synchronized (lock)
|
||||
{
|
||||
while (toCopy > 0)
|
||||
{
|
||||
// Wait for data in the pipe. If the writer is closed and
|
||||
// no data has been copied into the output buffer, return
|
||||
// the magic EOF number.
|
||||
while (in == -1)
|
||||
{
|
||||
if (writer.isClosed())
|
||||
{
|
||||
if (toCopy < count)
|
||||
return count - toCopy;
|
||||
return -1;
|
||||
}
|
||||
/**
|
||||
* This is the real pipe size. It defaults to PIPE_SIZE, unless overridden
|
||||
* by use of the system property <code>gnu.java.io.PipedReader.pipe_size</code>.
|
||||
*/
|
||||
private static int pipe_size;
|
||||
|
||||
// Note that JCL doesn't say this is the right thing
|
||||
// to do. Still, it feels right, and we must deal
|
||||
// with an interrupt somehow.
|
||||
try
|
||||
{
|
||||
lock.wait();
|
||||
}
|
||||
catch (InterruptedException e)
|
||||
{
|
||||
InterruptedIOException io
|
||||
= new InterruptedIOException (e.getMessage());
|
||||
io.bytesTransferred = count - toCopy;
|
||||
throw io;
|
||||
}
|
||||
}
|
||||
// Now copy some data from pipe into user buffer.
|
||||
int len;
|
||||
if (in < out)
|
||||
len = pipeBuffer.length - out;
|
||||
else
|
||||
len = in - out;
|
||||
len = len > toCopy ? toCopy : len;
|
||||
System.arraycopy(pipeBuffer, out, buf, offset, len);
|
||||
out += len;
|
||||
if (out == pipeBuffer.length)
|
||||
out = 0;
|
||||
toCopy -= len;
|
||||
offset += len;
|
||||
// If we've read all the data, then reset so that we know
|
||||
// there is nothing left to be read.
|
||||
if (in == out)
|
||||
in = -1;
|
||||
// Tell anybody waiting for space in the buffer.
|
||||
lock.notifyAll();
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
/**
|
||||
* This variable indicates whether or not the <code>read()</code> method will attempt
|
||||
* return a short count if this will possibly keep the stream from blocking.
|
||||
* The default for this is <code>false</code> because that is what what the JDK seems
|
||||
* to imply in its javadocs. We set this to <code>false</code> if the system
|
||||
* property <code>gnu.java.io.try_not_to_block</code> is set.
|
||||
*/
|
||||
private static boolean try_not_to_block = false;
|
||||
|
||||
void receive (char buf[], int offset, int count) throws IOException
|
||||
{
|
||||
if (count < 0)
|
||||
throw new ArrayIndexOutOfBoundsException ();
|
||||
int original = count;
|
||||
synchronized (lock)
|
||||
{
|
||||
while (count > 0)
|
||||
{
|
||||
// Wait until there is some space in the buffer.
|
||||
while (in == out)
|
||||
{
|
||||
try
|
||||
{
|
||||
lock.wait();
|
||||
}
|
||||
catch (InterruptedException e)
|
||||
{
|
||||
// Turn interrupts into IO interrupts.
|
||||
InterruptedIOException io
|
||||
= new InterruptedIOException (e.getMessage());
|
||||
io.bytesTransferred = original - count;
|
||||
throw io;
|
||||
}
|
||||
}
|
||||
static
|
||||
{
|
||||
pipe_size = Integer.getInteger("gnu.java.io.PipedReader.pipe_size",
|
||||
PIPE_SIZE).intValue();
|
||||
|
||||
// Compute destination in the pipe.
|
||||
int base, len;
|
||||
if (in == -1)
|
||||
{
|
||||
base = 0;
|
||||
len = pipeBuffer.length;
|
||||
}
|
||||
else if (in < out)
|
||||
{
|
||||
base = in;
|
||||
len = out - in;
|
||||
}
|
||||
else
|
||||
{
|
||||
base = in;
|
||||
len = pipeBuffer.length - in;
|
||||
}
|
||||
int copyLen = len > count ? count : len;
|
||||
// Copy data and update local state.
|
||||
System.arraycopy(buf, offset, pipeBuffer, base, copyLen);
|
||||
in = base + copyLen;
|
||||
if (in == pipeBuffer.length)
|
||||
in = 0;
|
||||
count -= copyLen;
|
||||
offset += copyLen;
|
||||
// Tell anybody waiting for data.
|
||||
lock.notifyAll();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
boolean isClosed ()
|
||||
{
|
||||
return closed;
|
||||
}
|
||||
|
||||
// The associated writer.
|
||||
private PipedWriter writer;
|
||||
// True if this reader has been closed.
|
||||
boolean closed;
|
||||
|
||||
// Index of next character to overwrite when receive() is called.
|
||||
// If -1, then that means the buffer is empty.
|
||||
private int in;
|
||||
// Index of next character to return from read().
|
||||
private int out;
|
||||
|
||||
// The pipe buffer itself.
|
||||
private char[] pipeBuffer;
|
||||
String block_prop = System.getProperty("gnu.java.io.try_not_to_block");
|
||||
if (block_prop != null)
|
||||
try_not_to_block = true;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/*
|
||||
* Instance Variables
|
||||
*/
|
||||
|
||||
/**
|
||||
* This is the internal circular buffer used for storing chars written
|
||||
* to the pipe and from which chars are read by this stream
|
||||
*/
|
||||
private char[] buffer = new char[pipe_size];
|
||||
|
||||
/**
|
||||
* The index into buffer where the chars written char the connected
|
||||
* <code>PipedWriter</code> will be written. If this variables is less
|
||||
* than 0, then the buffer is empty. If this variable is equal to
|
||||
* <code>out</code>, then the buffer is full
|
||||
*/
|
||||
private int in = -1;
|
||||
|
||||
/**
|
||||
* This index into the buffer where chars will be read from.
|
||||
*/
|
||||
private int out = 0;
|
||||
|
||||
/**
|
||||
* This variable is <code>true</code> if this object has ever been connected
|
||||
* to a <code>PipedWriter</code>, and <code>false</code> otherwise. It is used
|
||||
* to detect an attempt to connect an already connected stream or to
|
||||
* otherwise use the stream before it is connected.
|
||||
*/
|
||||
private boolean ever_connected = false;
|
||||
|
||||
/**
|
||||
* This variable is set to <code>true</code> if the <code>close()</code> method is
|
||||
* called. This value is checked prevents a caller from re-opening the
|
||||
* stream.
|
||||
*/
|
||||
private boolean closed = false;
|
||||
|
||||
/**
|
||||
* This variable is the PipedWriter to which this stream is connected.
|
||||
*/
|
||||
PipedWriter src;
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/*
|
||||
* Constructors
|
||||
*/
|
||||
|
||||
/**
|
||||
* This constructor 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()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This constructor creates a new <code>PipedReader</code> and connects
|
||||
* it to the passed in <code>PipedWriter</code>. The stream is then read
|
||||
* for reading.
|
||||
*
|
||||
* @param src The <code>PipedWriter</code> to connect this stream to
|
||||
*
|
||||
* @exception IOException If an error occurs
|
||||
*/
|
||||
public
|
||||
PipedReader(PipedWriter src) throws IOException
|
||||
{
|
||||
connect(src);
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/*
|
||||
* Instance Variables
|
||||
*/
|
||||
|
||||
/**
|
||||
* 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 src The <code>PipedWriter</code> to connect this stream to
|
||||
*
|
||||
* @exception IOException If an error occurs
|
||||
*/
|
||||
public void
|
||||
connect(PipedWriter src) throws IOException
|
||||
{
|
||||
if (src == this.src)
|
||||
return;
|
||||
|
||||
if (ever_connected)
|
||||
throw new IOException("Already connected");
|
||||
|
||||
if (closed)
|
||||
throw new IOException("Stream is closed and cannot be reopened");
|
||||
|
||||
synchronized (lock) {
|
||||
|
||||
src.connect(this);
|
||||
|
||||
ever_connected = true;
|
||||
|
||||
} // synchronized
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This methods closes the stream so that no more data can be read
|
||||
* from it.
|
||||
*
|
||||
* @exception IOException If an error occurs
|
||||
*/
|
||||
public void
|
||||
close() throws IOException
|
||||
{
|
||||
synchronized (lock) {
|
||||
|
||||
closed = true;
|
||||
notifyAll();
|
||||
|
||||
} // synchronized
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This method determines whether or not this stream is ready to be read.
|
||||
* If this metho returns <code>false</code> an attempt to read may (but is
|
||||
* not guaranteed to) block.
|
||||
*
|
||||
* @return <code>true</code> if this stream is ready to be read, <code>false</code> otherwise
|
||||
*
|
||||
* @exception IOException If an error occurs
|
||||
*/
|
||||
public boolean
|
||||
ready() throws IOException
|
||||
{
|
||||
if (in == -1)
|
||||
return(false);
|
||||
|
||||
if (out == (in - 1))
|
||||
return(false);
|
||||
|
||||
if ((out == pipe_size) && (in == 0))
|
||||
return(false);
|
||||
|
||||
return(true);
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This method reads a single char from the pipe and returns it as an
|
||||
* <code>int</code>.
|
||||
* <p>
|
||||
* This method will block if no chars are available to be read.
|
||||
*
|
||||
* @return An char read from the pipe, or -1 if the end of stream is
|
||||
* reached.
|
||||
*
|
||||
* @exception IOException If an error occurs.
|
||||
*/
|
||||
public int
|
||||
read() throws IOException
|
||||
{
|
||||
char[] buf = new char[1];
|
||||
|
||||
return(read(buf, 0, buf.length));
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This method reads chars 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 <cod>>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. If the stream is already
|
||||
* closed, a -1 will again be returned to indicate the end of the stream.
|
||||
* <p>
|
||||
* This method will block if no chars are available to be read.
|
||||
*
|
||||
* @param buf The buffer into which chars will be stored
|
||||
* @param offset The index into the buffer at which to start writing.
|
||||
* @param len The maximum number of chars to read.
|
||||
*/
|
||||
public int
|
||||
read(char[] buf, int offset, int len) throws IOException
|
||||
{
|
||||
if (!ever_connected)
|
||||
throw new IOException("Not connected");
|
||||
|
||||
synchronized (lock) {
|
||||
|
||||
int chars_read = 0;
|
||||
for (;;)
|
||||
{
|
||||
// If there are chars, take them
|
||||
if (in != -1)
|
||||
{
|
||||
int desired_chars = len - chars_read;
|
||||
|
||||
// We are in a "wrap" condition
|
||||
if (out > in)
|
||||
{
|
||||
if (desired_chars > (pipe_size - out))
|
||||
{
|
||||
if (in == 0)
|
||||
desired_chars = (pipe_size - out) - 1;
|
||||
else
|
||||
desired_chars = pipe_size - out;
|
||||
|
||||
System.arraycopy(buffer, out, buf, offset + chars_read,
|
||||
desired_chars);
|
||||
|
||||
chars_read += desired_chars;
|
||||
out += desired_chars;
|
||||
desired_chars = len - chars_read;
|
||||
|
||||
if (out == pipe_size)
|
||||
out = 0;
|
||||
|
||||
notifyAll();
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((out + desired_chars) == in)
|
||||
--desired_chars;
|
||||
|
||||
if (((out + desired_chars) == pipe_size) && (in == 0))
|
||||
desired_chars = (pipe_size - out) - 1;
|
||||
|
||||
System.arraycopy(buffer, out, buf, offset + chars_read,
|
||||
desired_chars);
|
||||
|
||||
chars_read += desired_chars;
|
||||
out += desired_chars;
|
||||
desired_chars = len - chars_read;
|
||||
|
||||
if (out == pipe_size)
|
||||
out = 0;
|
||||
|
||||
notifyAll();
|
||||
}
|
||||
}
|
||||
|
||||
// We are in a "no wrap" or condition (can also be fall through
|
||||
// from above
|
||||
if (in > out)
|
||||
{
|
||||
if (desired_chars >= ((in - out) - 1))
|
||||
desired_chars = (in - out) - 1;
|
||||
|
||||
System.arraycopy(buffer, out, buf, offset + chars_read,
|
||||
desired_chars);
|
||||
|
||||
chars_read += desired_chars;
|
||||
out += desired_chars;
|
||||
desired_chars = len - chars_read;
|
||||
|
||||
if (out == pipe_size)
|
||||
out = 0;
|
||||
|
||||
notifyAll();
|
||||
}
|
||||
}
|
||||
|
||||
// If we are done, return
|
||||
if (chars_read == len)
|
||||
return(chars_read);
|
||||
|
||||
// Return a short count if necessary
|
||||
if (chars_read < len)
|
||||
if (try_not_to_block)
|
||||
return(chars_read);
|
||||
|
||||
// Handle the case where the end of stream was encountered.
|
||||
if (closed)
|
||||
{
|
||||
// We never let in == out so there might be one last char
|
||||
// available that we have not copied yet.
|
||||
if (in != -1)
|
||||
{
|
||||
buf[offset + chars_read] = buffer[out];
|
||||
in = -1;
|
||||
++out;
|
||||
++chars_read;
|
||||
}
|
||||
|
||||
if (chars_read != 0)
|
||||
return(chars_read);
|
||||
else
|
||||
return(-1);
|
||||
}
|
||||
|
||||
// Wait for a char to be read
|
||||
try
|
||||
{
|
||||
wait();
|
||||
}
|
||||
catch(InterruptedException e) { ; }
|
||||
}
|
||||
|
||||
} // synchronized
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/**
|
||||
* This method is used by the connected <code>PipedWriter</code> to
|
||||
* write chars into the buffer. It uses this method instead of directly
|
||||
* writing the chars in order to obtain ownership of the object's monitor
|
||||
* for the purposes of calling <code>notify</code>.
|
||||
*
|
||||
* @param buf The array containing chars to write to this stream
|
||||
* @param offset The offset into the array to start writing from
|
||||
* @param len The number of chars to write.
|
||||
*
|
||||
* @exception IOException If an error occurs
|
||||
*/
|
||||
void
|
||||
write(char[] buf, int offset, int len) throws IOException
|
||||
{
|
||||
if (len <= 0)
|
||||
return;
|
||||
|
||||
synchronized (lock) {
|
||||
|
||||
int total_written = 0;
|
||||
while (total_written < len)
|
||||
{
|
||||
// If we are not at the end of the buffer with out = 0
|
||||
if (!((in == (buffer.length - 1)) && (out == 0)))
|
||||
{
|
||||
// This is the "no wrap" situation
|
||||
if ((in - 1) >= out)
|
||||
{
|
||||
int chars_written = 0;
|
||||
if ((buffer.length - in) > (len - total_written))
|
||||
chars_written = (len - total_written);
|
||||
else if (out == 0)
|
||||
chars_written = (buffer.length - in) - 1;
|
||||
else
|
||||
chars_written = (buffer.length - in);
|
||||
|
||||
if (chars_written > 0)
|
||||
System.arraycopy(buf, offset + total_written, buffer, in,
|
||||
chars_written);
|
||||
total_written += chars_written;
|
||||
in += chars_written;
|
||||
|
||||
if (in == buffer.length)
|
||||
in = 0;
|
||||
|
||||
notifyAll();
|
||||
}
|
||||
// This is the "wrap" situtation
|
||||
if ((out > in) && (total_written != len))
|
||||
{
|
||||
int chars_written = 0;
|
||||
|
||||
// Do special processing if we are at the beginning
|
||||
if (in == -1)
|
||||
{
|
||||
in = 0;
|
||||
|
||||
if (buffer.length > len)
|
||||
chars_written = len;
|
||||
else
|
||||
chars_written = buffer.length - 1;
|
||||
}
|
||||
else if (((out - in) - 1) < (len - total_written))
|
||||
{
|
||||
chars_written = (out - in) - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
chars_written = len - total_written;
|
||||
}
|
||||
|
||||
// If the buffer is full, wait for it to empty out
|
||||
if ((out - 1) == in)
|
||||
{
|
||||
try
|
||||
{
|
||||
wait();
|
||||
}
|
||||
catch (InterruptedException e)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
System.arraycopy(buf, offset + total_written, buffer, in,
|
||||
chars_written);
|
||||
total_written += chars_written;
|
||||
in += chars_written;
|
||||
|
||||
if (in == buffer.length)
|
||||
in = 0;
|
||||
|
||||
notifyAll();
|
||||
}
|
||||
}
|
||||
// Wait for some reads to occur before we write anything.
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
wait();
|
||||
}
|
||||
catch (InterruptedException e) { ; }
|
||||
}
|
||||
}
|
||||
} // synchronized
|
||||
}
|
||||
|
||||
} // class PipedReader
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue