libjava/gnu/java/nio/channels/FileChannelImpl.java

   1 /* FileChannelImpl.java --
   2    Copyright (C) 2002, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package gnu.java.nio.channels;
  40
  41 import gnu.classpath.Configuration;
  42 import gnu.java.nio.FileLockImpl;
  43
  44 import java.io.FileNotFoundException;
  45 import java.io.IOException;
  46 import java.nio.ByteBuffer;
  47 import java.nio.MappedByteBuffer;
  48 import java.nio.channels.ClosedChannelException;
  49 import java.nio.channels.FileChannel;
  50 import java.nio.channels.FileLock;
  51 import java.nio.channels.NonReadableChannelException;
  52 import java.nio.channels.NonWritableChannelException;
  53 import java.nio.channels.ReadableByteChannel;
  54 import java.nio.channels.WritableByteChannel;
  55
  56 /**
  57  * This file is not user visible !
  58  * But alas, Java does not have a concept of friendly packages
  59  * so this class is public.
  60  * Instances of this class are created by invoking getChannel
  61  * Upon a Input/Output/RandomAccessFile object.
  62  */
  63 public final class FileChannelImpl extends FileChannel
  64 {
  65   // These are mode values for open().
  66   public static final int READ   = 1;
  67   public static final int WRITE  = 2;
  68   public static final int APPEND = 4;
  69
  70   // EXCL is used only when making a temp file.
  71   public static final int EXCL   = 8;
  72   public static final int SYNC   = 16;
  73   public static final int DSYNC  = 32;
  74
  75   private static native void init();
  76
  77   static
  78   {
  79     if (Configuration.INIT_LOAD_LIBRARY)
  80       {
  81         System.loadLibrary("javanio");
  82       }
  83
  84     init();
  85   }
  86
  87   /**
  88    * This is the actual native file descriptor value
  89    */
  90   // System's notion of file descriptor.  It might seem redundant to
  91   // initialize this given that it is reassigned in the constructors.
  92   // However, this is necessary because if open() throws an exception
  93   // we want to make sure this has the value -1.  This is the most
  94   // efficient way to accomplish that.
  95   private int fd = -1;
  96
  97   private long pos;
  98   private int mode;
  99
 100   public FileChannelImpl ()
 101   {
 102   }
 103
 104   /* Open a file.  MODE is a combination of the above mode flags. */
 105   public FileChannelImpl (String path, int mode) throws FileNotFoundException
 106   {
 107     fd = open (path, mode);
 108     this.mode = mode;
 109   }
 110
 111   /* Used by init() (native code) */
 112   FileChannelImpl (int fd, int mode)
 113   {
 114     this.fd = fd;
 115     this.mode = mode;
 116   }
 117
 118   public static FileChannelImpl in;
 119   public static FileChannelImpl out;
 120   public static FileChannelImpl err;
 121
 122   private native int open (String path, int mode) throws FileNotFoundException;
 123
 124   public native int available () throws IOException;
 125   private native long implPosition () throws IOException;
 126   private native void seek (long newPosition) throws IOException;
 127   private native void implTruncate (long size) throws IOException;
 128
 129   public native void unlock (long pos, long len) throws IOException;
 130
 131   public native long size () throws IOException;
 132
 133   protected native void implCloseChannel() throws IOException;
 134
 135   /**
 136    * Makes sure the Channel is properly closed.
 137    */
 138   protected void finalize() throws IOException
 139   {
 140     this.close();
 141   }
 142
 143   public int read (ByteBuffer dst) throws IOException
 144   {
 145     int result;
 146     byte[] buffer = new byte [dst.remaining ()];
 147
 148     result = read (buffer, 0, buffer.length);
 149
 150     if (result > 0)
 151       dst.put (buffer, 0, result);
 152
 153     return result;
 154   }
 155
 156   public int read (ByteBuffer dst, long position)
 157     throws IOException
 158   {
 159     if (position < 0)
 160       throw new IllegalArgumentException ();
 161     long oldPosition = implPosition ();
 162     position (position);
 163     int result = read(dst);
 164     position (oldPosition);
 165
 166     return result;
 167   }
 168
 169   public native int read ()
 170     throws IOException;
 171
 172   public native int read (byte[] buffer, int offset, int length)
 173     throws IOException;
 174
 175   public long read (ByteBuffer[] dsts, int offset, int length)
 176     throws IOException
 177   {
 178     long result = 0;
 179
 180     for (int i = offset; i < offset + length; i++)
 181       {
 182         result += read (dsts [i]);
 183       }
 184
 185     return result;
 186   }
 187
 188   public int write (ByteBuffer src) throws IOException
 189   {
 190     int len = src.remaining ();
 191     if (src.hasArray())
 192       {
 193         byte[] buffer = src.array();
 194         write(buffer, src.arrayOffset() + src.position(), len);
 195         src.position(src.position() + len);
 196       }
 197     else
 198       {
 199         // Use a more efficient native method! FIXME!
 200         byte[] buffer = new byte [len];
 201         src.get (buffer, 0, len);
 202         write (buffer, 0, len);
 203       }
 204     return len;
 205   }
 206
 207   public int write (ByteBuffer src, long position)
 208     throws IOException
 209   {
 210     if (position < 0)
 211       throw new IllegalArgumentException ();
 212
 213     if (!isOpen ())
 214       throw new ClosedChannelException ();
 215
 216     if ((mode & WRITE) == 0)
 217        throw new NonWritableChannelException ();
 218
 219     int result;
 220     long oldPosition;
 221
 222     oldPosition = implPosition ();
 223     seek (position);
 224     result = write(src);
 225     seek (oldPosition);
 226
 227     return result;
 228   }
 229
 230   public native void write (byte[] buffer, int offset, int length)
 231     throws IOException;
 232
 233   public native void write (int b) throws IOException;
 234
 235   public long write(ByteBuffer[] srcs, int offset, int length)
 236     throws IOException
 237   {
 238     long result = 0;
 239
 240     for (int i = offset;i < offset + length;i++)
 241       {
 242         result += write (srcs[i]);
 243       }
 244
 245     return result;
 246   }
 247
 248   public native MappedByteBuffer mapImpl (char mode, long position, int size)
 249     throws IOException;
 250
 251   public MappedByteBuffer map (FileChannel.MapMode mode,
 252                                long position, long size)
 253     throws IOException
 254   {
 255     char nmode = 0;
 256     if (mode == MapMode.READ_ONLY)
 257       {
 258         nmode = 'r';
 259         if ((this.mode & READ) == 0)
 260           throw new NonReadableChannelException();
 261       }
 262     else if (mode == MapMode.READ_WRITE || mode == MapMode.PRIVATE)
 263       {
 264         nmode = mode == MapMode.READ_WRITE ? '+' : 'c';
 265         if ((this.mode & (READ|WRITE)) != (READ|WRITE))
 266           throw new NonWritableChannelException();
 267       }
 268     else
 269       throw new IllegalArgumentException ();
 270
 271     if (position < 0 || size < 0 || size > Integer.MAX_VALUE)
 272       throw new IllegalArgumentException ();
 273     return mapImpl(nmode, position, (int) size);
 274   }
 275
 276   /**
 277    * msync with the disk
 278    */
 279   public void force (boolean metaData) throws IOException
 280   {
 281     if (!isOpen ())
 282       throw new ClosedChannelException ();
 283   }
 284
 285   public long transferTo (long position, long count, WritableByteChannel target)
 286     throws IOException
 287   {
 288     if (position < 0
 289         || count < 0)
 290       throw new IllegalArgumentException ();
 291
 292     if (!isOpen ())
 293       throw new ClosedChannelException ();
 294
 295     if ((mode & READ) == 0)
 296        throw new NonReadableChannelException ();
 297
 298     // XXX: count needs to be casted from long to int. Dataloss ?
 299     ByteBuffer buffer = ByteBuffer.allocate ((int) count);
 300     read (buffer, position);
 301     buffer.flip();
 302     return target.write (buffer);
 303   }
 304
 305   public long transferFrom (ReadableByteChannel src, long position, long count)
 306     throws IOException
 307   {
 308     if (position < 0
 309         || count < 0)
 310       throw new IllegalArgumentException ();
 311
 312     if (!isOpen ())
 313       throw new ClosedChannelException ();
 314
 315     if ((mode & WRITE) == 0)
 316        throw new NonWritableChannelException ();
 317
 318     // XXX: count needs to be casted from long to int. Dataloss ?
 319     ByteBuffer buffer = ByteBuffer.allocate ((int) count);
 320     src.read (buffer);
 321     buffer.flip();
 322     return write (buffer, position);
 323   }
 324
 325   public FileLock tryLock (long position, long size, boolean shared)
 326     throws IOException
 327   {
 328     if (position < 0
 329         || size < 0)
 330       throw new IllegalArgumentException ();
 331
 332     if (!isOpen ())
 333       throw new ClosedChannelException ();
 334
 335     if (shared && (mode & READ) == 0)
 336       throw new NonReadableChannelException ();
 337
 338     if (!shared && (mode & WRITE) == 0)
 339       throw new NonWritableChannelException ();
 340
 341     boolean completed = false;
 342
 343     try
 344       {
 345         begin();
 346         lock(position, size, shared, true);
 347         completed = true;
 348         return new FileLockImpl(this, position, size, shared);
 349       }
 350     finally
 351       {
 352         end(completed);
 353       }
 354   }
 355
 356   /** Try to acquire a lock at the given position and size.
 357    * On success return true.
 358    * If wait as specified, block until we can get it.
 359    * Otherwise return false.
 360    */
 361   private native boolean lock(long position, long size,
 362                               boolean shared, boolean wait) throws IOException;
 363
 364   public FileLock lock (long position, long size, boolean shared)
 365     throws IOException
 366   {
 367     if (position < 0
 368         || size < 0)
 369       throw new IllegalArgumentException ();
 370
 371     if (!isOpen ())
 372       throw new ClosedChannelException ();
 373
 374     boolean completed = false;
 375
 376     try
 377       {
 378         boolean lockable = lock(position, size, shared, false);
 379         completed = true;
 380         return (lockable
 381                 ? new FileLockImpl(this, position, size, shared)
 382                 : null);
 383       }
 384     finally
 385       {
 386         end(completed);
 387       }
 388   }
 389
 390   public long position ()
 391     throws IOException
 392   {
 393     if (!isOpen ())
 394       throw new ClosedChannelException ();
 395
 396     return implPosition ();
 397   }
 398
 399   public FileChannel position (long newPosition)
 400     throws IOException
 401   {
 402     if (newPosition < 0)
 403       throw new IllegalArgumentException ();
 404
 405     if (!isOpen ())
 406       throw new ClosedChannelException ();
 407
 408     // FIXME note semantics if seeking beyond eof.
 409     // We should seek lazily - only on a write.
 410     seek (newPosition);
 411     return this;
 412   }
 413
 414   public FileChannel truncate (long size)
 415     throws IOException
 416   {
 417     if (size < 0)
 418       throw new IllegalArgumentException ();
 419
 420     if (!isOpen ())
 421       throw new ClosedChannelException ();
 422
 423     if ((mode & WRITE) == 0)
 424        throw new NonWritableChannelException ();
 425
 426     if (size < size ())
 427       implTruncate (size);
 428
 429     return this;
 430   }
 431 }