I'm checking this in.
This implements a missing java.nio method.
It also fixes a systematic bug in the 'compact' methods, and adds the
appropriate locking to ChannelReader.
Tom
2006-05-01 Tom Tromey <[EMAIL PROTECTED]>
* java/nio/ByteBufferImpl.java (compact): Don't reset position
in empty case.
* gnu/java/nio/ChannelReader.java (read): Synchronize.
(close): Synchronize.
* java/nio/ShortBufferImpl.java (compact): Rewrote.
* java/nio/LongBufferImpl.java (compact): Rewrote.
* java/nio/IntBufferImpl.java (compact): Rewrote.
* java/nio/FloatBufferImpl.java (compact): Rewrote.
* java/nio/DoubleBufferImpl.java (compact): Rewrote.
* java/nio/CharBufferImpl.java (compact): Rewrote.
* gnu/java/nio/ChannelWriter.java: New file.
* java/nio/channels/Channels.java (newWriter): Implemented.
Index: gnu/java/nio/ChannelReader.java
===================================================================
RCS file: /cvsroot/classpath/classpath/gnu/java/nio/ChannelReader.java,v
retrieving revision 1.3
diff -u -r1.3 ChannelReader.java
--- gnu/java/nio/ChannelReader.java 2 Jul 2005 20:32:13 -0000 1.3
+++ gnu/java/nio/ChannelReader.java 1 May 2006 22:39:53 -0000
@@ -92,120 +92,126 @@
public int read(char[] buf, int offset, int count) throws IOException
{
- // I declared channel being null meaning that the reader is closed.
- if (!channel.isOpen())
- throw new IOException("Reader was already closed.");
-
- // I declared decoder being null meaning that there is no more data to read
- // and convert.
- if (decoder == null)
- return -1;
-
- // Stores the amount of character being read. It -1 so that if no
conversion
- // occured the caller will see this as an 'end of file'.
- int sum = -1;
-
- // Copies any characters which may be left from the last invocation into
the
- // destination array.
- if (charBuffer.remaining() > 0)
- {
- sum = Math.min(count, charBuffer.remaining());
- charBuffer.get(buf, offset, sum);
-
- // Updates the control variables according to the latest copy
operation.
- offset += sum;
- count -= sum;
- }
-
- // Copies the character which have not been put in the destination array to
- // the beginning. If data is actually copied count will be 0. If no data is
- // copied count is >0 and we can now convert some more characters.
- charBuffer.compact();
-
- int converted = 0;
- boolean last = false;
-
- while (count != 0)
+ synchronized (lock)
{
- // Tries to convert some bytes (Which will intentionally fail in the
- // first place because we have not read any bytes yet.)
- CoderResult result = decoder.decode(byteBuffer, charBuffer, last);
- if (result.isMalformed() || result.isUnmappable())
- {
- // JDK throws exception when bytes are malformed for sure.
- // FIXME: Unsure what happens when a character is simply
- // unmappable.
- result.throwException();
- }
-
- // Marks that we should end this loop regardless whether the caller
- // wants more chars or not, when this was the last conversion.
- if (last)
+ // I declared channel being null meaning that the reader is closed.
+ if (!channel.isOpen())
+ throw new IOException("Reader was already closed.");
+
+ // I declared decoder being null meaning that there is no more data to
read
+ // and convert.
+ if (decoder == null)
+ return -1;
+
+ // Stores the amount of character being read. It -1 so that if no
conversion
+ // occured the caller will see this as an 'end of file'.
+ int sum = -1;
+
+ // Copies any characters which may be left from the last invocation
into the
+ // destination array.
+ if (charBuffer.remaining() > 0)
{
- decoder = null;
+ sum = Math.min(count, charBuffer.remaining());
+ charBuffer.get(buf, offset, sum);
+
+ // Updates the control variables according to the latest copy
operation.
+ offset += sum;
+ count -= sum;
}
- else if (result.isUnderflow())
+
+ // Copies the character which have not been put in the destination
array to
+ // the beginning. If data is actually copied count will be 0. If no
data is
+ // copied count is >0 and we can now convert some more characters.
+ charBuffer.compact();
+
+ int converted = 0;
+ boolean last = false;
+
+ while (count != 0)
{
- // We need more bytes to do the conversion.
-
- // Copies the not yet converted bytes to the beginning making it
- // being able to receive more bytes.
- byteBuffer.compact();
-
- // Reads in another bunch of bytes for being converted.
- if (channel.read(byteBuffer) == -1)
+ // Tries to convert some bytes (Which will intentionally fail in
the
+ // first place because we have not read any bytes yet.)
+ CoderResult result = decoder.decode(byteBuffer, charBuffer, last);
+ if (result.isMalformed() || result.isUnmappable())
{
- // If there is no more data available in the channel we mark
- // that state for the final character conversion run which is
- // done in the next loop iteration.
- last = true;
+ // JDK throws exception when bytes are malformed for sure.
+ // FIXME: Unsure what happens when a character is simply
+ // unmappable.
+ result.throwException();
}
-
- // Prepares the byteBuffer for the next character conversion run.
- byteBuffer.flip();
+
+ // Marks that we should end this loop regardless whether the caller
+ // wants more chars or not, when this was the last conversion.
+ if (last)
+ {
+ decoder = null;
+ }
+ else if (result.isUnderflow())
+ {
+ // We need more bytes to do the conversion.
+
+ // Copies the not yet converted bytes to the beginning making
it
+ // being able to receive more bytes.
+ byteBuffer.compact();
+
+ // Reads in another bunch of bytes for being converted.
+ if (channel.read(byteBuffer) == -1)
+ {
+ // If there is no more data available in the channel we
mark
+ // that state for the final character conversion run which
is
+ // done in the next loop iteration.
+ last = true;
+ }
+
+ // Prepares the byteBuffer for the next character conversion
run.
+ byteBuffer.flip();
+ }
+
+ // Prepares the charBuffer for being drained.
+ charBuffer.flip();
+
+ converted = Math.min(count, charBuffer.remaining());
+ charBuffer.get(buf, offset, converted);
+
+ // Copies characters which have not yet being copied into the
char-Array
+ // to the beginning making it possible to read them later (If data
is
+ // really copied here, then the caller has received enough
characters so
+ // far.).
+ charBuffer.compact();
+
+ // Updates the control variables according to the latest copy
operation.
+ offset += converted;
+ count -= converted;
+
+ // Updates the amount of transferred characters.
+ sum += converted;
+
+ if (decoder == null)
+ {
+ break;
+ }
+
+ // Now that more characters have been transfered we let the loop
decide
+ // what to do next.
}
-
- // Prepares the charBuffer for being drained.
+
+ // Makes the charBuffer ready for reading on the next invocation.
charBuffer.flip();
-
- converted = Math.min(count, charBuffer.remaining());
- charBuffer.get(buf, offset, converted);
-
- // Copies characters which have not yet being copied into the
char-Array
- // to the beginning making it possible to read them later (If data is
- // really copied here, then the caller has received enough characters
so
- // far.).
- charBuffer.compact();
-
- // Updates the control variables according to the latest copy
operation.
- offset += converted;
- count -= converted;
-
- // Updates the amount of transferred characters.
- sum += converted;
-
- if (decoder == null)
- {
- break;
- }
-
- // Now that more characters have been transfered we let the loop decide
- // what to do next.
+
+ return sum;
}
-
- // Makes the charBuffer ready for reading on the next invocation.
- charBuffer.flip();
-
- return sum;
}
public void close() throws IOException
{
- channel.close();
+ synchronized (lock)
+ {
+ channel.close();
- // Makes sure all intermediate data is released by the decoder.
- if (decoder != null)
- decoder.reset();
+ // Makes sure all intermediate data is released by the decoder.
+ if (decoder != null)
+ decoder.reset();
+ }
}
}
Index: java/nio/ByteBufferImpl.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/nio/ByteBufferImpl.java,v
retrieving revision 1.13
diff -u -r1.13 ByteBufferImpl.java
--- java/nio/ByteBufferImpl.java 2 Jul 2005 20:32:39 -0000 1.13
+++ java/nio/ByteBufferImpl.java 1 May 2006 22:39:54 -0000
@@ -120,13 +120,8 @@
int count = remaining();
shiftDown(0, pos, count);
position(count);
- limit(capacity());
- }
- else
- {
- position(limit());
- limit(capacity());
}
+ limit(capacity());
return this;
}
Index: java/nio/CharBufferImpl.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/nio/CharBufferImpl.java,v
retrieving revision 1.10
diff -u -r1.10 CharBufferImpl.java
--- java/nio/CharBufferImpl.java 2 Jul 2005 20:32:39 -0000 1.10
+++ java/nio/CharBufferImpl.java 1 May 2006 22:39:54 -0000
@@ -90,15 +90,14 @@
{
checkIfReadOnly();
mark = -1;
- int copied = 0;
-
- while (remaining () > 0)
+ int p = position();
+ int n = limit() - p;
+ if (n > 0)
{
- put (copied, get ());
- copied++;
+ System.arraycopy(backing_buffer, array_offset + p,
+ backing_buffer, array_offset, n);
}
-
- position (copied);
+ position(n);
limit(capacity());
return this;
}
Index: java/nio/DoubleBufferImpl.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/nio/DoubleBufferImpl.java,v
retrieving revision 1.9
diff -u -r1.9 DoubleBufferImpl.java
--- java/nio/DoubleBufferImpl.java 2 Jul 2005 20:32:39 -0000 1.9
+++ java/nio/DoubleBufferImpl.java 1 May 2006 22:39:54 -0000
@@ -82,15 +82,14 @@
{
checkIfReadOnly();
mark = -1;
- int copied = 0;
-
- while (remaining () > 0)
+ int p = position();
+ int n = limit() - p;
+ if (n > 0)
{
- put (copied, get ());
- copied++;
+ System.arraycopy(backing_buffer, array_offset + p,
+ backing_buffer, array_offset, n);
}
-
- position (copied);
+ position(n);
limit(capacity());
return this;
}
Index: java/nio/FloatBufferImpl.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/nio/FloatBufferImpl.java,v
retrieving revision 1.9
diff -u -r1.9 FloatBufferImpl.java
--- java/nio/FloatBufferImpl.java 2 Jul 2005 20:32:39 -0000 1.9
+++ java/nio/FloatBufferImpl.java 1 May 2006 22:39:54 -0000
@@ -82,15 +82,14 @@
{
checkIfReadOnly();
mark = -1;
- int copied = 0;
-
- while (remaining () > 0)
+ int p = position();
+ int n = limit() - p;
+ if (n > 0)
{
- put (copied, get ());
- copied++;
+ System.arraycopy(backing_buffer, array_offset + p,
+ backing_buffer, array_offset, n);
}
-
- position (copied);
+ position(n);
limit(capacity());
return this;
}
Index: java/nio/IntBufferImpl.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/nio/IntBufferImpl.java,v
retrieving revision 1.9
diff -u -r1.9 IntBufferImpl.java
--- java/nio/IntBufferImpl.java 2 Jul 2005 20:32:39 -0000 1.9
+++ java/nio/IntBufferImpl.java 1 May 2006 22:39:54 -0000
@@ -82,15 +82,14 @@
{
checkIfReadOnly();
mark = -1;
- int copied = 0;
-
- while (remaining () > 0)
+ int p = position();
+ int n = limit() - p;
+ if (n > 0)
{
- put (copied, get ());
- copied++;
+ System.arraycopy(backing_buffer, array_offset + p,
+ backing_buffer, array_offset, n);
}
-
- position (copied);
+ position(n);
limit(capacity());
return this;
}
Index: java/nio/LongBufferImpl.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/nio/LongBufferImpl.java,v
retrieving revision 1.9
diff -u -r1.9 LongBufferImpl.java
--- java/nio/LongBufferImpl.java 2 Jul 2005 20:32:39 -0000 1.9
+++ java/nio/LongBufferImpl.java 1 May 2006 22:39:54 -0000
@@ -82,15 +82,14 @@
{
checkIfReadOnly();
mark = -1;
- int copied = 0;
-
- while (remaining () > 0)
+ int p = position();
+ int n = limit() - p;
+ if (n > 0)
{
- put (copied, get ());
- copied++;
+ System.arraycopy(backing_buffer, array_offset + p,
+ backing_buffer, array_offset, n);
}
-
- position (copied);
+ position(n);
limit(capacity());
return this;
}
Index: java/nio/ShortBufferImpl.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/nio/ShortBufferImpl.java,v
retrieving revision 1.9
diff -u -r1.9 ShortBufferImpl.java
--- java/nio/ShortBufferImpl.java 2 Jul 2005 20:32:39 -0000 1.9
+++ java/nio/ShortBufferImpl.java 1 May 2006 22:39:54 -0000
@@ -82,15 +82,14 @@
{
checkIfReadOnly();
mark = -1;
- int copied = 0;
-
- while (remaining () > 0)
+ int p = position();
+ int n = limit() - p;
+ if (n > 0)
{
- put (copied, get ());
- copied++;
+ System.arraycopy(backing_buffer, array_offset + p,
+ backing_buffer, array_offset, n);
}
-
- position (copied);
+ position(n);
limit(capacity());
return this;
}
Index: java/nio/channels/Channels.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/nio/channels/Channels.java,v
retrieving revision 1.14
diff -u -r1.14 Channels.java
--- java/nio/channels/Channels.java 22 Mar 2006 19:15:25 -0000 1.14
+++ java/nio/channels/Channels.java 1 May 2006 22:39:54 -0000
@@ -38,8 +38,8 @@
package java.nio.channels;
-import gnu.classpath.NotImplementedException;
import gnu.java.nio.ChannelReader;
+import gnu.java.nio.ChannelWriter;
import gnu.java.nio.InputStreamChannel;
import gnu.java.nio.OutputStreamChannel;
@@ -126,10 +126,8 @@
*/
public static Writer newWriter(WritableByteChannel ch, CharsetEncoder enc,
int minBufferCap)
- throws NotImplementedException
{
- // FIXME: implement
java.nio.channels.Channel.newWriter(WritableByteChannel, CharsetEncoder, int)
- throw new Error("not implemented");
+ return new ChannelWriter(ch, enc, minBufferCap);
}
/**
Index: gnu/java/nio/ChannelWriter.java
===================================================================
RCS file: gnu/java/nio/ChannelWriter.java
diff -N gnu/java/nio/ChannelWriter.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ gnu/java/nio/ChannelWriter.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,190 @@
+/* ChannelWriter.java -- nio / writer bridge
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.nio;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.channels.WritableByteChannel;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+
+/**
+ * A Writer implementation that works by wrapping an NIO channel.
+ */
+public class ChannelWriter
+ extends Writer
+{
+ private static final int DEFAULT_BUFFER_CAP = 8192;
+
+ /**
+ * The output channel.
+ */
+ private WritableByteChannel byteChannel;
+
+ /**
+ * The encoder to use.
+ */
+ private CharsetEncoder enc;
+
+ /**
+ * The byte buffer. Translated characters are stored here on their way out.
+ */
+ private ByteBuffer byteBuffer;
+
+ /**
+ * The character buffer. Characters are stored here on their way into
+ * the encoder.
+ */
+ private CharBuffer charBuffer;
+
+ private void writeBuffer() throws IOException
+ {
+ byteBuffer.flip();
+ byteChannel.write(byteBuffer);
+ }
+
+ /**
+ * Create a new instance, given the output byte channel, the encoder
+ * to use, and the minimum buffer capacity.
+ */
+ public ChannelWriter(WritableByteChannel ch, CharsetEncoder enc,
+ int minBufferCap)
+ {
+ this.byteChannel = ch;
+ this.enc = enc;
+ if (minBufferCap == -1)
+ minBufferCap = DEFAULT_BUFFER_CAP;
+ this.byteBuffer
+ = ByteBuffer.allocate((int) (minBufferCap * enc.maxBytesPerChar()));
+ this.charBuffer = CharBuffer.allocate(minBufferCap);
+ this.charBuffer.clear();
+ }
+
+ /* (non-Javadoc)
+ * @see java.io.Writer#flush()
+ */
+ public void flush() throws IOException
+ {
+ // Presumably if we have characters in our buffer, it is
+ // due to an underflow. So we don't bother trying to flush
+ // that here.
+ }
+
+ /* (non-Javadoc)
+ * @see java.io.Writer#close()
+ */
+ public void close() throws IOException
+ {
+ synchronized (lock)
+ {
+ if (enc == null)
+ throw new IOException("writer already closed");
+
+ byteBuffer.clear();
+ charBuffer.flip();
+ CoderResult res = enc.encode(charBuffer, byteBuffer, true);
+ if (res.isError() || res.isMalformed() || res.isUnmappable())
+ res.throwException();
+ writeBuffer();
+
+ byteBuffer.clear();
+ res = enc.flush(byteBuffer);
+ if (res.isError() || res.isMalformed() || res.isUnmappable())
+ res.throwException();
+ writeBuffer();
+ enc = null;
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see java.io.Writer#write(char[], int, int)
+ */
+ public void write(char[] buf, int offset, int len) throws IOException
+ {
+ synchronized (lock)
+ {
+ if (enc == null)
+ throw new IOException("writer already closed");
+ int lastLen = -1;
+ while (len > 0)
+ {
+ // Copy data into our character buffer.
+ int allowed = Math.min(charBuffer.remaining(), len);
+ charBuffer.put(buf, offset, allowed);
+ // Update for the next pass through the loop.
+ offset += allowed;
+ len -= allowed;
+ charBuffer.flip();
+ // If we didn't make any progress, we want to clean up
+ // and save our state for the next write().
+ if (len == lastLen)
+ {
+ if (len <= charBuffer.remaining())
+ {
+ charBuffer.put(buf, offset, len);
+ charBuffer.flip();
+ }
+ else
+ {
+ CharBuffer ncb = CharBuffer.allocate(charBuffer.length()
+ + len);
+ ncb.put(charBuffer);
+ ncb.put(buf, offset, len);
+ charBuffer = ncb;
+ }
+ break;
+ }
+ lastLen = len;
+
+ // Convert.
+ byteBuffer.clear();
+ CoderResult res = enc.encode(charBuffer, byteBuffer, false);
+ // Compact here, as we want to leave the buffer in the
+ // right state for any future put()s.
+ charBuffer.compact();
+ if (res.isError() || res.isMalformed() || res.isUnmappable())
+ res.throwException();
+ // Write the byte buffer to the output channel.
+ writeBuffer();
+ }
+ }
+ }
+}
