From 6b603eb999cdf19bb27cdaf7b3433582d1c04356 Mon Sep 17 00:00:00 2001 From: Michael Koch Date: Thu, 13 Feb 2003 15:12:36 +0000 Subject: [PATCH] 2003-02-13 Michael * gnu/java/nio/FileChannelImpl.java (lengthInternal): Must be native. (size): Check if channel is already closed. (implCloseChannel): Reformated. (read): w was unused, removed it. (read): Removed. (read): New method. (write): New method. (map): Check arguments. (force): Throws IOException, check if channel is closed. (transferTo): New method. (transferFrom): New method. (lock): New method. (tryLock): New method. (position): New method. (truncate): New method. (nio_mmap_file): Uncommented. (nio_munmap_file): Uncommented. (nio_msync): Uncommented. * gnu/java/nio/natFileChannelImpl.cc: New file. From-SVN: r62841 --- libjava/ChangeLog | 23 +++ libjava/gnu/java/nio/FileChannelImpl.java | 187 +++++++++++++++++---- libjava/gnu/java/nio/natFileChannelImpl.cc | 53 ++++++ 3 files changed, 231 insertions(+), 32 deletions(-) create mode 100644 libjava/gnu/java/nio/natFileChannelImpl.cc diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 72491438c12..15391fc68f3 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,26 @@ +2003-02-13 Michael + + * gnu/java/nio/FileChannelImpl.java + (lengthInternal): Must be native. + (size): Check if channel is already closed. + (implCloseChannel): Reformated. + (read): w was unused, removed it. + (read): Removed. + (read): New method. + (write): New method. + (map): Check arguments. + (force): Throws IOException, check if channel is closed. + (transferTo): New method. + (transferFrom): New method. + (lock): New method. + (tryLock): New method. + (position): New method. + (truncate): New method. + (nio_mmap_file): Uncommented. + (nio_munmap_file): Uncommented. + (nio_msync): Uncommented. + * gnu/java/nio/natFileChannelImpl.cc: New file. + 2003-02-13 Michael Koch * java/nio/ByteBuffer.java diff --git a/libjava/gnu/java/nio/FileChannelImpl.java b/libjava/gnu/java/nio/FileChannelImpl.java index 26b48e5e51c..31779bbc64e 100644 --- a/libjava/gnu/java/nio/FileChannelImpl.java +++ b/libjava/gnu/java/nio/FileChannelImpl.java @@ -44,7 +44,13 @@ import java.io.IOException; import java.io.RandomAccessFile; import java.nio.ByteBuffer; import java.nio.MappedByteBuffer; +import java.nio.channels.ClosedChannelException; import java.nio.channels.FileChannel; +import java.nio.channels.FileLock; +import java.nio.channels.NonReadableChannelException; +import java.nio.channels.NonWritableChannelException; +import java.nio.channels.ReadableByteChannel; +import java.nio.channels.WritableByteChannel; /** * This file is not user visible ! @@ -66,11 +72,7 @@ public class FileChannelImpl extends FileChannel * 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; - }; + private native long lengthInternal (int native_fd) throws IOException; public FileChannelImpl (int fd, Object obj) { @@ -80,39 +82,42 @@ public class FileChannelImpl extends FileChannel public long size () throws IOException { + if (!isOpen ()) + throw new ClosedChannelException (); + return lengthInternal (fd); } - protected void implCloseChannel() throws IOException + protected void implCloseChannel() throws IOException { if (address != 0) - { + { nio_unmmap_file (fd, address, (int) length); - } + address = 0; + } // 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) @@ -128,9 +133,18 @@ public class FileChannelImpl extends FileChannel return s; } - public long read (ByteBuffer[] dsts) throws IOException + public int read (ByteBuffer dst, long position) + throws IOException { - return read (dsts, 0, dsts.length); + if (position < 0) + throw new IllegalArgumentException (); + + if (!isOpen ()) + throw new ClosedChannelException (); + + // FIXME: check for NonReadableChannelException + + throw new Error ("Not implemented"); } public long read (ByteBuffer[] dsts, int offset, int length) @@ -164,6 +178,20 @@ public class FileChannelImpl extends FileChannel return w; } + public int write (ByteBuffer src, long position) + throws IOException + { + if (position < 0) + throw new IllegalArgumentException (); + + if (!isOpen ()) + throw new ClosedChannelException (); + + // FIXME: check for NonWritableChannelException + + throw new Error ("Not implemented"); + } + public long write(ByteBuffer[] srcs, int offset, int length) throws IOException { @@ -173,13 +201,22 @@ public class FileChannelImpl extends FileChannel { res += write (srcs[i]); } - return res; - } + + return res; + } public MappedByteBuffer map (FileChannel.MapMode mode, long position, long size) throws IOException { + if ((mode != MapMode.READ_ONLY + && mode != MapMode.READ_WRITE + && mode != MapMode.PRIVATE) + || position < 0 + || size < 0 + || size > Integer.MAX_VALUE) + throw new IllegalArgumentException (); + // int cmode = mode.m; // address = nio_mmap_file (fd, position, size, cmode); // length = size; @@ -208,27 +245,113 @@ public class FileChannelImpl extends FileChannel /** * msync with the disk */ - public void force (boolean metaData) + public void force (boolean metaData) throws IOException { + if (!isOpen ()) + throw new ClosedChannelException (); + + // FIXME: What to do with metaData ? + nio_msync (fd, address, length); } -// static native long nio_mmap_file (int fd, long pos, int size, int mode); - -// static native void nio_unmmap_file (int fd, long address, int size); - -// static native void nio_msync (int fd, long address, int length); - - static long nio_mmap_file (int fd, long pos, int size, int mode) + public long transferTo (long position, long count, WritableByteChannel target) + throws IOException { - return 0; + if (position < 0 + || count < 0) + throw new IllegalArgumentException (); + + if (!isOpen ()) + throw new ClosedChannelException (); + + // FIXME: check for NonReadableChannelException + // FIXME: check for NonWritableChannelException + + throw new Error ("Not implemented"); } - static void nio_unmmap_file (int fd, long address, int size) + public long transferFrom (ReadableByteChannel src, long position, long count) + throws IOException { - }; + if (position < 0 + || count < 0) + throw new IllegalArgumentException (); - static void nio_msync (int fd, long address, int length) + if (!isOpen ()) + throw new ClosedChannelException (); + + // FIXME: check for NonReadableChannelException + // FIXME: check for NonWritableChannelException + + throw new Error ("Not implemented"); + } + + public FileLock lock (long position, long size, boolean shared) + throws IOException { - }; + if (position < 0 + || size < 0) + throw new IllegalArgumentException (); + + if (!isOpen ()) + throw new ClosedChannelException (); + + // FIXME: check for NonReadableChannelException + // FIXME: check for NonWritableChannelException + + throw new Error ("Not implemented"); + } + + public FileLock tryLock (long position, long size, boolean shared) + throws IOException + { + if (position < 0 + || size < 0) + throw new IllegalArgumentException (); + + if (!isOpen ()) + throw new ClosedChannelException (); + + throw new Error ("Not implemented"); + } + + public long position () + throws IOException + { + if (!isOpen ()) + throw new ClosedChannelException (); + + throw new Error ("not implemented"); + } + + public FileChannel position (long newPosition) + throws IOException + { + if (newPosition < 0) + throw new IllegalArgumentException (); + + if (!isOpen ()) + throw new ClosedChannelException (); + + throw new Error ("not implemented"); + } + + public FileChannel truncate (long size) + throws IOException + { + if (size < 0) + throw new IllegalArgumentException (); + + if (!isOpen ()) + throw new ClosedChannelException (); + + // FIXME: check for NonWritableChannelException + + throw new Error ("not implemented"); + } + + private static native long nio_mmap_file (int fd, long pos, int size, int mode); + private static native void nio_unmmap_file (int fd, long address, int size); + private static native void nio_msync (int fd, long address, int length); } diff --git a/libjava/gnu/java/nio/natFileChannelImpl.cc b/libjava/gnu/java/nio/natFileChannelImpl.cc new file mode 100644 index 00000000000..87386305bc6 --- /dev/null +++ b/libjava/gnu/java/nio/natFileChannelImpl.cc @@ -0,0 +1,53 @@ +// natFileChannelImpl.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 +#include + +jlong +gnu::java::nio::FileChannelImpl::lengthInternal (jint fd) +{ + throw new ::java::io::IOException (JvNewStringUTF ("lengthInternal not implemented")); +} + +jlong +gnu::java::nio::FileChannelImpl::nio_mmap_file (jint, jlong, jint, jint) +{ + throw new ::java::io::IOException (JvNewStringUTF ("mmap not implemented")); +} + +void +gnu::java::nio::FileChannelImpl::nio_unmmap_file (jint, jlong, jint) +{ + throw new ::java::io::IOException (JvNewStringUTF ("munmap not implemented")); +} + +void +gnu::java::nio::FileChannelImpl::nio_msync (jint, jlong, jint) +{ + throw new ::java::io::IOException (JvNewStringUTF ("msync not implemented")); +}