From 9d4c1565091e0017b2d4b54126f4d691d1d8681d Mon Sep 17 00:00:00 2001 From: Michael Koch Date: Tue, 25 Feb 2003 11:09:44 +0000 Subject: [PATCH] MappedByteFileBuffer.java, [...]: New files, both are not compiled yet to get not noncompiling CVS. 2003-02-25 Michael Koch * gnu/java/nio/MappedByteFileBuffer.java, gnu/java/nio/natMappedByteFileBuffer.cc: New files, both are not compiled yet to get not noncompiling CVS. From-SVN: r63403 --- libjava/ChangeLog | 6 + .../gnu/java/nio/MappedByteFileBuffer.java | 426 ++++++++++++++++++ .../gnu/java/nio/natMappedByteFileBuffer.cc | 140 ++++++ 3 files changed, 572 insertions(+) create mode 100644 libjava/gnu/java/nio/MappedByteFileBuffer.java create mode 100644 libjava/gnu/java/nio/natMappedByteFileBuffer.cc diff --git a/libjava/ChangeLog b/libjava/ChangeLog index fb5c10fa47e..5b55699f41f 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,9 @@ +2003-02-25 Michael Koch + + * gnu/java/nio/MappedByteFileBuffer.java, + gnu/java/nio/natMappedByteFileBuffer.cc: + New files, both are not compiled yet to get not noncompiling CVS. + 2003-02-24 Tom Tromey * java/util/prefs/AbstractPreferences.java (isUserNode): diff --git a/libjava/gnu/java/nio/MappedByteFileBuffer.java b/libjava/gnu/java/nio/MappedByteFileBuffer.java new file mode 100644 index 00000000000..e8399047d5a --- /dev/null +++ b/libjava/gnu/java/nio/MappedByteFileBuffer.java @@ -0,0 +1,426 @@ +/* MappedByteFileBuffer.java -- + Copyright (C) 2002 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.*; +import java.io.IOException; + +final public class MappedByteFileBuffer + extends MappedByteBuffer +{ + public long address; + boolean readOnly; + boolean direct; + public FileChannelImpl ch; + + public MappedByteFileBuffer (FileChannelImpl ch) throws IOException + { + super ((int) ch.size (), (int) ch.size (), 0, -1); + + this.ch = ch; + address = ch.address; + try { + long si = ch.size() / 1; + limit((int)si); + } catch (IOException e) { + System.err.println("failed to get size of file-channel's file"); + } + } + + public MappedByteFileBuffer (MappedByteFileBuffer b) + { + // FIXME: fix last value + super (b.capacity (), b.limit (), b.position (), -1); + + this.readOnly = b.isReadOnly (); + this.ch = b.ch; + address = b.address; + limit (b.limit ()); + } + + public boolean isReadOnly () + { + return readOnly; + } + + public static native byte nio_read_Byte_file_channel (FileChannelImpl ch, + int index, int limit, + long address); + public static native void nio_write_Byte_file_channel (FileChannelImpl ch, + int index, int limit, + byte value, + long address); + public static native short nio_read_Short_file_channel (FileChannelImpl ch, + int index, int limit, + long address); + public static native void nio_write_Short_file_channel (FileChannelImpl ch, + int index, int limit, + short value, + long address); + public static native char nio_read_Char_file_channel (FileChannelImpl ch, + int index, int limit, + long address); + public static native void nio_write_Char_file_channel (FileChannelImpl ch, + int index, int limit, + char value, + long address); + public static native int nio_read_Int_file_channel (FileChannelImpl ch, + int index, int limit, + long address); + public static native void nio_write_Int_file_channel (FileChannelImpl ch, + int index, int limit, + int value, long address); + public static native long nio_read_Long_file_channel (FileChannelImpl ch, + int index, int limit, + long address); + public static native void nio_write_Long_file_channel (FileChannelImpl ch, + int index, int limit, + long value, + long address); + public static native float nio_read_Float_file_channel (FileChannelImpl ch, + int index, int limit, + long address); + public static native void nio_write_Float_file_channel (FileChannelImpl ch, + int index, int limit, + float value, + long address); + public static native double nio_read_Double_file_channel (FileChannelImpl ch, + int index, int limit, + long address); + public static native void nio_write_Double_file_channel (FileChannelImpl ch, + int index, int limit, + double value, + long address); + + final public byte get () + { + byte a = MappedByteFileBuffer.nio_read_Byte_file_channel (ch, position (), + limit (), address); + position (position () + 1); + return a; + } + + final public ByteBuffer put (byte b) + { + MappedByteFileBuffer.nio_write_Byte_file_channel (ch, position (), limit (), + b, address); + position (position () + 1); + return this; + } + + final public byte get (int index) + { + byte a = MappedByteFileBuffer.nio_read_Byte_file_channel (ch, index, + limit (), + address); + return a; + } + + final public ByteBuffer put (int index, byte b) + { + MappedByteFileBuffer.nio_write_Byte_file_channel (ch, index, limit (), b, + address); + return this; + } + + final public ByteBuffer compact () + { + return this; + } + + final public boolean isDirect () + { + return direct; + } + + final public ByteBuffer slice () + { + MappedByteFileBuffer A = new MappedByteFileBuffer (this); + return A; + } + + public ByteBuffer duplicate () + { + return new MappedByteFileBuffer (this); + } + + public ByteBuffer asReadOnlyBuffer () + { + MappedByteFileBuffer b = new MappedByteFileBuffer (this); + b.readOnly = true; + return b; + } + + final public ByteBuffer asByteBuffer () + { +// ByteBuffer res = new MappedByteFileBuffer (ch); +// res.limit ((limit () * 1) / 1); +// return res; + throw new Error ("not implemented"); + } + + final public byte getByte () + { + byte a = nio_read_Byte_file_channel (ch, position (), limit (), address); + position (position () + 1); + return a; + } + + final public ByteBuffer putByte (byte value) + { + nio_write_Byte_file_channel (ch, position (), limit (), value, address); + position (position () + 1); + return this; + } + + final public byte getByte (int index) + { + byte a = nio_read_Byte_file_channel (ch, index, limit(), address); + return a; + } + + final public ByteBuffer putByte (int index, byte value) + { + nio_write_Byte_file_channel (ch, index, limit (), value, address); + return this; + }; + + final public CharBuffer asCharBuffer () + { +// CharBuffer res = new MappedCharFileBuffer (ch); +// res.limit ((limit () * 1) / 2); +// return res; + throw new Error ("not implemented"); + } + + final public char getChar () + { + char a = nio_read_Char_file_channel (ch, position (), limit (), address); + position (position () + 1); + return a; + } + + final public ByteBuffer putChar (char value) + { + nio_write_Char_file_channel (ch, position (), limit (), value, address); + position (position () + 1); + return this; + } + + final public char getChar (int index) + { + char a = nio_read_Char_file_channel (ch, index, limit (), address); + return a; + } + + final public ByteBuffer putChar (int index, char value) + { + nio_write_Char_file_channel (ch, index, limit (), value, address); + return this; + }; + + final public ShortBuffer asShortBuffer () + { +// ShortBuffer res = new MappedShortFileBuffer (ch); +// res.limit ((limit () * 1) / 2); +// return res; + throw new Error ("not implemented"); + } + + final public short getShort () + { + short a = nio_read_Short_file_channel (ch, position (), limit (), address); + position (position () + 1); + return a; + } + + final public ByteBuffer putShort (short value) + { + nio_write_Short_file_channel (ch, position (), limit (), value, address); + position (position () + 1); + return this; + } + + final public short getShort (int index) + { + short a = nio_read_Short_file_channel (ch, index, limit (), address); + return a; + } + + final public ByteBuffer putShort (int index, short value) + { + nio_write_Short_file_channel (ch, index, limit (), value, address); + return this; + } + + final public IntBuffer asIntBuffer () + { +// IntBuffer res = new MappedIntFileBuffer (ch); +// res.limit ((limit () * 1) / 4); +// return res; + throw new Error ("not implemented"); + } + + final public int getInt () + { + int a = nio_read_Int_file_channel (ch, position (), limit (), address); + position (position () + 1); + return a; + } + + final public ByteBuffer putInt (int value) + { + nio_write_Int_file_channel (ch, position (), limit (), value, address); + position (position () + 1); + return this; + } + + final public int getInt (int index) + { + int a = nio_read_Int_file_channel (ch, index, limit (), + address); + return a; + } + + final public ByteBuffer putInt (int index, int value) + { + nio_write_Int_file_channel (ch, index, limit (), value, address); + return this; + } + + final public LongBuffer asLongBuffer () + { +// LongBuffer res = new MappedLongFileBuffer (ch); +// res.limit ((limit () * 1) / 8); +// return res; + throw new Error ("not implemented"); + } + + final public long getLong () + { + long a = nio_read_Long_file_channel (ch, position (), limit (), address); + position (position () + 1); + return a; + } + + final public ByteBuffer putLong (long value) + { + nio_write_Long_file_channel (ch, position (), limit (), value, address); + position (position () + 1); + return this; + } + + final public long getLong (int index) + { + long a = nio_read_Long_file_channel (ch, index, limit (), address); + return a; + } + + final public ByteBuffer putLong (int index, long value) + { + nio_write_Long_file_channel (ch, index, limit (), value, address); + return this; + } + + final public FloatBuffer asFloatBuffer () + { +// FloatBuffer res = new MappedFloatFileBuffer (ch); +// res.limit ((limit () * 1) / 4); +// return res; + throw new Error ("not implemented"); + } + + final public float getFloat () + { + float a = nio_read_Float_file_channel (ch, position (), limit (), address); + position (position () + 1); + return a; + } + + final public ByteBuffer putFloat (float value) + { + nio_write_Float_file_channel (ch, position (), limit (), value, address); + position (position () + 1); + return this; + } + + final public float getFloat (int index) + { + float a = nio_read_Float_file_channel (ch, index, limit (), address); + return a; + } + + final public ByteBuffer putFloat (int index, float value) + { + nio_write_Float_file_channel (ch, index, limit (), value, address); + return this; + } + + final public DoubleBuffer asDoubleBuffer () + { +// DoubleBuffer res = new MappedDoubleFileBuffer (ch); +// res.limit ((limit () * 1) / 8); +// return res; + throw new Error ("not implemented"); + } + + final public double getDouble () + { + double a = nio_read_Double_file_channel (ch, position (), limit (), address); + position (position () + 1); + return a; + } + + final public ByteBuffer putDouble (double value) + { + nio_write_Double_file_channel (ch, position (), limit (), value, address); + position (position () + 1); + return this; + } + + final public double getDouble (int index) + { + double a = nio_read_Double_file_channel (ch, index, limit (), address); + return a; + } + + final public ByteBuffer putDouble (int index, double value) + { + nio_write_Double_file_channel (ch, index, limit (), value, address); + return this; + } +} diff --git a/libjava/gnu/java/nio/natMappedByteFileBuffer.cc b/libjava/gnu/java/nio/natMappedByteFileBuffer.cc new file mode 100644 index 00000000000..6f2eee2107d --- /dev/null +++ b/libjava/gnu/java/nio/natMappedByteFileBuffer.cc @@ -0,0 +1,140 @@ +// natMappedByteFileBuffer.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 +#include + +#ifdef HAVE_UNISTD_H +#include +#endif + +#ifdef HAVE_FCNTL_H +#include +#endif + +#include +#include + +jbyte +gnu::java::nio::MappedByteFileBuffer::nio_read_Byte_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +jchar +gnu::java::nio::MappedByteFileBuffer::nio_read_Char_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +jdouble +gnu::java::nio::MappedByteFileBuffer::nio_read_Double_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +jfloat +gnu::java::nio::MappedByteFileBuffer::nio_read_Float_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +jint +gnu::java::nio::MappedByteFileBuffer::nio_read_Int_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +jlong +gnu::java::nio::MappedByteFileBuffer::nio_read_Long_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +jshort +gnu::java::nio::MappedByteFileBuffer::nio_read_Short_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +void +gnu::java::nio::MappedByteFileBuffer::nio_write_Byte_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jbyte, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +void +gnu::java::nio::MappedByteFileBuffer::nio_write_Char_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jchar, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +void +gnu::java::nio::MappedByteFileBuffer::nio_write_Double_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jdouble, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +void +gnu::java::nio::MappedByteFileBuffer::nio_write_Float_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jfloat, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +void +gnu::java::nio::MappedByteFileBuffer::nio_write_Int_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jint, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +void +gnu::java::nio::MappedByteFileBuffer::nio_write_Long_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jlong, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} + +void +gnu::java::nio::MappedByteFileBuffer::nio_write_Short_file_channel + (gnu::java::nio::FileChannelImpl*, + jint, jint, jshort, jlong) +{ + throw new ::java::lang::Error (_Jv_NewStringUTF ("not implemented")); +} -- 2.30.2