From 8e9833f3d57b2e209870aef68ae6b17b39a114a8 Mon Sep 17 00:00:00 2001 From: mkoch Date: Mon, 18 Nov 2002 13:56:59 +0000 Subject: [PATCH] 2002-11-18 Michael Koch * gnu/java/nio/ByteBufferImpl.java, gnu/java/nio/CharBufferImpl.java, gnu/java/nio/DatagramChannelImpl.java, gnu/java/nio/DoubleBufferImpl.java, gnu/java/nio/FileChannelImpl.java, gnu/java/nio/FloatBufferImpl.java, gnu/java/nio/IntBufferImpl.java, gnu/java/nio/LongBufferImpl.java, gnu/java/nio/PipeImpl.java, gnu/java/nio/SelectionKeyImpl.java, gnu/java/nio/SelectorImpl.java, gnu/java/nio/SelectorProviderImpl.java, gnu/java/nio/ServerSocketChannelImpl.java, gnu/java/nio/ShortBufferImpl.java, gnu/java/nio/SocketChannelImpl.java, java/nio/DoubleBuffer.java, java/nio/FloatBuffer.java, java/nio/IntBuffer.java, java/nio/LongBuffer.java, java/nio/ShortBuffer.java, java/nio/channels/FileChannel.java: New files. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@59216 138bc75d-0d04-0410-961f-82ee72b054a4 --- libjava/ChangeLog | 24 +++ libjava/gnu/java/nio/ByteBufferImpl.java | 214 ++++++++++++++++++++ libjava/gnu/java/nio/CharBufferImpl.java | 223 +++++++++++++++++++++ libjava/gnu/java/nio/DatagramChannelImpl.java | 110 ++++++++++ libjava/gnu/java/nio/DoubleBufferImpl.java | 212 ++++++++++++++++++++ libjava/gnu/java/nio/FileChannelImpl.java | 234 ++++++++++++++++++++++ libjava/gnu/java/nio/FloatBufferImpl.java | 218 ++++++++++++++++++++ libjava/gnu/java/nio/IntBufferImpl.java | 206 +++++++++++++++++++ libjava/gnu/java/nio/LongBufferImpl.java | 212 ++++++++++++++++++++ libjava/gnu/java/nio/PipeImpl.java | 57 ++++++ libjava/gnu/java/nio/SelectionKeyImpl.java | 83 ++++++++ libjava/gnu/java/nio/SelectorImpl.java | 204 +++++++++++++++++++ libjava/gnu/java/nio/SelectorProviderImpl.java | 77 +++++++ libjava/gnu/java/nio/ServerSocketChannelImpl.java | 118 +++++++++++ libjava/gnu/java/nio/ShortBufferImpl.java | 212 ++++++++++++++++++++ libjava/gnu/java/nio/SocketChannelImpl.java | 234 ++++++++++++++++++++++ libjava/java/nio/DoubleBuffer.java | 225 +++++++++++++++++++++ libjava/java/nio/FloatBuffer.java | 224 +++++++++++++++++++++ libjava/java/nio/IntBuffer.java | 225 +++++++++++++++++++++ libjava/java/nio/LongBuffer.java | 226 +++++++++++++++++++++ libjava/java/nio/ShortBuffer.java | 226 +++++++++++++++++++++ libjava/java/nio/channels/FileChannel.java | 135 +++++++++++++ 22 files changed, 3899 insertions(+) create mode 100644 libjava/gnu/java/nio/ByteBufferImpl.java create mode 100644 libjava/gnu/java/nio/CharBufferImpl.java create mode 100644 libjava/gnu/java/nio/DatagramChannelImpl.java create mode 100644 libjava/gnu/java/nio/DoubleBufferImpl.java create mode 100644 libjava/gnu/java/nio/FileChannelImpl.java create mode 100644 libjava/gnu/java/nio/FloatBufferImpl.java create mode 100644 libjava/gnu/java/nio/IntBufferImpl.java create mode 100644 libjava/gnu/java/nio/LongBufferImpl.java create mode 100644 libjava/gnu/java/nio/PipeImpl.java create mode 100644 libjava/gnu/java/nio/SelectionKeyImpl.java create mode 100644 libjava/gnu/java/nio/SelectorImpl.java create mode 100644 libjava/gnu/java/nio/SelectorProviderImpl.java create mode 100644 libjava/gnu/java/nio/ServerSocketChannelImpl.java create mode 100644 libjava/gnu/java/nio/ShortBufferImpl.java create mode 100644 libjava/gnu/java/nio/SocketChannelImpl.java create mode 100644 libjava/java/nio/DoubleBuffer.java create mode 100644 libjava/java/nio/FloatBuffer.java create mode 100644 libjava/java/nio/IntBuffer.java create mode 100644 libjava/java/nio/LongBuffer.java create mode 100644 libjava/java/nio/ShortBuffer.java create mode 100644 libjava/java/nio/channels/FileChannel.java diff --git a/libjava/ChangeLog b/libjava/ChangeLog index f14e39e..85215d5 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,5 +1,29 @@ 2002-11-18 Michael Koch + * gnu/java/nio/ByteBufferImpl.java, + gnu/java/nio/CharBufferImpl.java, + gnu/java/nio/DatagramChannelImpl.java, + gnu/java/nio/DoubleBufferImpl.java, + gnu/java/nio/FileChannelImpl.java, + gnu/java/nio/FloatBufferImpl.java, + gnu/java/nio/IntBufferImpl.java, + gnu/java/nio/LongBufferImpl.java, + gnu/java/nio/PipeImpl.java, + gnu/java/nio/SelectionKeyImpl.java, + gnu/java/nio/SelectorImpl.java, + gnu/java/nio/SelectorProviderImpl.java, + gnu/java/nio/ServerSocketChannelImpl.java, + gnu/java/nio/ShortBufferImpl.java, + gnu/java/nio/SocketChannelImpl.java, + java/nio/DoubleBuffer.java, + java/nio/FloatBuffer.java, + java/nio/IntBuffer.java, + java/nio/LongBuffer.java, + java/nio/ShortBuffer.java, + java/nio/channels/FileChannel.java: New files. + +2002-11-18 Michael Koch + * Makefile.am (ordinary_java_source_files): Added java/nio/ReadOnlyBufferException.java and java/nio/channels/ClosedSelectorException.java. diff --git a/libjava/gnu/java/nio/ByteBufferImpl.java b/libjava/gnu/java/nio/ByteBufferImpl.java new file mode 100644 index 0000000..e27207e --- /dev/null +++ b/libjava/gnu/java/nio/ByteBufferImpl.java @@ -0,0 +1,214 @@ +/* ByteBufferImpl.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.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; + +public final class ByteBufferImpl extends ByteBuffer +{ + private byte[] backing_buffer; + private int array_offset; + private boolean ro; + + public ByteBufferImpl (int cap, int off, int lim) + { + this.cap = cap; + position (off); + limit (lim); + this.backing_buffer = new byte[cap]; + } + + public ByteBufferImpl (byte[] array, int off, int lim) + { + this.cap = array.length; + position (off); + limit (lim); + this.backing_buffer = array; + } + + public ByteBufferImpl (ByteBufferImpl copy) + { + this.cap = copy.capacity (); + position (copy.position ()); + limit (copy.limit ()); + ro = copy.ro; + backing_buffer = copy.backing_buffer; + } + + void inc_pos (int toAdd) + { + position (position () + toAdd); + } + +// private static native byte[] nio_cast(byte[]copy); +// private static native byte[] nio_cast(char[]copy); +// private static native byte[] nio_cast(short[]copy); +// private static native byte[] nio_cast(long[]copy); +// private static native byte[] nio_cast(int[]copy); +// private static native byte[] nio_cast(float[]copy); +// private static native byte[] nio_cast(double[]copy); + + private static byte[] nio_cast(byte[]copy) { return null; }; + private static byte[] nio_cast(char[]copy) { return null; }; + private static byte[] nio_cast(short[]copy) { return null; }; + private static byte[] nio_cast(long[]copy) { return null; }; + private static byte[] nio_cast(int[]copy) { return null; }; + private static byte[] nio_cast(float[]copy) { return null; }; + private static byte[] nio_cast(double[]copy) { return null; }; + + ByteBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(ByteBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(ByteBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(ByteBufferImpl b, int index, int limit, byte value) { }; + public ByteBuffer asByteBuffer() { ByteBufferImpl res = new ByteBufferImpl(backing_buffer); res.limit((limit()*1)/1); return res; } + + ByteBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Char(ByteBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(ByteBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(ByteBufferImpl b, int index, int limit, char value) { }; + public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/1); return res; } + + ByteBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Short(ByteBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(ByteBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(ByteBufferImpl b, int index, int limit, short value) { }; + public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/1); return res; } + + ByteBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Int(ByteBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(ByteBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(ByteBufferImpl b, int index, int limit, int value) { }; + public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/1); return res; } + + ByteBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Long(ByteBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(ByteBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(ByteBufferImpl b, int index, int limit, long value) { }; + public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/1); return res; } + + ByteBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Float(ByteBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(ByteBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(ByteBufferImpl b, int index, int limit, float value) { }; + public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/1); return res; } + + ByteBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(ByteBufferImpl b, int index, int limit); +// private static native void nio_put_Double(ByteBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(ByteBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(ByteBufferImpl b, int index, int limit, double value) { }; + public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/1); return res; } + + public boolean isReadOnly() + { + return ro; + } + + public ByteBuffer slice() + { + ByteBufferImpl A = new ByteBufferImpl(this); + A.array_offset = position(); + return A; + } + + public ByteBuffer duplicate() + { + return new ByteBufferImpl(this); + } + + public ByteBuffer asReadOnlyBuffer() + { + ByteBufferImpl a = new ByteBufferImpl(this); + a.ro = true; + return a; + } + + public ByteBuffer compact() + { + return this; + } + + public boolean isDirect() + { + return backing_buffer != null; + } + + final public byte get() + { + byte e = backing_buffer[position()]; + position(position()+1); + return e; + } + + final public ByteBuffer put(byte b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + + final public byte get(int index) + { + return backing_buffer[index]; + } + + final public ByteBuffer put(int index, byte b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public ByteBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public ByteBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public ByteBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public ByteBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public ByteBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public ByteBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public ByteBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public ByteBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public ByteBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public ByteBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public ByteBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public ByteBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; }; +} diff --git a/libjava/gnu/java/nio/CharBufferImpl.java b/libjava/gnu/java/nio/CharBufferImpl.java new file mode 100644 index 0000000..5253646 --- /dev/null +++ b/libjava/gnu/java/nio/CharBufferImpl.java @@ -0,0 +1,223 @@ +/* CharBufferImpl.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.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; + +public final class CharBufferImpl extends CharBuffer +{ + private int array_offset; + private boolean ro; + + public CharBufferImpl(int cap, int off, int lim) + { + this.backing_buffer = new char[cap]; + this.cap = cap; + this.position(off); + this.limit(lim); + } + + public CharBufferImpl(char[] array, int off, int lim) + { + this.backing_buffer = array; + this.cap = array.length; + this.position(off); + this.limit(lim); + } + + public CharBufferImpl (CharBufferImpl copy) + { + backing_buffer = copy.backing_buffer; + ro = copy.ro; + position (copy.position ()); + limit (copy.limit()); + } + + void inc_pos (int a) + { + position (position () + a); + } + +// private static native char[] nio_cast(byte[]copy); +// private static native char[] nio_cast(char[]copy); +// private static native char[] nio_cast(short[]copy); +// private static native char[] nio_cast(long[]copy); +// private static native char[] nio_cast(int[]copy); +// private static native char[] nio_cast(float[]copy); +// private static native char[] nio_cast(double[]copy); + + private static char[] nio_cast(byte[]copy) { return null; }; + private static char[] nio_cast(char[]copy) { return null; }; + private static char[] nio_cast(short[]copy) { return null; }; + private static char[] nio_cast(long[]copy) { return null; }; + private static char[] nio_cast(int[]copy) { return null; }; + private static char[] nio_cast(float[]copy) { return null; }; + private static char[] nio_cast(double[]copy) { return null; }; + + CharBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(CharBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(CharBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(CharBufferImpl b, int index, int limit, byte value) { }; + public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/2); return res; } + + CharBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Char(CharBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(CharBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(CharBufferImpl b, int index, int limit, char value) { }; + public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; } + + CharBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Short(CharBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(CharBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(CharBufferImpl b, int index, int limit, short value) { }; + public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; } + + CharBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Int(CharBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(CharBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(CharBufferImpl b, int index, int limit, int value) { }; + public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; } + + CharBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Long(CharBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(CharBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(CharBufferImpl b, int index, int limit, long value) { }; + public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; } + + CharBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Float(CharBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(CharBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(CharBufferImpl b, int index, int limit, float value) { }; + public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; } + + CharBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(CharBufferImpl b, int index, int limit); +// private static native void nio_put_Double(CharBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(CharBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(CharBufferImpl b, int index, int limit, double value) { }; + public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; } + + public boolean isReadOnly() + { + return ro; + } + public CharBuffer slice() + { + CharBufferImpl A = new CharBufferImpl(this); + A.array_offset = position(); + return A; + } + public CharBuffer duplicate() + { + return new CharBufferImpl(this); + } + public CharBuffer asReadOnlyBuffer() + { + CharBufferImpl a = new CharBufferImpl(this); + a.ro = true; + return a; + } + public CharBuffer compact() + { + return this; + } + public boolean isDirect() + { + return backing_buffer != null; + } + final public char get() + { + char e = backing_buffer[position()]; + position(position()+1); + return e; + } + final public CharBuffer put(char b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + final public char get(int index) + { + return backing_buffer[index]; + } + final public java.nio. CharBuffer put(int index, char b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { return get(); } final public java.nio. CharBuffer putChar(char value) { return put(value); } final public char getChar(int index) { return get(index); } final public java.nio. CharBuffer putChar(int index, char value) { return put(index, value); }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. CharBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. CharBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. CharBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. CharBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. CharBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. CharBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. CharBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. CharBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. CharBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. CharBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; }; + + public String toString() + { + if (backing_buffer != null) + { + return new String(backing_buffer, position(), limit()); + } + return super.toString(); + } + + public final ByteOrder order() + { + return endian; + } + + public CharSequence subSequence(int a, int b) + { + return null; + } +} diff --git a/libjava/gnu/java/nio/DatagramChannelImpl.java b/libjava/gnu/java/nio/DatagramChannelImpl.java new file mode 100644 index 0000000..b192ef2 --- /dev/null +++ b/libjava/gnu/java/nio/DatagramChannelImpl.java @@ -0,0 +1,110 @@ +/* DatagramChannelImpl.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.net.DatagramSocket; +import java.net.SocketAddress; +import java.nio.ByteBuffer; +import java.nio.channels.DatagramChannel; +import java.nio.channels.spi.SelectorProvider; + +public class DatagramChannelImpl extends DatagramChannel +{ + protected DatagramChannelImpl (SelectorProvider provider) + { + super (provider); + } + + protected void implCloseSelectableChannel () + { + } + + protected void implConfigureBlocking (boolean block) + { + } + + public int write (ByteBuffer src) + { + return 0; + } + + public long write (ByteBuffer[] srcs, int offset, int length) + { + return 0; + } + + public int read (ByteBuffer dst) + { + return 0; + } + + public DatagramChannel connect (SocketAddress remote) + { + return null; + } + + public DatagramChannel disconnect () + { + return null; + } + + public boolean isConnected () + { + return false; + } + + public long read (ByteBuffer[] dsts, int offset, int length) + { + return 0; + } + + public SocketAddress receive (ByteBuffer dst) + { + return null; + } + + public int send (ByteBuffer src, SocketAddress target) + { + return 0; + } + + public DatagramSocket socket () + { + return null; + } +} diff --git a/libjava/gnu/java/nio/DoubleBufferImpl.java b/libjava/gnu/java/nio/DoubleBufferImpl.java new file mode 100644 index 0000000..4062867 --- /dev/null +++ b/libjava/gnu/java/nio/DoubleBufferImpl.java @@ -0,0 +1,212 @@ +/* DoubleBufferImpl.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.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; + +public final class DoubleBufferImpl extends DoubleBuffer +{ + private int array_offset; + private boolean ro; + + public DoubleBufferImpl(int cap, int off, int lim) + { + this.backing_buffer = new double[cap]; + this.cap = cap; + this.position(off); + this.limit(lim); + } + + public DoubleBufferImpl(double[] array, int off, int lim) + { + this.backing_buffer = array; + this.cap = array.length; + this.position(off); + this.limit(lim); + } + + public DoubleBufferImpl(DoubleBufferImpl copy) + { + backing_buffer = copy.backing_buffer; + ro = copy.ro; + position(copy.position()); + limit(copy.limit()); + } + + void inc_pos(int a) + { + position(position() + a); + } + +// private static native double[] nio_cast(byte[]copy); +// private static native double[] nio_cast(char[]copy); +// private static native double[] nio_cast(short[]copy); +// private static native double[] nio_cast(long[]copy); +// private static native double[] nio_cast(int[]copy); +// private static native double[] nio_cast(float[]copy); +// private static native double[] nio_cast(double[]copy); + + private static double[] nio_cast(byte[]copy) { return null; }; + private static double[] nio_cast(char[]copy) { return null; }; + private static double[] nio_cast(short[]copy) { return null; }; + private static double[] nio_cast(long[]copy) { return null; }; + private static double[] nio_cast(int[]copy) { return null; }; + private static double[] nio_cast(float[]copy) { return null; }; + private static double[] nio_cast(double[]copy) { return null; }; + + DoubleBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native byte nio_get_Byte(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Byte(DoubleBufferImpl b, int index, int limit, byte value); + private static byte nio_get_Byte(DoubleBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Byte(DoubleBufferImpl b, int index, int limit, byte value) { }; + public ByteBuffer asByteBuffer() { ByteBufferImpl res = new ByteBufferImpl(backing_buffer); res.limit((limit()*1)/8); return res; } + + DoubleBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native char nio_get_Char(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Char(DoubleBufferImpl b, int index, int limit, char value); + private static char nio_get_Char(DoubleBufferImpl b, int index, int limit) { return ' '; }; + private static void nio_put_Char(DoubleBufferImpl b, int index, int limit, char value) { }; + public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; } + + DoubleBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native short nio_get_Short(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Short(DoubleBufferImpl b, int index, int limit, short value); + private static short nio_get_Short(DoubleBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Short(DoubleBufferImpl b, int index, int limit, short value) { }; + public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; } + + DoubleBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native int nio_get_Int(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Int(DoubleBufferImpl b, int index, int limit, int value); + private static int nio_get_Int(DoubleBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Int(DoubleBufferImpl b, int index, int limit, int value) { }; + public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; } + + DoubleBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native long nio_get_Long(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Long(DoubleBufferImpl b, int index, int limit, long value); + private static long nio_get_Long(DoubleBufferImpl b, int index, int limit) { return 0; }; + private static void nio_put_Long(DoubleBufferImpl b, int index, int limit, long value) { }; + public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; } + + DoubleBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native float nio_get_Float(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Float(DoubleBufferImpl b, int index, int limit, float value); + private static float nio_get_Float(DoubleBufferImpl b, int index, int limit) { return 0.0f; }; + private static void nio_put_Float(DoubleBufferImpl b, int index, int limit, float value) { }; + public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; } + + DoubleBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; } +// private static native double nio_get_Double(DoubleBufferImpl b, int index, int limit); +// private static native void nio_put_Double(DoubleBufferImpl b, int index, int limit, double value); + private static double nio_get_Double(DoubleBufferImpl b, int index, int limit) { return 0.0d; }; + private static void nio_put_Double(DoubleBufferImpl b, int index, int limit, double value) { }; + public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; } + + public boolean isReadOnly() + { + return ro; + } + + public DoubleBuffer slice() + { + DoubleBufferImpl A = new DoubleBufferImpl(this); + A.array_offset = position(); + return A; + } + + public DoubleBuffer duplicate() + { + return new DoubleBufferImpl(this); + } + + public DoubleBuffer asReadOnlyBuffer() + { + DoubleBufferImpl a = new DoubleBufferImpl(this); + a.ro = true; + return a; + } + + public DoubleBuffer compact() + { + return this; + } + + public boolean isDirect() + { + return backing_buffer != null; + } + + final public double get() + { + double e = backing_buffer[position()]; + position(position()+1); + return e; + } + + final public DoubleBuffer put(double b) + { + backing_buffer[position()] = b; + position(position()+1); + return this; + } + + final public double get(int index) + { + return backing_buffer[index]; + } + + final public DoubleBuffer put(int index, double b) + { + backing_buffer[index] = b; + return this; + } + + final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public DoubleBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public DoubleBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; }; + final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public DoubleBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public DoubleBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; }; + final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public DoubleBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public DoubleBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; }; + final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public DoubleBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public DoubleBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; }; + final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public DoubleBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public DoubleBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; }; + final public double getDouble() { return get(); } final public DoubleBuffer putDouble(double value) { return put(value); } final public double getDouble(int index) { return get(index); } final public DoubleBuffer putDouble(int index, double value) { return put(index, value); }; +} diff --git a/libjava/gnu/java/nio/FileChannelImpl.java b/libjava/gnu/java/nio/FileChannelImpl.java new file mode 100644 index 0000000..26b48e5 --- /dev/null +++ b/libjava/gnu/java/nio/FileChannelImpl.java @@ -0,0 +1,234 @@ +/* FileChannelImpl.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.io.EOFException; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.RandomAccessFile; +import java.nio.ByteBuffer; +import java.nio.MappedByteBuffer; +import java.nio.channels.FileChannel; + +/** + * This file is not user visible ! + * But alas, Java does not have a concept of friendly packages + * so this class is public. + * Instances of this class are created by invoking getChannel + * Upon a Input/Output/RandomAccessFile object. + */ + +public class FileChannelImpl extends FileChannel +{ + public long address; + public int length; + public int fd; + public MappedByteBuffer buf; + public Object file_obj; // just to keep it live... + + /** + * This method came from java.io.RandomAccessFile + * It is private there so we will repeat it here. + */ +// private native long lengthInternal (int native_fd) throws IOException; + private long lengthInternal (int native_fd) throws IOException + { + return 0; + }; + + public FileChannelImpl (int fd, Object obj) + { + this.fd = fd; + this.file_obj = obj; + } + + public long size () throws IOException + { + return lengthInternal (fd); + } + + protected void implCloseChannel() throws IOException + { + if (address != 0) + { + nio_unmmap_file (fd, address, (int) length); + } + + // FIXME + fd = 0; + + if (file_obj instanceof RandomAccessFile) + { + RandomAccessFile o = (RandomAccessFile) file_obj; + o.close(); + } + else if (file_obj instanceof FileInputStream) + { + FileInputStream o = (FileInputStream) file_obj; + o.close(); + } + else if (file_obj instanceof FileOutputStream) + { + FileOutputStream o = (FileOutputStream) file_obj; + o.close(); + } + } + + public int read (ByteBuffer dst) throws IOException + { + int w = 0; + int s = (int)size(); + + if (buf == null) + { + throw new EOFException("file not mapped"); + } + + for (int i=0; i