diff options
Diffstat (limited to 'libjava/java/nio')
22 files changed, 2793 insertions, 15 deletions
diff --git a/libjava/java/nio/ByteBuffer.java b/libjava/java/nio/ByteBuffer.java index cb743c7..1727b41 100644 --- a/libjava/java/nio/ByteBuffer.java +++ b/libjava/java/nio/ByteBuffer.java @@ -35,10 +35,8 @@ 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 java.nio; -import gnu.java.nio.ByteBufferImpl; -import gnu.java.nio.DirectByteBufferImpl; +package java.nio; /** * @since 1.4 diff --git a/libjava/java/nio/ByteBufferImpl.java b/libjava/java/nio/ByteBufferImpl.java new file mode 100644 index 0000000..4642288 --- /dev/null +++ b/libjava/java/nio/ByteBufferImpl.java @@ -0,0 +1,422 @@ +/* ByteBufferImpl.java -- + Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +/** + * This is a Heap memory implementation + */ +public final class ByteBufferImpl extends ByteBuffer +{ + private boolean readOnly; + + ByteBufferImpl (int capacity) + { + this (new byte [capacity], 0, capacity, capacity, 0, -1, false); + } + + ByteBufferImpl (byte[] buffer, int offset, int capacity, int limit, int position, int mark, boolean readOnly) + { + super (buffer, offset, capacity, limit, position, mark); + this.readOnly = readOnly; + } + + public CharBuffer asCharBuffer () + { + return new CharViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ()); + } + + public ShortBuffer asShortBuffer () + { + return new ShortViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ()); + } + + public IntBuffer asIntBuffer () + { + return new IntViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ()); + } + + public LongBuffer asLongBuffer () + { + return new LongViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ()); + } + + public FloatBuffer asFloatBuffer () + { + return new FloatViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ()); + } + + public DoubleBuffer asDoubleBuffer () + { + return new DoubleViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ()); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public ByteBuffer slice () + { + return new ByteBufferImpl (backing_buffer, array_offset + position (), remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public ByteBuffer duplicate () + { + return new ByteBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, isReadOnly ()); + } + + public ByteBuffer asReadOnlyBuffer () + { + return new ByteBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, true); + } + + public ByteBuffer compact () + { + int copied = 0; + + while (remaining () > 0) + { + put (copied, get ()); + copied++; + } + + position (copied); + return this; + } + + public boolean isDirect () + { + return false; + } + + /** + * Relative get method. Reads the next <code>byte</code> from the buffer. + */ + final public byte get () + { + byte result = backing_buffer [position ()]; + position (position () + 1); + return result; + } + + /** + * Relative put method. Writes <code>value</code> to the next position + * in the buffer. + * + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public ByteBuffer put (byte value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [position ()] = value; + position (position () + 1); + return this; + } + + /** + * Absolute get method. Reads the <code>byte</code> at position + * <code>index</code>. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + */ + final public byte get (int index) + { + return backing_buffer [index]; + } + + /** + * Absolute put method. Writes <code>value</value> to position + * <code>index</code> in the buffer. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public ByteBuffer put (int index, byte value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [index] = value; + return this; + } + + final public char getChar () + { + // FIXME: this handles big endian only + return (char) (((get () & 0xff) << 8) + (get () & 0xff)); + } + + final public ByteBuffer putChar (char value) + { + // FIXME: this handles big endian only + put ((byte) ((((int) value) & 0xff00) >> 8)); + put ((byte) (((int) value) & 0x00ff)); + return this; + } + + final public char getChar (int index) + { + // FIXME: this handles big endian only + return (char) (((get (index) & 0xff) << 8) + (get (index + 1) & 0xff)); + } + + final public ByteBuffer putChar (int index, char value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((int) value) & 0xff00) >> 8)); + put (index + 1, (byte) (((int) value) & 0x00ff)); + return this; + } + + final public short getShort () + { + // FIXME: this handles big endian only + return (short) (((get () & 0xff) << 8) + (get () & 0xff)); + } + + final public ByteBuffer putShort (short value) + { + // FIXME: this handles big endian only + put ((byte) ((((int) value) & 0xff00) >> 8)); + put ((byte) (((int) value) & 0x00ff)); + return this; + } + + final public short getShort (int index) + { + // FIXME: this handles big endian only + return (short) (((get (index) & 0xff) << 8) + (get (index + 1) & 0xff)); + } + + final public ByteBuffer putShort (int index, short value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((int) value) & 0xff00) >> 8)); + put (index + 1, (byte) (((int) value) & 0x00ff)); + return this; + } + + final public int getInt () + { + // FIXME: this handles big endian only + return (int) (((get () & 0xff) << 24) + + (get () & 0xff) << 16 + + (get () & 0xff) << 8 + + (get () & 0xff)); + } + + final public ByteBuffer putInt (int value) + { + // FIXME: this handles big endian only + put ((byte) ((((int) value) & 0xff000000) >> 24)); + put ((byte) ((((int) value) & 0x00ff0000) >> 16)); + put ((byte) ((((int) value) & 0x0000ff00) >> 8)); + put ((byte) (((int) value) & 0x000000ff)); + return this; + } + + final public int getInt (int index) + { + // FIXME: this handles big endian only + return (int) (((get (index) & 0xff) << 24) + + (get (index + 1) & 0xff) << 16 + + (get (index + 2) & 0xff) << 8 + + (get (index + 3) & 0xff)); + } + + final public ByteBuffer putInt (int index, int value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((int) value) & 0xff000000) >> 24)); + put (index + 1, (byte) ((((int) value) & 0x00ff0000) >> 16)); + put (index + 2, (byte) ((((int) value) & 0x0000ff00) >> 8)); + put (index + 3, (byte) (((int) value) & 0x000000ff)); + return this; + } + + final public long getLong () + { + // FIXME: this handles big endian only + return (long) (((get () & 0xff) << 56) + + (get () & 0xff) << 48 + + (get () & 0xff) << 40 + + (get () & 0xff) << 32 + + (get () & 0xff) << 24 + + (get () & 0xff) << 16 + + (get () & 0xff) << 8 + + (get () & 0xff)); + } + + final public ByteBuffer putLong (long value) + { + // FIXME: this handles big endian only + put ((byte) ((value & 0xff00000000000000L) >> 56)); + put ((byte) ((value & 0x00ff000000000000L) >> 48)); + put ((byte) ((value & 0x0000ff0000000000L) >> 40)); + put ((byte) ((value & 0x000000ff00000000L) >> 32)); + put ((byte) ((value & 0x00000000ff000000L) >> 24)); + put ((byte) ((value & 0x0000000000ff0000L) >> 16)); + put ((byte) ((value & 0x000000000000ff00L) >> 8)); + put ((byte) (value & 0x00000000000000ffL)); + return this; + } + + final public long getLong (int index) + { + // FIXME: this handles big endian only + return (long) (((get (index) & 0xff) << 56) + + (get (index + 1) & 0xff) << 48 + + (get (index + 2) & 0xff) << 40 + + (get (index + 3) & 0xff) << 32 + + (get (index + 4) & 0xff) << 24 + + (get (index + 5) & 0xff) << 16 + + (get (index + 6) & 0xff) << 8 + + (get (index + 7) & 0xff)); + } + + final public ByteBuffer putLong (int index, long value) + { + // FIXME: this handles big endian only + put (index, (byte) ((value & 0xff00000000000000L) >> 56)); + put (index + 1, (byte) ((value & 0x00ff000000000000L) >> 48)); + put (index + 2, (byte) ((value & 0x0000ff0000000000L) >> 40)); + put (index + 3, (byte) ((value & 0x000000ff00000000L) >> 32)); + put (index + 4, (byte) ((value & 0x00000000ff000000L) >> 24)); + put (index + 5, (byte) ((value & 0x0000000000ff0000L) >> 16)); + put (index + 6, (byte) ((value & 0x000000000000ff00L) >> 8)); + put (index + 7, (byte) (value & 0x00000000000000ffL)); + return this; + } + + final public float getFloat () + { + // FIXME: this handles big endian only + return (float) (((get () & 0xff) << 24) + + (get () & 0xff) << 16 + + (get () & 0xff) << 8 + + (get () & 0xff)); + } + + final public ByteBuffer putFloat (float value) + { + // FIXME: this handles big endian only + put ((byte) ((((int) value) & 0xff000000) >> 24)); + put ((byte) ((((int) value) & 0x00ff0000) >> 16)); + put ((byte) ((((int) value) & 0x0000ff00) >> 8)); + put ((byte) (((int) value) & 0x000000ff)); + return this; + } + + final public float getFloat (int index) + { + // FIXME: this handles big endian only + return (float) (((get (index) & 0xff) << 24) + + (get (index + 1) & 0xff) << 16 + + (get (index + 2) & 0xff) << 8 + + (get (index + 3) & 0xff)); + } + + final public ByteBuffer putFloat (int index, float value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((int) value) & 0xff000000) >> 24)); + put (index + 1, (byte) ((((int) value) & 0x00ff0000) >> 16)); + put (index + 2, (byte) ((((int) value) & 0x0000ff00) >> 8)); + put (index + 3, (byte) (((int) value) & 0x000000ff)); + return this; + } + + final public double getDouble () + { + // FIXME: this handles big endian only + return (double) (((get () & 0xff) << 56) + + (get () & 0xff) << 48 + + (get () & 0xff) << 40 + + (get () & 0xff) << 32 + + (get () & 0xff) << 24 + + (get () & 0xff) << 16 + + (get () & 0xff) << 8 + + (get () & 0xff)); + } + + final public ByteBuffer putDouble (double value) + { + // FIXME: this handles big endian only + put ((byte) ((((long) value) & 0xff00000000000000L) >> 56)); + put ((byte) ((((long) value) & 0x00ff000000000000L) >> 48)); + put ((byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); + put ((byte) ((((long) value) & 0x000000ff00000000L) >> 32)); + put ((byte) ((((long) value) & 0x00000000ff000000L) >> 24)); + put ((byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); + put ((byte) ((((long) value) & 0x000000000000ff00L) >> 8)); + put ((byte) (((long) value) & 0x00000000000000ffL)); + return this; + } + + final public double getDouble (int index) + { + // FIXME: this handles big endian only + return (double) (((get (index) & 0xff) << 56) + + (get (index + 1) & 0xff) << 48 + + (get (index + 2) & 0xff) << 40 + + (get (index + 3) & 0xff) << 32 + + (get (index + 4) & 0xff) << 24 + + (get (index + 5) & 0xff) << 16 + + (get (index + 6) & 0xff) << 8 + + (get (index + 7) & 0xff)); + } + + final public ByteBuffer putDouble (int index, double value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((long) value) & 0xff00000000000000L) >> 56)); + put (index + 1, (byte) ((((long) value) & 0x00ff000000000000L) >> 48)); + put (index + 2, (byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); + put (index + 3, (byte) ((((long) value) & 0x000000ff00000000L) >> 32)); + put (index + 4, (byte) ((((long) value) & 0x00000000ff000000L) >> 24)); + put (index + 5, (byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); + put (index + 6, (byte) ((((long) value) & 0x000000000000ff00L) >> 8)); + put (index + 7, (byte) (((long) value) & 0x00000000000000ffL)); + return this; + } +} diff --git a/libjava/java/nio/CharBuffer.java b/libjava/java/nio/CharBuffer.java index 9b97b4a..15a5357 100644 --- a/libjava/java/nio/CharBuffer.java +++ b/libjava/java/nio/CharBuffer.java @@ -35,9 +35,8 @@ 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 java.nio; -import gnu.java.nio.CharBufferImpl; +package java.nio; /** * @since 1.4 diff --git a/libjava/java/nio/CharBufferImpl.java b/libjava/java/nio/CharBufferImpl.java new file mode 100644 index 0000000..708ab40 --- /dev/null +++ b/libjava/java/nio/CharBufferImpl.java @@ -0,0 +1,183 @@ +/* CharBufferImpl.java -- + Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +/** + * This is a Heap memory implementation + */ +public final class CharBufferImpl extends CharBuffer +{ + private boolean readOnly; + + CharBufferImpl (int capacity) + { + this (new char [capacity], 0, capacity, capacity, 0, -1, false); + } + + CharBufferImpl (char[] buffer, int offset, int capacity, int limit, int position, int mark, boolean readOnly) + { + super (buffer, offset, capacity, limit, position, mark); + this.readOnly = readOnly; + } + + public CharBufferImpl (CharBufferImpl copy) + { + super (copy.capacity (), copy.limit (), copy.position (), 0); + backing_buffer = copy.backing_buffer; + readOnly = copy.isReadOnly (); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public CharBuffer slice () + { + return new CharBufferImpl (backing_buffer, array_offset + position (), remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public CharBuffer duplicate () + { + return new CharBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, isReadOnly ()); + } + + public CharBuffer asReadOnlyBuffer () + { + return new CharBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, true); + } + + public CharBuffer compact () + { + int copied = 0; + + while (remaining () > 0) + { + put (copied, get ()); + copied++; + } + + position (copied); + return this; + } + + public boolean isDirect () + { + return false; + } + + final public CharSequence subSequence (int start, int end) + { + if (start < 0 + || start > length () + || end < start + || end > length ()) + throw new IndexOutOfBoundsException (); + + return new CharBufferImpl (backing_buffer, array_offset, capacity (), position () + end, position () + start, -1, isReadOnly ()); + } + + /** + * Relative get method. Reads the next <code>char</code> from the buffer. + */ + final public char get () + { + char result = backing_buffer [position ()]; + position (position () + 1); + return result; + } + + /** + * Relative put method. Writes <code>value</code> to the next position + * in the buffer. + * + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public CharBuffer put (char value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [position ()] = value; + position (position () + 1); + return this; + } + + /** + * Absolute get method. Reads the <code>char</code> at position + * <code>index</code>. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + */ + final public char get (int index) + { + if (index < 0 + || index >= limit ()) + throw new IndexOutOfBoundsException (); + + return backing_buffer [index]; + } + + /** + * Absolute put method. Writes <code>value</value> to position + * <code>index</code> in the buffer. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public CharBuffer put (int index, char value) + { + if (index < 0 + || index >= limit ()) + throw new IndexOutOfBoundsException (); + + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [index] = value; + return this; + } + + final public ByteOrder order () + { + return ByteOrder.nativeOrder (); + } +} diff --git a/libjava/java/nio/CharViewBufferImpl.java b/libjava/java/nio/CharViewBufferImpl.java new file mode 100644 index 0000000..6da6d59 --- /dev/null +++ b/libjava/java/nio/CharViewBufferImpl.java @@ -0,0 +1,165 @@ +/* CharViewBufferImpl.java -- + Copyright (C) 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +class CharViewBufferImpl extends CharBuffer +{ + private boolean readOnly; + private int offset; + private ByteBuffer bb; + private ByteOrder endian; + + public CharViewBufferImpl (ByteBuffer bb, boolean readOnly) + { + super (bb.remaining () >> 1, bb.remaining () >> 1, bb.position (), 0); + this.bb = bb; + this.readOnly = readOnly; + // FIXME: What if this is called from CharByteBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public CharViewBufferImpl (ByteBuffer bb, int offset, int capacity, + int limit, int position, int mark, + boolean readOnly) + { + super (limit >> 1, limit >> 1, position >> 1, mark >> 1); + this.bb = bb; + this.offset = offset; + this.readOnly = readOnly; + // FIXME: What if this is called from CharViewBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public char get () + { + char result = bb.getChar ((position () << 1) + offset); + position (position () + 1); + return result; + } + + public char get (int index) + { + return bb.getChar ((index << 1) + offset); + } + + public CharBuffer put (char value) + { + bb.putChar ((position () << 1) + offset, value); + position (position () + 1); + return this; + } + + public CharBuffer put (int index, char value) + { + bb.putChar ((index << 1) + offset, value); + return this; + } + + public CharBuffer compact () + { + if (position () > 0) + { + // Copy all data from position() to limit() to the beginning of the + // buffer, set position to end of data and limit to capacity + // XXX: This can surely be optimized, for direct and non-direct buffers + + int count = limit () - position (); + + for (int i = 0; i < count; i++) + { + bb.putChar ((i >> 1) + offset, + bb.getChar (((i + position ()) >> 1) + offset)); + } + + position (count); + limit (capacity ()); + } + + return this; + } + + public CharBuffer duplicate () + { + // Create a copy of this object that shares its content + // FIXME: mark is not correct + return new CharViewBufferImpl (bb, offset, capacity (), limit (), + position (), -1, isReadOnly ()); + } + + public CharBuffer slice () + { + // Create a sliced copy of this object that shares its content. + return new CharViewBufferImpl (bb, (position () >> 1) + offset, + remaining (), remaining (), 0, -1, + isReadOnly ()); + } + + public CharSequence subSequence (int start, int end) + { + if (start < 0 + || start > length () + || end < start + || end > length ()) + throw new IndexOutOfBoundsException (); + + return new CharViewBufferImpl (bb, array_offset, capacity (), position () + end, position () + start, -1, isReadOnly ()); + } + + public CharBuffer asReadOnlyBuffer () + { + // Create a copy of this object that shares its content and is read-only + return new CharViewBufferImpl (bb, (position () >> 1) + offset, + remaining (), remaining (), 0, -1, true); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public boolean isDirect () + { + return bb.isDirect (); + } + + public ByteOrder order () + { + return ByteOrder.LITTLE_ENDIAN; + } +} diff --git a/libjava/java/nio/DirectByteBufferImpl.java b/libjava/java/nio/DirectByteBufferImpl.java new file mode 100644 index 0000000..b037385 --- /dev/null +++ b/libjava/java/nio/DirectByteBufferImpl.java @@ -0,0 +1,416 @@ +/* DirectByteBufferImpl.java -- + Copyright (C) 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +import gnu.gcj.RawData; + +public class DirectByteBufferImpl extends ByteBuffer +{ + private RawData address; + private int offset; + private boolean readOnly; + + public DirectByteBufferImpl (RawData address, int offset, int capacity, + int limit, int position, int mark, + boolean readOnly) + { + super (capacity, limit, position, mark); + this.address = address; + this.offset = offset; + this.readOnly = readOnly; + } + + private static native RawData allocateImpl (int capacity); + private static native void freeImpl (RawData address); + + protected void finalize () throws Throwable + { + freeImpl (address); + } + + public static ByteBuffer allocateDirect (int capacity) + { + RawData address = allocateImpl (capacity); + + if (address == null) + throw new InternalError ("Not enough memory to create direct buffer"); + + return new DirectByteBufferImpl (address, 0, capacity, capacity, 0, -1, false); + } + + private native byte getImpl (int index); + private native void putImpl (int index, byte value); + + public byte get () + { + byte result = getImpl (position () + offset); + position (position () + 1); + return result; + } + + public byte get (int index) + { + return getImpl (index); + } + + public ByteBuffer put (byte value) + { + putImpl (position (), value); + position (position () + 1); + return this; + } + + public ByteBuffer put (int index, byte value) + { + putImpl (index, value); + return this; + } + + public ByteBuffer compact () + { + // FIXME this can sure be optimized using memcpy() + int copied = 0; + + while (remaining () > 0) + { + put (copied, get ()); + copied++; + } + + position (copied); + return this; + } + + public ByteBuffer duplicate () + { + return new DirectByteBufferImpl ( + address, offset, capacity (), limit (), position (), -1, isReadOnly ()); + } + + public ByteBuffer slice () + { + return new DirectByteBufferImpl (address, position () + offset, remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public ByteBuffer asReadOnlyBuffer () + { + return new DirectByteBufferImpl ( + address, offset, capacity (), limit (), position (), -1, true); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public boolean isDirect () + { + return true; + } + + public CharBuffer asCharBuffer () + { + return new CharViewBufferImpl (this, position () + offset, remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public DoubleBuffer asDoubleBuffer () + { + return new DoubleViewBufferImpl (this, position () + offset, remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public FloatBuffer asFloatBuffer () + { + return new FloatViewBufferImpl (this, position () + offset, remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public IntBuffer asIntBuffer () + { + return new IntViewBufferImpl (this, position () + offset, remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public LongBuffer asLongBuffer () + { + return new LongViewBufferImpl (this, position () + offset, remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public ShortBuffer asShortBuffer () + { + return new ShortViewBufferImpl (this, position () + offset, remaining (), remaining (), 0, -1, isReadOnly ()); + } + + final public char getChar () + { + // FIXME: this handles big endian only + return (char) (((get () & 0xff) << 8) + (get () & 0xff)); + } + + final public ByteBuffer putChar (char value) + { + // FIXME: this handles big endian only + put ((byte) ((((int) value) & 0xff00) >> 8)); + put ((byte) (((int) value) & 0x00ff)); + return this; + } + + final public char getChar (int index) + { + // FIXME: this handles big endian only + return (char) (((get (index) & 0xff) << 8) + (get (index + 1) & 0xff)); + } + + final public ByteBuffer putChar (int index, char value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((int) value) & 0xff00) >> 8)); + put (index + 1, (byte) (((int) value) & 0x00ff)); + return this; + } + + final public short getShort () + { + // FIXME: this handles big endian only + return (short) (((get () & 0xff) << 8) + (get () & 0xff)); + } + + final public ByteBuffer putShort (short value) + { + // FIXME: this handles big endian only + put ((byte) ((((int) value) & 0xff00) >> 8)); + put ((byte) (((int) value) & 0x00ff)); + return this; + } + + final public short getShort (int index) + { + // FIXME: this handles big endian only + return (short) (((get (index) & 0xff) << 8) + (get (index + 1) & 0xff)); + } + + final public ByteBuffer putShort (int index, short value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((int) value) & 0xff00) >> 8)); + put (index + 1, (byte) (((int) value) & 0x00ff)); + return this; + } + + final public int getInt () + { + // FIXME: this handles big endian only + return (int) (((get () & 0xff) << 24) + + (get () & 0xff) << 16 + + (get () & 0xff) << 8 + + (get () & 0xff)); + } + + final public ByteBuffer putInt (int value) + { + // FIXME: this handles big endian only + put ((byte) ((((int) value) & 0xff000000) >> 24)); + put ((byte) ((((int) value) & 0x00ff0000) >> 16)); + put ((byte) ((((int) value) & 0x0000ff00) >> 8)); + put ((byte) (((int) value) & 0x000000ff)); + return this; + } + + final public int getInt (int index) + { + // FIXME: this handles big endian only + return (int) (((get (index) & 0xff) << 24) + + (get (index + 1) & 0xff) << 16 + + (get (index + 2) & 0xff) << 8 + + (get (index + 3) & 0xff)); + } + + final public ByteBuffer putInt (int index, int value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((int) value) & 0xff000000) >> 24)); + put (index + 1, (byte) ((((int) value) & 0x00ff0000) >> 16)); + put (index + 2, (byte) ((((int) value) & 0x0000ff00) >> 8)); + put (index + 3, (byte) (((int) value) & 0x000000ff)); + return this; + } + + final public long getLong () + { + // FIXME: this handles big endian only + return (long) (((get () & 0xff) << 56) + + (get () & 0xff) << 48 + + (get () & 0xff) << 40 + + (get () & 0xff) << 32 + + (get () & 0xff) << 24 + + (get () & 0xff) << 16 + + (get () & 0xff) << 8 + + (get () & 0xff)); + } + + final public ByteBuffer putLong (long value) + { + // FIXME: this handles big endian only + put ((byte) ((value & 0xff00000000000000L) >> 56)); + put ((byte) ((value & 0x00ff000000000000L) >> 48)); + put ((byte) ((value & 0x0000ff0000000000L) >> 40)); + put ((byte) ((value & 0x000000ff00000000L) >> 32)); + put ((byte) ((value & 0x00000000ff000000L) >> 24)); + put ((byte) ((value & 0x0000000000ff0000L) >> 16)); + put ((byte) ((value & 0x000000000000ff00L) >> 8)); + put ((byte) (value & 0x00000000000000ffL)); + return this; + } + + final public long getLong (int index) + { + // FIXME: this handles big endian only + return (long) (((get (index) & 0xff) << 56) + + (get (index + 1) & 0xff) << 48 + + (get (index + 2) & 0xff) << 40 + + (get (index + 3) & 0xff) << 32 + + (get (index + 4) & 0xff) << 24 + + (get (index + 5) & 0xff) << 16 + + (get (index + 6) & 0xff) << 8 + + (get (index + 7) & 0xff)); + } + + final public ByteBuffer putLong (int index, long value) + { + // FIXME: this handles big endian only + put (index, (byte) ((value & 0xff00000000000000L) >> 56)); + put (index + 1, (byte) ((value & 0x00ff000000000000L) >> 48)); + put (index + 2, (byte) ((value & 0x0000ff0000000000L) >> 40)); + put (index + 3, (byte) ((value & 0x000000ff00000000L) >> 32)); + put (index + 4, (byte) ((value & 0x00000000ff000000L) >> 24)); + put (index + 5, (byte) ((value & 0x0000000000ff0000L) >> 16)); + put (index + 6, (byte) ((value & 0x000000000000ff00L) >> 8)); + put (index + 7, (byte) (value & 0x00000000000000ffL)); + return this; + } + + final public float getFloat () + { + // FIXME: this handles big endian only + return (float) (((get () & 0xff) << 24) + + (get () & 0xff) << 16 + + (get () & 0xff) << 8 + + (get () & 0xff)); + } + + final public ByteBuffer putFloat (float value) + { + // FIXME: this handles big endian only + put ((byte) ((((int) value) & 0xff000000) >> 24)); + put ((byte) ((((int) value) & 0x00ff0000) >> 16)); + put ((byte) ((((int) value) & 0x0000ff00) >> 8)); + put ((byte) (((int) value) & 0x000000ff)); + return this; + } + + final public float getFloat (int index) + { + // FIXME: this handles big endian only + return (float) (((get (index) & 0xff) << 24) + + (get (index + 1) & 0xff) << 16 + + (get (index + 2) & 0xff) << 8 + + (get (index + 3) & 0xff)); + } + + final public ByteBuffer putFloat (int index, float value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((int) value) & 0xff000000) >> 24)); + put (index + 1, (byte) ((((int) value) & 0x00ff0000) >> 16)); + put (index + 2, (byte) ((((int) value) & 0x0000ff00) >> 8)); + put (index + 3, (byte) (((int) value) & 0x000000ff)); + return this; + } + + final public double getDouble () + { + // FIXME: this handles big endian only + return (double) (((get () & 0xff) << 56) + + (get () & 0xff) << 48 + + (get () & 0xff) << 40 + + (get () & 0xff) << 32 + + (get () & 0xff) << 24 + + (get () & 0xff) << 16 + + (get () & 0xff) << 8 + + (get () & 0xff)); + } + + final public ByteBuffer putDouble (double value) + { + // FIXME: this handles big endian only + put ((byte) ((((long) value) & 0xff00000000000000L) >> 56)); + put ((byte) ((((long) value) & 0x00ff000000000000L) >> 48)); + put ((byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); + put ((byte) ((((long) value) & 0x000000ff00000000L) >> 32)); + put ((byte) ((((long) value) & 0x00000000ff000000L) >> 24)); + put ((byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); + put ((byte) ((((long) value) & 0x000000000000ff00L) >> 8)); + put ((byte) (((long) value) & 0x00000000000000ffL)); + return this; + } + + final public double getDouble (int index) + { + // FIXME: this handles big endian only + return (double) (((get (index) & 0xff) << 56) + + (get (index + 1) & 0xff) << 48 + + (get (index + 2) & 0xff) << 40 + + (get (index + 3) & 0xff) << 32 + + (get (index + 4) & 0xff) << 24 + + (get (index + 5) & 0xff) << 16 + + (get (index + 6) & 0xff) << 8 + + (get (index + 7) & 0xff)); + } + + final public ByteBuffer putDouble (int index, double value) + { + // FIXME: this handles big endian only + put (index, (byte) ((((long) value) & 0xff00000000000000L) >> 56)); + put (index + 1, (byte) ((((long) value) & 0x00ff000000000000L) >> 48)); + put (index + 2, (byte) ((((long) value) & 0x0000ff0000000000L) >> 40)); + put (index + 3, (byte) ((((long) value) & 0x000000ff00000000L) >> 32)); + put (index + 4, (byte) ((((long) value) & 0x00000000ff000000L) >> 24)); + put (index + 5, (byte) ((((long) value) & 0x0000000000ff0000L) >> 16)); + put (index + 6, (byte) ((((long) value) & 0x000000000000ff00L) >> 8)); + put (index + 7, (byte) (((long) value) & 0x00000000000000ffL)); + return this; + } +} diff --git a/libjava/java/nio/DoubleBuffer.java b/libjava/java/nio/DoubleBuffer.java index f212566..644f33b 100644 --- a/libjava/java/nio/DoubleBuffer.java +++ b/libjava/java/nio/DoubleBuffer.java @@ -35,9 +35,8 @@ 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 java.nio; -import gnu.java.nio.DoubleBufferImpl; +package java.nio; /** * @since 1.4 diff --git a/libjava/java/nio/DoubleBufferImpl.java b/libjava/java/nio/DoubleBufferImpl.java new file mode 100644 index 0000000..dbc63bb --- /dev/null +++ b/libjava/java/nio/DoubleBufferImpl.java @@ -0,0 +1,157 @@ +/* DoubleBufferImpl.java -- + Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +/** + * This is a Heap memory implementation + */ +public final class DoubleBufferImpl extends DoubleBuffer +{ + private boolean readOnly; + + DoubleBufferImpl (int capacity) + { + this (new double [capacity], 0, capacity, capacity, 0, -1, false); + } + + DoubleBufferImpl (double[] buffer, int offset, int capacity, int limit, int position, int mark, boolean readOnly) + { + super (buffer, offset, capacity, limit, position, mark); + this.readOnly = readOnly; + } + + public boolean isReadOnly () + { + return readOnly; + } + + public DoubleBuffer slice () + { + return new DoubleBufferImpl (backing_buffer, array_offset + position (), remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public DoubleBuffer duplicate () + { + return new DoubleBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, isReadOnly ()); + } + + public DoubleBuffer asReadOnlyBuffer () + { + return new DoubleBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, true); + } + + public DoubleBuffer compact () + { + int copied = 0; + + while (remaining () > 0) + { + put (copied, get ()); + copied++; + } + + position (copied); + return this; + } + + public boolean isDirect () + { + return false; + } + + /** + * Relative get method. Reads the next <code>double</code> from the buffer. + */ + final public double get () + { + double result = backing_buffer [position ()]; + position (position () + 1); + return result; + } + + /** + * Relative put method. Writes <code>value</code> to the next position + * in the buffer. + * + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public DoubleBuffer put (double value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [position ()] = value; + position (position () + 1); + return this; + } + + /** + * Absolute get method. Reads the <code>double</code> at position + * <code>index</code>. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + */ + final public double get (int index) + { + return backing_buffer [index]; + } + + /** + * Absolute put method. Writes <code>value</value> to position + * <code>index</code> in the buffer. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public DoubleBuffer put (int index, double value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [index] = value; + return this; + } + + final public ByteOrder order () + { + return ByteOrder.nativeOrder (); + } +} diff --git a/libjava/java/nio/DoubleViewBufferImpl.java b/libjava/java/nio/DoubleViewBufferImpl.java new file mode 100644 index 0000000..480b97f --- /dev/null +++ b/libjava/java/nio/DoubleViewBufferImpl.java @@ -0,0 +1,154 @@ +/* DoubleViewBufferImpl.java -- + Copyright (C) 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +class DoubleViewBufferImpl extends DoubleBuffer +{ + private boolean readOnly; + private int offset; + private ByteBuffer bb; + private ByteOrder endian; + + public DoubleViewBufferImpl (ByteBuffer bb, boolean readOnly) + { + super (bb.remaining () >> 3, bb.remaining () >> 3, bb.position (), 0); + this.bb = bb; + this.readOnly = readOnly; + // FIXME: What if this is called from DoubleByteBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public DoubleViewBufferImpl (ByteBuffer bb, int offset, int capacity, + int limit, int position, int mark, + boolean readOnly) + { + super (limit >> 3, limit >> 3, position >> 3, mark >> 3); + this.bb = bb; + this.offset = offset; + this.readOnly = readOnly; + // FIXME: What if this is called from DoubleViewBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public double get () + { + double result = bb.getDouble ((position () << 3) + offset); + position (position () + 1); + return result; + } + + public double get (int index) + { + return bb.getDouble ((index << 3) + offset); + } + + public DoubleBuffer put (double value) + { + bb.putDouble ((position () << 3) + offset, value); + position (position () + 1); + return this; + } + + public DoubleBuffer put (int index, double value) + { + bb.putDouble ((index << 3) + offset, value); + return this; + } + + public DoubleBuffer compact () + { + if (position () > 0) + { + // Copy all data from position() to limit() to the beginning of the + // buffer, set position to end of data and limit to capacity + // XXX: This can surely be optimized, for direct and non-direct buffers + + int count = limit () - position (); + + for (int i = 0; i < count; i++) + { + bb.putDouble ((i >> 3) + offset, + bb.getDouble (((i + position ()) >> 3) + offset)); + } + + position (count); + limit (capacity ()); + } + + return this; + } + + public DoubleBuffer duplicate () + { + // Create a copy of this object that shares its content + // FIXME: mark is not correct + return new DoubleViewBufferImpl (bb, offset, capacity (), limit (), + position (), -1, isReadOnly ()); + } + + public DoubleBuffer slice () + { + // Create a sliced copy of this object that shares its content. + return new DoubleViewBufferImpl (bb, (position () >> 3) + offset, + remaining (), remaining (), 0, -1, + isReadOnly ()); + } + + public DoubleBuffer asReadOnlyBuffer () + { + // Create a copy of this object that shares its content and is read-only + return new DoubleViewBufferImpl (bb, (position () >> 3) + offset, + remaining (), remaining (), 0, -1, true); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public boolean isDirect () + { + return bb.isDirect (); + } + + public ByteOrder order () + { + return ByteOrder.LITTLE_ENDIAN; + } +} diff --git a/libjava/java/nio/FloatBuffer.java b/libjava/java/nio/FloatBuffer.java index 65d680b..5fcfc8e 100644 --- a/libjava/java/nio/FloatBuffer.java +++ b/libjava/java/nio/FloatBuffer.java @@ -35,9 +35,8 @@ 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 java.nio; -import gnu.java.nio.FloatBufferImpl; +package java.nio; /** * @since 1.4 diff --git a/libjava/java/nio/FloatBufferImpl.java b/libjava/java/nio/FloatBufferImpl.java new file mode 100644 index 0000000..93dd1d0 --- /dev/null +++ b/libjava/java/nio/FloatBufferImpl.java @@ -0,0 +1,157 @@ +/* FloatBufferImpl.java -- + Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +/** + * This is a Heap memory implementation + */ +public final class FloatBufferImpl extends FloatBuffer +{ + private boolean readOnly; + + FloatBufferImpl (int capacity) + { + this (new float [capacity], 0, capacity, capacity, 0, -1, false); + } + + FloatBufferImpl (float[] buffer, int offset, int capacity, int limit, int position, int mark, boolean readOnly) + { + super (buffer, offset, capacity, limit, position, mark); + this.readOnly = readOnly; + } + + public boolean isReadOnly () + { + return readOnly; + } + + public FloatBuffer slice () + { + return new FloatBufferImpl (backing_buffer, array_offset + position (), remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public FloatBuffer duplicate () + { + return new FloatBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, isReadOnly ()); + } + + public FloatBuffer asReadOnlyBuffer () + { + return new FloatBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, true); + } + + public FloatBuffer compact () + { + int copied = 0; + + while (remaining () > 0) + { + put (copied, get ()); + copied++; + } + + position (copied); + return this; + } + + public boolean isDirect () + { + return false; + } + + /** + * Relative get method. Reads the next <code>float</code> from the buffer. + */ + final public float get () + { + float result = backing_buffer [position ()]; + position (position () + 1); + return result; + } + + /** + * Relative put method. Writes <code>value</code> to the next position + * in the buffer. + * + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public FloatBuffer put (float value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [position ()] = value; + position (position () + 1); + return this; + } + + /** + * Absolute get method. Reads the <code>float</code> at position + * <code>index</code>. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + */ + final public float get (int index) + { + return backing_buffer [index]; + } + + /** + * Absolute put method. Writes <code>value</value> to position + * <code>index</code> in the buffer. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public FloatBuffer put (int index, float value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [index] = value; + return this; + } + + final public ByteOrder order () + { + return ByteOrder.nativeOrder (); + } +} diff --git a/libjava/java/nio/FloatViewBufferImpl.java b/libjava/java/nio/FloatViewBufferImpl.java new file mode 100644 index 0000000..e44cd5e --- /dev/null +++ b/libjava/java/nio/FloatViewBufferImpl.java @@ -0,0 +1,154 @@ +/* FloatViewBufferImpl.java -- + Copyright (C) 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +class FloatViewBufferImpl extends FloatBuffer +{ + private boolean readOnly; + private int offset; + private ByteBuffer bb; + private ByteOrder endian; + + public FloatViewBufferImpl (ByteBuffer bb, boolean readOnly) + { + super (bb.remaining () >> 2, bb.remaining () >> 2, bb.position (), 0); + this.bb = bb; + this.readOnly = readOnly; + // FIXME: What if this is called from FloatByteBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public FloatViewBufferImpl (ByteBuffer bb, int offset, int capacity, + int limit, int position, int mark, + boolean readOnly) + { + super (limit >> 2, limit >> 2, position >> 2, mark >> 2); + this.bb = bb; + this.offset = offset; + this.readOnly = readOnly; + // FIXME: What if this is called from FloatViewBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public float get () + { + float result = bb.getFloat ((position () << 2) + offset); + position (position () + 1); + return result; + } + + public float get (int index) + { + return bb.getFloat ((index << 2) + offset); + } + + public FloatBuffer put (float value) + { + bb.putFloat ((position () << 2) + offset, value); + position (position () + 1); + return this; + } + + public FloatBuffer put (int index, float value) + { + bb.putFloat ((index << 2) + offset, value); + return this; + } + + public FloatBuffer compact () + { + if (position () > 0) + { + // Copy all data from position() to limit() to the beginning of the + // buffer, set position to end of data and limit to capacity + // XXX: This can surely be optimized, for direct and non-direct buffers + + int count = limit () - position (); + + for (int i = 0; i < count; i++) + { + bb.putFloat ((i >> 2) + offset, + bb.getFloat (((i + position ()) >> 2) + offset)); + } + + position (count); + limit (capacity ()); + } + + return this; + } + + public FloatBuffer duplicate () + { + // Create a copy of this object that shares its content + // FIXME: mark is not correct + return new FloatViewBufferImpl (bb, offset, capacity (), limit (), + position (), -1, isReadOnly ()); + } + + public FloatBuffer slice () + { + // Create a sliced copy of this object that shares its content. + return new FloatViewBufferImpl (bb, (position () >> 2) + offset, + remaining (), remaining (), 0, -1, + isReadOnly ()); + } + + public FloatBuffer asReadOnlyBuffer () + { + // Create a copy of this object that shares its content and is read-only + return new FloatViewBufferImpl (bb, (position () >> 2) + offset, + remaining (), remaining (), 0, -1, true); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public boolean isDirect () + { + return bb.isDirect (); + } + + public ByteOrder order () + { + return ByteOrder.LITTLE_ENDIAN; + } +} diff --git a/libjava/java/nio/IntBuffer.java b/libjava/java/nio/IntBuffer.java index c8e0d0f..7916785 100644 --- a/libjava/java/nio/IntBuffer.java +++ b/libjava/java/nio/IntBuffer.java @@ -35,9 +35,8 @@ 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 java.nio; -import gnu.java.nio.IntBufferImpl; +package java.nio; /** * @since 1.4 diff --git a/libjava/java/nio/IntBufferImpl.java b/libjava/java/nio/IntBufferImpl.java new file mode 100644 index 0000000..ebf33ec --- /dev/null +++ b/libjava/java/nio/IntBufferImpl.java @@ -0,0 +1,157 @@ +/* IntBufferImpl.java -- + Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +/** + * This is a Heap memory implementation + */ +public final class IntBufferImpl extends IntBuffer +{ + private boolean readOnly; + + IntBufferImpl (int capacity) + { + this (new int [capacity], 0, capacity, capacity, 0, -1, false); + } + + IntBufferImpl (int[] buffer, int offset, int capacity, int limit, int position, int mark, boolean readOnly) + { + super (buffer, offset, capacity, limit, position, mark); + this.readOnly = readOnly; + } + + public boolean isReadOnly () + { + return readOnly; + } + + public IntBuffer slice () + { + return new IntBufferImpl (backing_buffer, array_offset + position (), remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public IntBuffer duplicate () + { + return new IntBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, isReadOnly ()); + } + + public IntBuffer asReadOnlyBuffer () + { + return new IntBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, true); + } + + public IntBuffer compact () + { + int copied = 0; + + while (remaining () > 0) + { + put (copied, get ()); + copied++; + } + + position (copied); + return this; + } + + public boolean isDirect () + { + return false; + } + + /** + * Relative get method. Reads the next <code>int</code> from the buffer. + */ + final public int get () + { + int result = backing_buffer [position ()]; + position (position () + 1); + return result; + } + + /** + * Relative put method. Writes <code>value</code> to the next position + * in the buffer. + * + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public IntBuffer put (int value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [position ()] = value; + position (position () + 1); + return this; + } + + /** + * Absolute get method. Reads the <code>int</code> at position + * <code>index</code>. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + */ + final public int get (int index) + { + return backing_buffer [index]; + } + + /** + * Absolute put method. Writes <code>value</value> to position + * <code>index</code> in the buffer. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public IntBuffer put (int index, int value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [index] = value; + return this; + } + + final public ByteOrder order () + { + return ByteOrder.nativeOrder (); + } +} diff --git a/libjava/java/nio/IntViewBufferImpl.java b/libjava/java/nio/IntViewBufferImpl.java new file mode 100644 index 0000000..e60f3cb9 --- /dev/null +++ b/libjava/java/nio/IntViewBufferImpl.java @@ -0,0 +1,154 @@ +/* IntViewBufferImpl.java -- + Copyright (C) 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +class IntViewBufferImpl extends IntBuffer +{ + private boolean readOnly; + private int offset; + private ByteBuffer bb; + private ByteOrder endian; + + public IntViewBufferImpl (ByteBuffer bb, boolean readOnly) + { + super (bb.remaining () >> 2, bb.remaining () >> 2, bb.position (), 0); + this.bb = bb; + this.readOnly = readOnly; + // FIXME: What if this is called from IntByteBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public IntViewBufferImpl (ByteBuffer bb, int offset, int capacity, + int limit, int position, int mark, + boolean readOnly) + { + super (limit >> 2, limit >> 2, position >> 2, mark >> 2); + this.bb = bb; + this.offset = offset; + this.readOnly = readOnly; + // FIXME: What if this is called from IntViewBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public int get () + { + int result = bb.getInt ((position () << 2) + offset); + position (position () + 1); + return result; + } + + public int get (int index) + { + return bb.getInt ((index << 2) + offset); + } + + public IntBuffer put (int value) + { + bb.putInt ((position () << 2) + offset, value); + position (position () + 1); + return this; + } + + public IntBuffer put (int index, int value) + { + bb.putInt ((index << 2) + offset, value); + return this; + } + + public IntBuffer compact () + { + if (position () > 0) + { + // Copy all data from position() to limit() to the beginning of the + // buffer, set position to end of data and limit to capacity + // XXX: This can surely be optimized, for direct and non-direct buffers + + int count = limit () - position (); + + for (int i = 0; i < count; i++) + { + bb.putInt ((i >> 2) + offset, + bb.getInt (((i + position ()) >> 2) + offset)); + } + + position (count); + limit (capacity ()); + } + + return this; + } + + public IntBuffer duplicate () + { + // Create a copy of this object that shares its content + // FIXME: mark is not correct + return new IntViewBufferImpl (bb, offset, capacity (), limit (), + position (), -1, isReadOnly ()); + } + + public IntBuffer slice () + { + // Create a sliced copy of this object that shares its content. + return new IntViewBufferImpl (bb, (position () >> 2) + offset, + remaining (), remaining (), 0, -1, + isReadOnly ()); + } + + public IntBuffer asReadOnlyBuffer () + { + // Create a copy of this object that shares its content and is read-only + return new IntViewBufferImpl (bb, (position () >> 2) + offset, + remaining (), remaining (), 0, -1, true); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public boolean isDirect () + { + return bb.isDirect (); + } + + public ByteOrder order () + { + return ByteOrder.LITTLE_ENDIAN; + } +} diff --git a/libjava/java/nio/LongBuffer.java b/libjava/java/nio/LongBuffer.java index 8808fd5..a39a83d 100644 --- a/libjava/java/nio/LongBuffer.java +++ b/libjava/java/nio/LongBuffer.java @@ -35,9 +35,8 @@ 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 java.nio; -import gnu.java.nio.LongBufferImpl; +package java.nio; /** * @since 1.4 diff --git a/libjava/java/nio/LongBufferImpl.java b/libjava/java/nio/LongBufferImpl.java new file mode 100644 index 0000000..08d4ac5 --- /dev/null +++ b/libjava/java/nio/LongBufferImpl.java @@ -0,0 +1,157 @@ +/* LongBufferImpl.java -- + Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +/** + * This is a Heap memory implementation + */ +public final class LongBufferImpl extends LongBuffer +{ + private boolean readOnly; + + LongBufferImpl (int capacity) + { + this (new long [capacity], 0, capacity, capacity, 0, -1, false); + } + + LongBufferImpl (long[] buffer, int offset, int capacity, int limit, int position, int mark, boolean readOnly) + { + super (buffer, offset, capacity, limit, position, mark); + this.readOnly = readOnly; + } + + public boolean isReadOnly () + { + return readOnly; + } + + public LongBuffer slice () + { + return new LongBufferImpl (backing_buffer, array_offset + position (), remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public LongBuffer duplicate () + { + return new LongBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, isReadOnly ()); + } + + public LongBuffer asReadOnlyBuffer () + { + return new LongBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, true); + } + + public LongBuffer compact () + { + int copied = 0; + + while (remaining () > 0) + { + put (copied, get ()); + copied++; + } + + position (copied); + return this; + } + + public boolean isDirect () + { + return false; + } + + /** + * Relative get method. Reads the next <code>long</code> from the buffer. + */ + final public long get () + { + long result = backing_buffer [position ()]; + position (position () + 1); + return result; + } + + /** + * Relative put method. Writes <code>value</code> to the next position + * in the buffer. + * + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public LongBuffer put (long value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [position ()] = value; + position (position () + 1); + return this; + } + + /** + * Absolute get method. Reads the <code>long</code> at position + * <code>index</code>. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + */ + final public long get (int index) + { + return backing_buffer [index]; + } + + /** + * Absolute put method. Writes <code>value</value> to position + * <code>index</code> in the buffer. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public LongBuffer put (int index, long value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [index] = value; + return this; + } + + final public ByteOrder order () + { + return ByteOrder.nativeOrder (); + } +} diff --git a/libjava/java/nio/LongViewBufferImpl.java b/libjava/java/nio/LongViewBufferImpl.java new file mode 100644 index 0000000..c7ada48 --- /dev/null +++ b/libjava/java/nio/LongViewBufferImpl.java @@ -0,0 +1,154 @@ +/* LongViewBufferImpl.java -- + Copyright (C) 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +class LongViewBufferImpl extends LongBuffer +{ + private boolean readOnly; + private int offset; + private ByteBuffer bb; + private ByteOrder endian; + + public LongViewBufferImpl (ByteBuffer bb, boolean readOnly) + { + super (bb.remaining () >> 3, bb.remaining () >> 3, bb.position (), 0); + this.bb = bb; + this.readOnly = readOnly; + // FIXME: What if this is called from LongByteBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public LongViewBufferImpl (ByteBuffer bb, int offset, int capacity, + int limit, int position, int mark, + boolean readOnly) + { + super (limit >> 3, limit >> 3, position >> 3, mark >> 3); + this.bb = bb; + this.offset = offset; + this.readOnly = readOnly; + // FIXME: What if this is called from LongViewBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public long get () + { + long result = bb.getLong ((position () << 3) + offset); + position (position () + 1); + return result; + } + + public long get (int index) + { + return bb.getLong ((index << 3) + offset); + } + + public LongBuffer put (long value) + { + bb.putLong ((position () << 3) + offset, value); + position (position () + 1); + return this; + } + + public LongBuffer put (int index, long value) + { + bb.putLong ((index << 3) + offset, value); + return this; + } + + public LongBuffer compact () + { + if (position () > 0) + { + // Copy all data from position() to limit() to the beginning of the + // buffer, set position to end of data and limit to capacity + // XXX: This can surely be optimized, for direct and non-direct buffers + + int count = limit () - position (); + + for (int i = 0; i < count; i++) + { + bb.putLong ((i >> 3) + offset, + bb.getLong (((i + position ()) >> 3) + offset)); + } + + position (count); + limit (capacity ()); + } + + return this; + } + + public LongBuffer duplicate () + { + // Create a copy of this object that shares its content + // FIXME: mark is not correct + return new LongViewBufferImpl (bb, offset, capacity (), limit (), + position (), -1, isReadOnly ()); + } + + public LongBuffer slice () + { + // Create a sliced copy of this object that shares its content. + return new LongViewBufferImpl (bb, (position () >> 3) + offset, + remaining (), remaining (), 0, -1, + isReadOnly ()); + } + + public LongBuffer asReadOnlyBuffer () + { + // Create a copy of this object that shares its content and is read-only + return new LongViewBufferImpl (bb, (position () >> 3) + offset, + remaining (), remaining (), 0, -1, true); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public boolean isDirect () + { + return bb.isDirect (); + } + + public ByteOrder order () + { + return ByteOrder.LITTLE_ENDIAN; + } +} diff --git a/libjava/java/nio/ShortBuffer.java b/libjava/java/nio/ShortBuffer.java index db14b48..6bd3de9 100644 --- a/libjava/java/nio/ShortBuffer.java +++ b/libjava/java/nio/ShortBuffer.java @@ -35,9 +35,8 @@ 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 java.nio; -import gnu.java.nio.ShortBufferImpl; +package java.nio; /** * @since 1.4 diff --git a/libjava/java/nio/ShortBufferImpl.java b/libjava/java/nio/ShortBufferImpl.java new file mode 100644 index 0000000..fcfbee6 --- /dev/null +++ b/libjava/java/nio/ShortBufferImpl.java @@ -0,0 +1,157 @@ +/* ShortBufferImpl.java -- + Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +/** + * This is a Heap memory implementation + */ +public final class ShortBufferImpl extends ShortBuffer +{ + private boolean readOnly; + + ShortBufferImpl (int capacity) + { + this (new short [capacity], 0, capacity, capacity, 0, -1, false); + } + + ShortBufferImpl (short[] buffer, int offset, int capacity, int limit, int position, int mark, boolean readOnly) + { + super (buffer, offset, capacity, limit, position, mark); + this.readOnly = readOnly; + } + + public boolean isReadOnly () + { + return readOnly; + } + + public ShortBuffer slice () + { + return new ShortBufferImpl (backing_buffer, array_offset + position (), remaining (), remaining (), 0, -1, isReadOnly ()); + } + + public ShortBuffer duplicate () + { + return new ShortBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, isReadOnly ()); + } + + public ShortBuffer asReadOnlyBuffer () + { + return new ShortBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, true); + } + + public ShortBuffer compact () + { + int copied = 0; + + while (remaining () > 0) + { + put (copied, get ()); + copied++; + } + + position (copied); + return this; + } + + public boolean isDirect () + { + return false; + } + + /** + * Relative get method. Reads the next <code>short</code> from the buffer. + */ + final public short get () + { + short result = backing_buffer [position ()]; + position (position () + 1); + return result; + } + + /** + * Relative put method. Writes <code>value</code> to the next position + * in the buffer. + * + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public ShortBuffer put (short value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [position ()] = value; + position (position () + 1); + return this; + } + + /** + * Absolute get method. Reads the <code>short</code> at position + * <code>index</code>. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + */ + final public short get (int index) + { + return backing_buffer [index]; + } + + /** + * Absolute put method. Writes <code>value</value> to position + * <code>index</code> in the buffer. + * + * @exception IndexOutOfBoundsException If index is negative or not smaller + * than the buffer's limit. + * @exception ReadOnlyBufferException If this buffer is read-only. + */ + final public ShortBuffer put (int index, short value) + { + if (readOnly) + throw new ReadOnlyBufferException (); + + backing_buffer [index] = value; + return this; + } + + final public ByteOrder order () + { + return ByteOrder.nativeOrder (); + } +} diff --git a/libjava/java/nio/ShortViewBufferImpl.java b/libjava/java/nio/ShortViewBufferImpl.java new file mode 100644 index 0000000..9594642 --- /dev/null +++ b/libjava/java/nio/ShortViewBufferImpl.java @@ -0,0 +1,154 @@ +/* ShortViewBufferImpl.java -- + Copyright (C) 2003 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., 59 Temple Place, Suite 330, Boston, MA +02111-1307 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 java.nio; + +class ShortViewBufferImpl extends ShortBuffer +{ + private boolean readOnly; + private int offset; + private ByteBuffer bb; + private ByteOrder endian; + + public ShortViewBufferImpl (ByteBuffer bb, boolean readOnly) + { + super (bb.remaining () >> 1, bb.remaining () >> 1, bb.position (), 0); + this.bb = bb; + this.readOnly = readOnly; + // FIXME: What if this is called from ShortByteBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public ShortViewBufferImpl (ByteBuffer bb, int offset, int capacity, + int limit, int position, int mark, + boolean readOnly) + { + super (limit >> 1, limit >> 1, position >> 1, mark >> 1); + this.bb = bb; + this.offset = offset; + this.readOnly = readOnly; + // FIXME: What if this is called from ShortViewBufferImpl and ByteBuffer has changed its endianess ? + this.endian = bb.order (); + } + + public short get () + { + short result = bb.getShort ((position () << 1) + offset); + position (position () + 1); + return result; + } + + public short get (int index) + { + return bb.getShort ((index << 1) + offset); + } + + public ShortBuffer put (short value) + { + bb.putShort ((position () << 1) + offset, value); + position (position () + 1); + return this; + } + + public ShortBuffer put (int index, short value) + { + bb.putShort ((index << 1) + offset, value); + return this; + } + + public ShortBuffer compact () + { + if (position () > 0) + { + // Copy all data from position() to limit() to the beginning of the + // buffer, set position to end of data and limit to capacity + // XXX: This can surely be optimized, for direct and non-direct buffers + + int count = limit () - position (); + + for (int i = 0; i < count; i++) + { + bb.putShort ((i >> 1) + offset, + bb.getShort (((i + position ()) >> 1) + offset)); + } + + position (count); + limit (capacity ()); + } + + return this; + } + + public ShortBuffer duplicate () + { + // Create a copy of this object that shares its content + // FIXME: mark is not correct + return new ShortViewBufferImpl (bb, offset, capacity (), limit (), + position (), -1, isReadOnly ()); + } + + public ShortBuffer slice () + { + // Create a sliced copy of this object that shares its content. + return new ShortViewBufferImpl (bb, (position () >> 1) + offset, + remaining (), remaining (), 0, -1, + isReadOnly ()); + } + + public ShortBuffer asReadOnlyBuffer () + { + // Create a copy of this object that shares its content and is read-only + return new ShortViewBufferImpl (bb, (position () >> 1) + offset, + remaining (), remaining (), 0, -1, true); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public boolean isDirect () + { + return bb.isDirect (); + } + + public ByteOrder order () + { + return ByteOrder.LITTLE_ENDIAN; + } +} diff --git a/libjava/java/nio/natDirectByteBufferImpl.cc b/libjava/java/nio/natDirectByteBufferImpl.cc new file mode 100644 index 0000000..8286390 --- /dev/null +++ b/libjava/java/nio/natDirectByteBufferImpl.cc @@ -0,0 +1,45 @@ +// natDirectByteBufferImpl.cc + +/* Copyright (C) 2003 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include <config.h> + +#include <gcj/cni.h> +#include <jvm.h> + +#include <gnu/gcj/RawData.h> +#include <java/nio/DirectByteBufferImpl.h> + +gnu::gcj::RawData* +java::nio::DirectByteBufferImpl::allocateImpl (jint /*capacity*/) +{ + // FIXME: implement this + return 0; +} + +void +java::nio::DirectByteBufferImpl::freeImpl (gnu::gcj::RawData* /*address*/) +{ + // FIXME: implement this +} + +jbyte +java::nio::DirectByteBufferImpl::getImpl (jint /*index*/) +{ + // FIXME: implement this + // Dont forget: add offset to index + return 0; +} + +void +java::nio::DirectByteBufferImpl::putImpl (jint /*index*/, jbyte /*value*/) +{ + // FIXME: implement this + // Dont forget: add offset to index +} |