From 5560b019e4e1d6f86fe4ad1166e3a0c16fff699a Mon Sep 17 00:00:00 2001 From: Michael Koch Date: Mon, 12 May 2003 18:32:17 +0000 Subject: [PATCH] CharViewBufferImpl.java, [...]: New files, not yet to be compiled. 2003-05-12 Michael Koch * gnu/java/nio/CharViewBufferImpl.java, gnu/java/nio/DirectByteBufferImpl.java, gnu/java/nio/DoubleViewBufferImpl.java, gnu/java/nio/FloatViewBufferImpl.java, gnu/java/nio/IntViewBufferImpl.java, gnu/java/nio/LongViewBufferImpl.java, gnu/java/nio/ShortViewBufferImpl.java, gnu/java/nio/natDirectByteBufferImpl.cc: New files, not yet to be compiled. From-SVN: r66727 --- libjava/ChangeLog | 12 + libjava/gnu/java/nio/CharViewBufferImpl.java | 167 +++++++ .../gnu/java/nio/DirectByteBufferImpl.java | 423 ++++++++++++++++++ .../gnu/java/nio/DoubleViewBufferImpl.java | 156 +++++++ libjava/gnu/java/nio/FloatViewBufferImpl.java | 156 +++++++ libjava/gnu/java/nio/IntViewBufferImpl.java | 156 +++++++ libjava/gnu/java/nio/LongViewBufferImpl.java | 156 +++++++ libjava/gnu/java/nio/ShortViewBufferImpl.java | 156 +++++++ .../gnu/java/nio/natDirectByteBufferImpl.cc | 44 ++ 9 files changed, 1426 insertions(+) create mode 100644 libjava/gnu/java/nio/CharViewBufferImpl.java create mode 100644 libjava/gnu/java/nio/DirectByteBufferImpl.java create mode 100644 libjava/gnu/java/nio/DoubleViewBufferImpl.java create mode 100644 libjava/gnu/java/nio/FloatViewBufferImpl.java create mode 100644 libjava/gnu/java/nio/IntViewBufferImpl.java create mode 100644 libjava/gnu/java/nio/LongViewBufferImpl.java create mode 100644 libjava/gnu/java/nio/ShortViewBufferImpl.java create mode 100644 libjava/gnu/java/nio/natDirectByteBufferImpl.cc diff --git a/libjava/ChangeLog b/libjava/ChangeLog index fc89fb9d29f..584defb5b30 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,15 @@ +2003-05-12 Michael Koch + + * gnu/java/nio/CharViewBufferImpl.java, + gnu/java/nio/DirectByteBufferImpl.java, + gnu/java/nio/DoubleViewBufferImpl.java, + gnu/java/nio/FloatViewBufferImpl.java, + gnu/java/nio/IntViewBufferImpl.java, + gnu/java/nio/LongViewBufferImpl.java, + gnu/java/nio/ShortViewBufferImpl.java, + gnu/java/nio/natDirectByteBufferImpl.cc: + New files, not yet to be compiled. + 2003-05-10 Michael Koch * javax/swing/plaf/ButtonUI.java, diff --git a/libjava/gnu/java/nio/CharViewBufferImpl.java b/libjava/gnu/java/nio/CharViewBufferImpl.java new file mode 100644 index 00000000000..62c8fdd9dc9 --- /dev/null +++ b/libjava/gnu/java/nio/CharViewBufferImpl.java @@ -0,0 +1,167 @@ +/* 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 gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.CharBuffer; + +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, limit, offset, position); + this.bb = bb; + 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); + 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/gnu/java/nio/DirectByteBufferImpl.java b/libjava/gnu/java/nio/DirectByteBufferImpl.java new file mode 100644 index 00000000000..0c08ab489db --- /dev/null +++ b/libjava/gnu/java/nio/DirectByteBufferImpl.java @@ -0,0 +1,423 @@ +/* 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 gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; +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 == 0) + 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) ((((int) value) & 0xff00000000000000) >> 56)); + put ((byte) ((((int) value) & 0x00ff000000000000) >> 48)); + put ((byte) ((((int) value) & 0x0000ff0000000000) >> 40)); + put ((byte) ((((int) value) & 0x000000ff00000000) >> 32)); + put ((byte) ((((int) value) & 0x00000000ff000000) >> 24)); + put ((byte) ((((int) value) & 0x0000000000ff0000) >> 16)); + put ((byte) ((((int) value) & 0x000000000000ff00) >> 8)); + put ((byte) (((int) value) & 0x00000000000000ff)); + 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) ((((int) value) & 0xff00000000000000) >> 56)); + put (index + 1, (byte) ((((int) value) & 0x00ff000000000000) >> 48)); + put (index + 2, (byte) ((((int) value) & 0x0000ff0000000000) >> 40)); + put (index + 3, (byte) ((((int) value) & 0x000000ff00000000) >> 32)); + put (index + 4, (byte) ((((int) value) & 0x00000000ff000000) >> 24)); + put (index + 5, (byte) ((((int) value) & 0x0000000000ff0000) >> 16)); + put (index + 6, (byte) ((((int) value) & 0x000000000000ff00) >> 8)); + put (index + 7, (byte) (((int) value) & 0x00000000000000ff)); + 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) ((((int) value) & 0xff00000000000000) >> 56)); + put ((byte) ((((int) value) & 0x00ff000000000000) >> 48)); + put ((byte) ((((int) value) & 0x0000ff0000000000) >> 40)); + put ((byte) ((((int) value) & 0x000000ff00000000) >> 32)); + put ((byte) ((((int) value) & 0x00000000ff000000) >> 24)); + put ((byte) ((((int) value) & 0x0000000000ff0000) >> 16)); + put ((byte) ((((int) value) & 0x000000000000ff00) >> 8)); + put ((byte) (((int) value) & 0x00000000000000ff)); + 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) ((((int) value) & 0xff00000000000000) >> 56)); + put (index + 1, (byte) ((((int) value) & 0x00ff000000000000) >> 48)); + put (index + 2, (byte) ((((int) value) & 0x0000ff0000000000) >> 40)); + put (index + 3, (byte) ((((int) value) & 0x000000ff00000000) >> 32)); + put (index + 4, (byte) ((((int) value) & 0x00000000ff000000) >> 24)); + put (index + 5, (byte) ((((int) value) & 0x0000000000ff0000) >> 16)); + put (index + 6, (byte) ((((int) value) & 0x000000000000ff00) >> 8)); + put (index + 7, (byte) (((int) value) & 0x00000000000000ff)); + return this; + } +} diff --git a/libjava/gnu/java/nio/DoubleViewBufferImpl.java b/libjava/gnu/java/nio/DoubleViewBufferImpl.java new file mode 100644 index 00000000000..d34e8866124 --- /dev/null +++ b/libjava/gnu/java/nio/DoubleViewBufferImpl.java @@ -0,0 +1,156 @@ +/* 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 gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.DoubleBuffer; + +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, limit, offset, position); + this.bb = bb; + 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); + 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/gnu/java/nio/FloatViewBufferImpl.java b/libjava/gnu/java/nio/FloatViewBufferImpl.java new file mode 100644 index 00000000000..78299f97307 --- /dev/null +++ b/libjava/gnu/java/nio/FloatViewBufferImpl.java @@ -0,0 +1,156 @@ +/* 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 gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.FloatBuffer; + +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, limit, offset, position); + this.bb = bb; + 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); + 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/gnu/java/nio/IntViewBufferImpl.java b/libjava/gnu/java/nio/IntViewBufferImpl.java new file mode 100644 index 00000000000..0bf5a08247b --- /dev/null +++ b/libjava/gnu/java/nio/IntViewBufferImpl.java @@ -0,0 +1,156 @@ +/* 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 gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.IntBuffer; + +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, limit, offset, position); + this.bb = bb; + 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); + 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/gnu/java/nio/LongViewBufferImpl.java b/libjava/gnu/java/nio/LongViewBufferImpl.java new file mode 100644 index 00000000000..2311fee5945 --- /dev/null +++ b/libjava/gnu/java/nio/LongViewBufferImpl.java @@ -0,0 +1,156 @@ +/* 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 gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.LongBuffer; + +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, limit, offset, position); + this.bb = bb; + 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); + 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/gnu/java/nio/ShortViewBufferImpl.java b/libjava/gnu/java/nio/ShortViewBufferImpl.java new file mode 100644 index 00000000000..91cbff7b0fb --- /dev/null +++ b/libjava/gnu/java/nio/ShortViewBufferImpl.java @@ -0,0 +1,156 @@ +/* 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 gnu.java.nio; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.ShortBuffer; + +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, limit, offset, position); + this.bb = bb; + 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); + 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/gnu/java/nio/natDirectByteBufferImpl.cc b/libjava/gnu/java/nio/natDirectByteBufferImpl.cc new file mode 100644 index 00000000000..317bc226b6c --- /dev/null +++ b/libjava/gnu/java/nio/natDirectByteBufferImpl.cc @@ -0,0 +1,44 @@ +// 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 + +#include +#include + +#include + +jlong +gnu::java::nio::DirectByteBufferImpl::allocateImpl (jint capacity) +{ + // FIXME: implement this + return 0; +} + +void +gnu::java::nio::DirectByteBufferImpl::freeImpl (jlong address) +{ + // FIXME: implement this +} + +jbyte +gnu::java::nio::DirectByteBufferImpl::getImpl (jint index) +{ + // FIXME: implement this + // Dont forget: add offset to index + return 0; +} + +void +gnu::java::nio::DirectByteBufferImpl::putImpl (jint index, jbyte value) +{ + // FIXME: implement this + // Dont forget: add offset to index +} -- 2.30.2