From ebce970d7fa5aac9c4dea5381784441e155dbb64 Mon Sep 17 00:00:00 2001 From: Michael Koch Date: Wed, 20 Apr 2005 06:05:04 +0000 Subject: [PATCH] [multiple changes] 2005-04-20 Sven de Marothy * java/nio/ByteBufferImpl.java: (putChar): Inlined for speed. (put, get): Bulk methods can use arraycopy. * java/nio/CharBufferImpl.java: (put, get): Bulk methods can use arraycopy. 2005-04-20 Jeroen Frijters * java/nio/ByteBufferImpl.java (get(), put(byte)): Inlined checks and field updates. * java/nio/CharBufferImpl.java (CharBufferImpl(CharBufferImpl)): Copy array_offset field. (get(), put(char)): Inlined checks and field updates. Fixed to take array_offset into account. (get(int), put(int, char)): Fixed to take array_offset into account. From-SVN: r98445 --- libjava/ChangeLog | 18 ++++++++ libjava/java/nio/ByteBufferImpl.java | 66 +++++++++++++++++++++++----- libjava/java/nio/CharBufferImpl.java | 50 ++++++++++++++++----- 3 files changed, 113 insertions(+), 21 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 203ea973054..0270724fbe0 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,21 @@ +2005-04-20 Sven de Marothy + + * java/nio/ByteBufferImpl.java: + (putChar): Inlined for speed. + (put, get): Bulk methods can use arraycopy. + * java/nio/CharBufferImpl.java: + (put, get): Bulk methods can use arraycopy. + +2005-04-20 Jeroen Frijters + + * java/nio/ByteBufferImpl.java (get(), put(byte)): Inlined checks + and field updates. + * java/nio/CharBufferImpl.java + (CharBufferImpl(CharBufferImpl)): Copy array_offset field. + (get(), put(char)): Inlined checks and field updates. Fixed to + take array_offset into account. + (get(int), put(int, char)): Fixed to take array_offset into account. + 2005-04-20 Sven de Marothy * java/text/SimpleDateFormat.java: diff --git a/libjava/java/nio/ByteBufferImpl.java b/libjava/java/nio/ByteBufferImpl.java index d9f24627de0..47961700a00 100644 --- a/libjava/java/nio/ByteBufferImpl.java +++ b/libjava/java/nio/ByteBufferImpl.java @@ -144,13 +144,43 @@ final class ByteBufferImpl extends ByteBuffer */ public byte get () { - checkForUnderflow(); + if (pos >= limit) + throw new BufferUnderflowException(); - byte result = backing_buffer [position () + array_offset]; - position (position () + 1); - return result; + return backing_buffer [(pos++) + array_offset]; } - + + /** + * Bulk get + */ + public ByteBuffer get (byte[] dst, int offset, int length) + { + checkArraySize(dst.length, offset, length); + if ( (limit - pos) < length) // check for overflow + throw new BufferUnderflowException(); + + System.arraycopy(backing_buffer, pos + array_offset, + dst, offset, length); + pos += length; + + return this; + } + + /** + * Relative bulk put(), overloads the ByteBuffer impl. + */ + public ByteBuffer put (byte[] src, int offset, int length) + { + if ( (limit - pos) < length) // check for overflow + throw new BufferOverflowException(); + checkArraySize(src.length, offset, length); + + System.arraycopy(src, offset, backing_buffer, pos + array_offset, length); + pos += length; + + return this; + } + /** * Relative put method. Writes value to the next position * in the buffer. @@ -161,12 +191,12 @@ final class ByteBufferImpl extends ByteBuffer */ public ByteBuffer put (byte value) { - checkIfReadOnly(); - checkForOverflow(); + if (readOnly) + throw new ReadOnlyBufferException(); + if (pos >= limit) + throw new BufferOverflowException(); - int pos = position(); - backing_buffer [pos + array_offset] = value; - position (pos + 1); + backing_buffer [(pos++) + array_offset] = value; return this; } @@ -208,7 +238,21 @@ final class ByteBufferImpl extends ByteBuffer public ByteBuffer putChar (char value) { - ByteBufferHelper.putChar(this, value, order()); + if (readOnly) + throw new ReadOnlyBufferException (); + if ( (limit-pos) < 2) + throw new BufferOverflowException(); + + if (endian == ByteOrder.LITTLE_ENDIAN) + { + backing_buffer [(pos++) + array_offset] = (byte)(value&0xFF); + backing_buffer [(pos++) + array_offset] = (byte)(value>>8); + } + else + { + backing_buffer [(pos++) + array_offset] = (byte)(value>>8); + backing_buffer [(pos++) + array_offset] = (byte)(value&0xFF); + } return this; } diff --git a/libjava/java/nio/CharBufferImpl.java b/libjava/java/nio/CharBufferImpl.java index f9babe8287b..a6c81d914fa 100644 --- a/libjava/java/nio/CharBufferImpl.java +++ b/libjava/java/nio/CharBufferImpl.java @@ -62,6 +62,7 @@ final class CharBufferImpl extends CharBuffer { super (copy.capacity (), copy.limit (), copy.position (), 0); backing_buffer = copy.backing_buffer; + array_offset = copy.array_offset; readOnly = copy.isReadOnly (); } @@ -127,11 +128,10 @@ final class CharBufferImpl extends CharBuffer */ public char get () { - checkForUnderflow(); + if (pos >= limit) + throw new BufferUnderflowException(); - char result = backing_buffer [position ()]; - position (position () + 1); - return result; + return backing_buffer [(pos++) + array_offset]; } /** @@ -142,10 +142,12 @@ final class CharBufferImpl extends CharBuffer */ public CharBuffer put (char value) { - checkIfReadOnly(); - - backing_buffer [position ()] = value; - position (position () + 1); + if (readOnly) + throw new ReadOnlyBufferException(); + if (pos >= limit) + throw new BufferOverflowException(); + + backing_buffer [(pos++) + array_offset] = value; return this; } @@ -162,9 +164,37 @@ final class CharBufferImpl extends CharBuffer { checkIndex(index); - return backing_buffer [index]; + return backing_buffer [index + array_offset]; } + /** + * Bulk get, overloaded for speed. + */ + public CharBuffer get (char[] dst, int offset, int length) + { + checkArraySize(dst.length, offset, length); + checkForUnderflow(length); + + System.arraycopy(backing_buffer, pos + array_offset, + dst, offset, length); + pos += length; + return this; + } + + /** + * Bulk put, overloaded for speed. + */ + public CharBuffer put (char[] src, int offset, int length) + { + checkArraySize(src.length, offset, length); + checkForOverflow(length); + + System.arraycopy(src, offset, + backing_buffer, pos + array_offset, length); + pos += length; + return this; + } + /** * Absolute put method. Writes value to position * index in the buffer. @@ -178,7 +208,7 @@ final class CharBufferImpl extends CharBuffer checkIndex(index); checkIfReadOnly(); - backing_buffer [index] = value; + backing_buffer [index + array_offset] = value; return this; }