diff options
Diffstat (limited to 'libjava/java')
| -rw-r--r-- | libjava/java/nio/DoubleBuffer.java | 225 | ||||
| -rw-r--r-- | libjava/java/nio/FloatBuffer.java | 224 | ||||
| -rw-r--r-- | libjava/java/nio/IntBuffer.java | 225 | ||||
| -rw-r--r-- | libjava/java/nio/LongBuffer.java | 226 | ||||
| -rw-r--r-- | libjava/java/nio/ShortBuffer.java | 226 | ||||
| -rw-r--r-- | libjava/java/nio/channels/FileChannel.java | 135 |
6 files changed, 1261 insertions, 0 deletions
diff --git a/libjava/java/nio/DoubleBuffer.java b/libjava/java/nio/DoubleBuffer.java new file mode 100644 index 0000000..7059b6e --- /dev/null +++ b/libjava/java/nio/DoubleBuffer.java @@ -0,0 +1,225 @@ +/* DoubleBuffer.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 java.nio; + +import gnu.java.nio.DoubleBufferImpl; + +public abstract class DoubleBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected double [] backing_buffer; + + public static DoubleBuffer allocateDirect(int capacity) + { + return new DoubleBufferImpl(capacity, 0, capacity); + } + + public static DoubleBuffer allocate(int capacity) + { + return new DoubleBufferImpl(capacity, 0, capacity); + } + + final public static DoubleBuffer wrap (double[] array, int offset, int length) + { + return new DoubleBufferImpl(array, offset, length); + } + + final public static DoubleBuffer wrap(String a) + { + int len = a.length(); + double[] buffer = new double[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (double) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static DoubleBuffer wrap(double[] array) + { + return wrap(array, 0, array.length); + } + + final public DoubleBuffer get (double[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public DoubleBuffer get(double[] dst) + { + return get(dst, 0, dst.length); + } + + final public DoubleBuffer put(DoubleBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public DoubleBuffer put (double[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final DoubleBuffer put(double[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final double[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof DoubleBuffer) + { + return compareTo(obj) == 0; + } + + return false; + } + + public int compareTo(Object ob) + { + DoubleBuffer a = (DoubleBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final DoubleBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract double get(); + public abstract DoubleBuffer put (double b); + public abstract double get(int index); + public abstract DoubleBuffer put(int index, double b); + public abstract DoubleBuffer compact(); + public abstract boolean isDirect(); + public abstract DoubleBuffer slice(); + public abstract DoubleBuffer duplicate(); + public abstract DoubleBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract DoubleBuffer putChar(char value); + public abstract char getChar(int index); + public abstract DoubleBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract DoubleBuffer putShort(short value); + public abstract short getShort(int index); + public abstract DoubleBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract DoubleBuffer putInt(int value); + public abstract int getInt(int index); + public abstract DoubleBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract DoubleBuffer putLong(long value); + public abstract long getLong(int index); + public abstract DoubleBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract DoubleBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract DoubleBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract DoubleBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract DoubleBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/FloatBuffer.java b/libjava/java/nio/FloatBuffer.java new file mode 100644 index 0000000..f06ef18 --- /dev/null +++ b/libjava/java/nio/FloatBuffer.java @@ -0,0 +1,224 @@ +/* FloatBuffer.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 java.nio; + +import gnu.java.nio.FloatBufferImpl; + +public abstract class FloatBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected float [] backing_buffer; + + public static FloatBuffer allocateDirect(int capacity) + { + return new FloatBufferImpl (capacity, 0, capacity); + } + + public static FloatBuffer allocate(int capacity) + { + return new FloatBufferImpl (capacity, 0, capacity); + } + + final public static FloatBuffer wrap(float[] array, int offset, int length) + { + return new FloatBufferImpl(array, offset, length); + } + + final public static FloatBuffer wrap(String a) + { + int len = a.length(); + float[] buffer = new float[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (float) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static FloatBuffer wrap(float[] array) + { + return wrap(array, 0, array.length); + } + + final public FloatBuffer get(float[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public FloatBuffer get(float[] dst) + { + return get(dst, 0, dst.length); + } + + final public FloatBuffer put(FloatBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public FloatBuffer put(float[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final FloatBuffer put(float[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final float[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof FloatBuffer) + { + return compareTo(obj) == 0; + } + return false; + } + + public int compareTo(Object ob) + { + FloatBuffer a = (FloatBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final FloatBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract float get(); + public abstract java.nio. FloatBuffer put(float b); + public abstract float get(int index); + public abstract java.nio. FloatBuffer put(int index, float b); + public abstract FloatBuffer compact(); + public abstract boolean isDirect(); + public abstract FloatBuffer slice(); + public abstract FloatBuffer duplicate(); + public abstract FloatBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract FloatBuffer putChar(char value); + public abstract char getChar(int index); + public abstract FloatBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract FloatBuffer putShort(short value); + public abstract short getShort(int index); + public abstract FloatBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract FloatBuffer putInt(int value); + public abstract int getInt(int index); + public abstract FloatBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract FloatBuffer putLong(long value); + public abstract long getLong(int index); + public abstract FloatBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract FloatBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract FloatBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract FloatBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract FloatBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/IntBuffer.java b/libjava/java/nio/IntBuffer.java new file mode 100644 index 0000000..d2d28d3 --- /dev/null +++ b/libjava/java/nio/IntBuffer.java @@ -0,0 +1,225 @@ +/* IntBuffer.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 java.nio; + +import gnu.java.nio.IntBufferImpl; + +public abstract class IntBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected int [] backing_buffer; + + public static IntBuffer allocateDirect(int capacity) + { + return new IntBufferImpl (capacity, 0, capacity); + } + + public static IntBuffer allocate(int capacity) + { + return new IntBufferImpl (capacity, 0, capacity); + } + + final public static IntBuffer wrap(int[] array, int offset, int length) + { + return new IntBufferImpl(array, offset, length); + } + + final public static IntBuffer wrap(String a) + { + int len = a.length(); + int[] buffer = new int[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (int) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static IntBuffer wrap(int[] array) + { + return wrap(array, 0, array.length); + } + + final public IntBuffer get(int[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public IntBuffer get(int[] dst) + { + return get(dst, 0, dst.length); + } + + final public IntBuffer put(IntBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public IntBuffer put(int[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final IntBuffer put(int[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final int[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof IntBuffer) + { + return compareTo(obj) == 0; + } + + return false; + } + + public int compareTo(Object ob) + { + IntBuffer a = (IntBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final IntBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract int get(); + public abstract IntBuffer put(int b); + public abstract int get(int index); + public abstract IntBuffer put(int index, int b); + public abstract IntBuffer compact(); + public abstract boolean isDirect(); + public abstract IntBuffer slice(); + public abstract IntBuffer duplicate(); + public abstract IntBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract IntBuffer putChar(char value); + public abstract char getChar(int index); + public abstract IntBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract IntBuffer putShort(short value); + public abstract short getShort(int index); + public abstract IntBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract IntBuffer putInt(int value); + public abstract int getInt(int index); + public abstract IntBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract IntBuffer putLong(long value); + public abstract long getLong(int index); + public abstract IntBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract IntBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract IntBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract IntBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract IntBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/LongBuffer.java b/libjava/java/nio/LongBuffer.java new file mode 100644 index 0000000..5bca6d5 --- /dev/null +++ b/libjava/java/nio/LongBuffer.java @@ -0,0 +1,226 @@ +/* LongBuffer.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 java.nio; + +import gnu.java.nio.LongBufferImpl; + +public abstract class LongBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected long [] backing_buffer; + + public static LongBuffer allocateDirect(int capacity) + { + return new LongBufferImpl(capacity, 0, capacity); + } + + public static LongBuffer allocate(int capacity) + { + return new LongBufferImpl(capacity, 0, capacity); + } + + final public static LongBuffer wrap(long[] array, int offset, int length) + { + return new LongBufferImpl (array, offset, length); + } + + final public static LongBuffer wrap(String a) + { + int len = a.length(); + long[] buffer = new long[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (long) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static LongBuffer wrap(long[] array) + { + return wrap(array, 0, array.length); + } + + final public LongBuffer get(long[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public LongBuffer get(long[] dst) + { + return get(dst, 0, dst.length); + } + + final public LongBuffer put(LongBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public LongBuffer put(long[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final LongBuffer put(long[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final long[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof LongBuffer) + { + return compareTo(obj) == 0; + } + + return false; + } + + public int compareTo(Object ob) + { + LongBuffer a = (LongBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final LongBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract long get(); + public abstract java.nio. LongBuffer put(long b); + public abstract long get(int index); + public abstract java.nio. LongBuffer put(int index, long b); + public abstract LongBuffer compact(); + public abstract boolean isDirect(); + public abstract LongBuffer slice(); + public abstract LongBuffer duplicate(); + public abstract LongBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract LongBuffer putChar(char value); + public abstract char getChar(int index); + public abstract LongBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract LongBuffer putShort(short value); + public abstract short getShort(int index); + public abstract LongBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract LongBuffer putInt(int value); + public abstract int getInt(int index); + public abstract LongBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract LongBuffer putLong(long value); + public abstract long getLong(int index); + public abstract LongBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract LongBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract LongBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract LongBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract LongBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/ShortBuffer.java b/libjava/java/nio/ShortBuffer.java new file mode 100644 index 0000000..5301366 --- /dev/null +++ b/libjava/java/nio/ShortBuffer.java @@ -0,0 +1,226 @@ +/* ShortBuffer.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 java.nio; + +import gnu.java.nio.ShortBufferImpl; + +public abstract class ShortBuffer extends Buffer +{ + private ByteOrder endian = ByteOrder.BIG_ENDIAN; + protected short [] backing_buffer; + + public static ShortBuffer allocateDirect(int capacity) + { + return new ShortBufferImpl(capacity, 0, capacity); + } + + public static ShortBuffer allocate(int capacity) + { + return new ShortBufferImpl(capacity, 0, capacity); + } + + final public static ShortBuffer wrap(short[] array, int offset, int length) + { + return new ShortBufferImpl(array, offset, length); + } + + final public static ShortBuffer wrap(String a) + { + int len = a.length(); + short[] buffer = new short[len]; + + for (int i=0;i<len;i++) + { + buffer[i] = (short) a.charAt(i); + } + + return wrap(buffer, 0, len); + } + + final public static ShortBuffer wrap(short[] array) + { + return wrap(array, 0, array.length); + } + + final public ShortBuffer get(short[] dst, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + { + dst[i] = get(); + } + + return this; + } + + final public ShortBuffer get(short[] dst) + { + return get(dst, 0, dst.length); + } + + final public ShortBuffer put(ShortBuffer src) + { + while (src.hasRemaining()) + put(src.get()); + + return this; + } + + final public ShortBuffer put(short[] src, int offset, int length) + { + for (int i = offset; i < offset + length; i++) + put(src[i]); + + return this; + } + + public final ShortBuffer put(short[] src) + { + return put(src, 0, src.length); + } + + public final boolean hasArray() + { + return (backing_buffer != null); + } + + public final short[] array() + { + return backing_buffer; + } + + public final int arrayOffset() + { + return 0; + } + + public int hashCode() + { + return super.hashCode(); + } + + public boolean equals(Object obj) + { + if (obj instanceof ShortBuffer) + { + return compareTo(obj) == 0; + } + + return false; + } + + public int compareTo(Object ob) + { + ShortBuffer a = (ShortBuffer) ob; + + if (a.remaining() != remaining()) + return 1; + + if (! hasArray() || + ! a.hasArray()) + { + return 1; + } + + int r = remaining(); + int i1 = position (); + int i2 = a.position (); + + for (int i=0;i<r;i++) + { + int t = (int) (get(i1)- a.get(i2)); + + if (t != 0) + { + return (int) t; + } + } + + return 0; + } + + public final ByteOrder order() + { + return endian; + } + + public final ShortBuffer order(ByteOrder bo) + { + endian = bo; + return this; + } + + public abstract short get(); + public abstract java.nio. ShortBuffer put(short b); + public abstract short get(int index); + public abstract java.nio. ShortBuffer put(int index, short b); + public abstract ShortBuffer compact(); + public abstract boolean isDirect(); + public abstract ShortBuffer slice(); + public abstract ShortBuffer duplicate(); + public abstract ShortBuffer asReadOnlyBuffer(); + public abstract ShortBuffer asShortBuffer(); + public abstract CharBuffer asCharBuffer(); + public abstract IntBuffer asIntBuffer(); + public abstract LongBuffer asLongBuffer(); + public abstract FloatBuffer asFloatBuffer(); + public abstract DoubleBuffer asDoubleBuffer(); + public abstract char getChar(); + public abstract ShortBuffer putChar(char value); + public abstract char getChar(int index); + public abstract ShortBuffer putChar(int index, char value); + public abstract short getShort(); + public abstract ShortBuffer putShort(short value); + public abstract short getShort(int index); + public abstract ShortBuffer putShort(int index, short value); + public abstract int getInt(); + public abstract ShortBuffer putInt(int value); + public abstract int getInt(int index); + public abstract ShortBuffer putInt(int index, int value); + public abstract long getLong(); + public abstract ShortBuffer putLong(long value); + public abstract long getLong(int index); + public abstract ShortBuffer putLong(int index, long value); + public abstract float getFloat(); + public abstract ShortBuffer putFloat(float value); + public abstract float getFloat(int index); + public abstract ShortBuffer putFloat(int index, float value); + public abstract double getDouble(); + public abstract ShortBuffer putDouble(double value); + public abstract double getDouble(int index); + public abstract ShortBuffer putDouble(int index, double value); +} diff --git a/libjava/java/nio/channels/FileChannel.java b/libjava/java/nio/channels/FileChannel.java new file mode 100644 index 0000000..8970b98 --- /dev/null +++ b/libjava/java/nio/channels/FileChannel.java @@ -0,0 +1,135 @@ +/* FileChannel.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 java.nio.channels; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.MappedByteBuffer; +import java.nio.channels.spi.AbstractInterruptibleChannel; + +/** + * @author Michael Koch + * @since 1.4 + */ +public abstract class FileChannel extends AbstractInterruptibleChannel + implements ByteChannel, GatheringByteChannel, ScatteringByteChannel +{ + public static class MapMode + { + public int m; + + public static MapMode READ_ONLY = new MapMode(0); + public static MapMode READ_WRITE = new MapMode(1); + public static MapMode PRIVATE = new MapMode(2); + + /** + * Initializes the MapMode. + */ + MapMode(int a) + { + m = a; + } + + public String toString() + { + return "" + m; + } + } + + /** + * Initializes the channel. + */ + protected FileChannel () + { + } + + /** + * Maps the file into the memory. + * + * @exception IOException If an error occurs. + */ + public abstract MappedByteBuffer map(MapMode mode, long position, long size) + throws IOException; + + /** + * Return the size of the file thus far + */ + public abstract long size() throws IOException; + + /** + * Writes data to the channel. + * + * @exception IOException If an error occurs. + */ + public long write (ByteBuffer[] srcs) throws IOException + { + long result = 0; + + for (int i = 0; i < srcs.length; i++) + { + result += write (srcs[i]); + } + + return result; + } + + /** + * Writes data to the channel. + */ + public abstract long write(ByteBuffer[] srcs, int offset, int length) + throws IOException; + + /** + * Reads data from the channel. + */ + public abstract int read(ByteBuffer dst) throws IOException; + + /** + * Closes the channel. + * + * This is called from @see close. + * + * @exception IOException If an error occurs. + */ + protected abstract void implCloseChannel() throws IOException; + + /** + * msync with the disk + */ + public abstract void force(boolean metaData); +} |