libjava/classpath/java/io/FileInputStream.java

   1 /* FileInputStream.java -- An input stream that reads from disk files.
   2    Copyright (C) 1998, 2002, 2003, 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., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 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 java.io;
  40
  41 import gnu.java.nio.FileChannelImpl;
  42
  43 import java.nio.ByteBuffer;
  44 import java.nio.channels.FileChannel;
  45
  46 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
  47  * "The Java Language Specification", ISBN 0-201-63451-1
  48  * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
  49  * Status:  Believed complete and correct.
  50  */
  51
  52 /**
  53  * This class is a stream that reads its bytes from a file.
  54  *
  55  * @author Aaron M. Renn (arenn@urbanophile.com)
  56  * @author Warren Levy (warrenl@cygnus.com)
  57  */
  58 public class FileInputStream extends InputStream
  59 {
  60   /**
  61    * This is the native file handle for the file this stream is reading from
  62    */
  63   private FileDescriptor fd;
  64
  65   private FileChannelImpl ch;
  66
  67   /**
  68    * This method initializes a <code>FileInputStream</code> to read from the
  69    * specified named file.  A security check is first made to determine
  70    * whether or not access to this file is allowed.  This is done by
  71    * calling the <code>checkRead()</code> method of the
  72    * <code>SecurityManager</code>
  73    * (if one exists) with the name of this file.  An exception is thrown
  74    * if reading is not allowed.  If the file does not exist, an exception
  75    * is also thrown.
  76    *
  77    * @param name The name of the file this stream should read from
  78    *
  79    * @exception SecurityException If read access to the file is not allowed
  80    * @exception FileNotFoundException If the file does not exist
  81    * or if it is a directory
  82    */
  83   public FileInputStream(String name) throws FileNotFoundException
  84   {
  85     this(new File(name));
  86   }
  87
  88   /**
  89    * This method initializes a <code>FileInputStream</code> to read from the
  90    * specified <code>File</code> object.  A security check is first
  91    * made to determine
  92    * whether or not access to this file is allowed.  This is done by
  93    * calling the <code>checkRead()</code> method of the
  94    * <code>SecurityManager</code>
  95    * (if one exists) with the name of this file.  An exception is thrown
  96    * if reading is not allowed.  If the file does not exist, an exception
  97    * is also thrown.
  98    *
  99    * @param file The <code>File</code> object this stream should read from
 100    *
 101    * @exception SecurityException If read access to the file is not allowed
 102    * @exception FileNotFoundException If the file does not exist
 103    * or if it is a directory.
 104    */
 105   public FileInputStream(File file) throws FileNotFoundException
 106   {
 107     SecurityManager s = System.getSecurityManager();
 108     if (s != null)
 109       s.checkRead(file.getPath());
 110
 111     try
 112       {
 113         ch = FileChannelImpl.create(file, FileChannelImpl.READ);
 114       }
 115     catch (FileNotFoundException fnfe)
 116       {
 117         throw fnfe;
 118       }
 119     catch (IOException ioe)
 120       {
 121         FileNotFoundException fnfe = new FileNotFoundException(file.getPath());
 122         fnfe.initCause(ioe);
 123         throw fnfe;
 124       }
 125   }
 126
 127   /**
 128    * This method initializes a <code>FileInputStream</code> to read from the
 129    * specified <code>FileDescriptor</code> object.  A security
 130    * check is first made to
 131    * determine whether or not access to this file is allowed.  This is done by
 132    * calling the <code>checkRead()</code> method of the
 133    * <code>SecurityManager</code>
 134    * (if one exists) with the specified <code>FileDescriptor</code>
 135    * An exception is
 136    * thrown if reading is not allowed.
 137    *
 138    * @param fdObj The <code>FileDescriptor</code> object this stream
 139    * should read from
 140    *
 141    * @exception SecurityException If read access to the file is not allowed
 142    */
 143   public FileInputStream(FileDescriptor fdObj)
 144   {
 145     SecurityManager s = System.getSecurityManager();
 146     if (s != null)
 147       s.checkRead(fdObj);
 148
 149     fd = fdObj;
 150     ch = (FileChannelImpl) fdObj.channel;
 151   }
 152
 153   FileInputStream(FileChannelImpl ch)
 154   {
 155     this.ch = ch;
 156   }
 157
 158   /**
 159    * This method returns the number of bytes that can be read from this
 160    * stream before a read can block.  A return of 0 indicates that blocking
 161    * might (or might not) occur on the very next read attempt.
 162    * <p>
 163    * This method returns the number of unread bytes remaining in the file if
 164    * the descriptor being read from is an actual file.  If this method is
 165    * reading from a ''special'' file such a the standard input, this method
 166    * will return the appropriate value for the stream being read.
 167    * <p>
 168    * Be aware that reads on plain files that do not reside locally might
 169    * possibly block even if this method says they should not.  For example,
 170    * a remote server might crash, preventing an NFS mounted file from being
 171    * read.
 172    *
 173    * @return The number of bytes that can be read before blocking could occur
 174    *
 175    * @exception IOException If an error occurs
 176    */
 177   public int available() throws IOException
 178   {
 179     return ch.available();
 180   }
 181
 182   /**
 183    * This method closes the stream.  Any futher attempts to read from the
 184    * stream will likely generate an IOException since the underlying file
 185    * will be closed.
 186    *
 187    * @exception IOException If an error occurs.
 188    */
 189   public void close() throws IOException
 190   {
 191     ch.close();
 192   }
 193
 194   protected void finalize() throws IOException
 195   {
 196     // We don't actually need this, but we include it because it is
 197     // mentioned in the JCL.
 198   }
 199
 200   /**
 201    * This method returns a <code>FileDescriptor</code> object representing the
 202    * underlying native file handle of the file this stream is reading
 203    * from
 204    *
 205    * @return A <code>FileDescriptor</code> for this stream
 206    *
 207    * @exception IOException If an error occurs
 208    */
 209   public final FileDescriptor getFD() throws IOException
 210   {
 211     synchronized (this)
 212       {
 213         if (fd == null)
 214           fd = new FileDescriptor (ch);
 215         return fd;
 216       }
 217   }
 218
 219   /**
 220    * This method reads an unsigned byte from the input stream and returns it
 221    * as an int in the range of 0-255.  This method also will return -1 if
 222    * the end of the stream has been reached.
 223    * <p>
 224    * This method will block until the byte can be read.
 225    *
 226    * @return The byte read or -1 if end of stream
 227    *
 228    * @exception IOException If an error occurs
 229    */
 230   public int read() throws IOException
 231   {
 232     return ch.read();
 233   }
 234
 235   /**
 236    * This method reads bytes from a stream and stores them into a caller
 237    * supplied buffer.  This method attempts to completely fill the buffer,
 238    * but can return before doing so.  The actual number of bytes read is
 239    * returned as an int.  A -1 is returned to indicate the end of the stream.
 240    * <p>
 241    * This method will block until some data can be read.
 242    * <p>
 243    * This method operates by calling an overloaded read method like so:
 244    * <code>read(buf, 0, buf.length)</code>
 245    *
 246    * @param buf The buffer into which the bytes read will be stored.
 247    *
 248    * @return The number of bytes read or -1 if end of stream.
 249    *
 250    * @exception IOException If an error occurs.
 251    */
 252   public int read(byte[] buf) throws IOException
 253   {
 254     return read(buf, 0, buf.length);
 255   }
 256
 257   /**
 258    * This method read bytes from a stream and stores them into a caller
 259    * supplied buffer.  It starts storing the data at index
 260    * <code>offset</code> into
 261    * the buffer and attempts to read <code>len</code> bytes.  This method can
 262    * return before reading the number of bytes requested.  The actual number
 263    * of bytes read is returned as an int.  A -1 is returned to indicate the
 264    * end of the stream.
 265    * <p>
 266    * This method will block until some data can be read.
 267    *
 268    * @param buf The array into which the bytes read should be stored
 269    * @param offset The offset into the array to start storing bytes
 270    * @param len The requested number of bytes to read
 271    *
 272    * @return The actual number of bytes read, or -1 if end of stream.
 273    *
 274    * @exception IOException If an error occurs.
 275    */
 276   public int read(byte[] buf, int offset, int len) throws IOException
 277   {
 278     if (offset < 0
 279         || len < 0
 280         || offset + len > buf.length)
 281       throw new ArrayIndexOutOfBoundsException();
 282
 283     return ch.read(ByteBuffer.wrap(buf, offset, len));
 284   }
 285
 286   /**
 287    * This method skips the specified number of bytes in the stream.  It
 288    * returns the actual number of bytes skipped, which may be less than the
 289    * requested amount.
 290    * <p>
 291    * @param numBytes The requested number of bytes to skip
 292    *
 293    * @return The actual number of bytes skipped.
 294    *
 295    * @exception IOException If an error occurs
 296    */
 297   public synchronized long skip (long numBytes) throws IOException
 298   {
 299     if (numBytes < 0)
 300       throw new IllegalArgumentException ("Can't skip negative bytes: " +
 301                                           numBytes);
 302
 303     if (numBytes == 0)
 304       return 0;
 305
 306     long oldPos = ch.position ();
 307     ch.position(oldPos + numBytes);
 308     return ch.position() - oldPos;
 309   }
 310
 311   /**
 312    * This method creates a java.nio.channels.FileChannel.
 313    * Nio does not allow one to create a file channel directly.
 314    * A file channel must be created by first creating an instance of
 315    * Input/Output/RandomAccessFile and invoking the getChannel() method on it.
 316    */
 317   public synchronized FileChannel getChannel ()
 318   {
 319     return ch;
 320   }
 321
 322 } // class FileInputStream
 323