/*

   * Copyright 1994-2007 Sun Microsystems, Inc.  All Rights Reserved.

   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

   *

   * This code is free software; you can redistribute it and/or modify it

   * under the terms of the GNU General Public License version 2 only, as

   * published by the Free Software Foundation.  Sun designates this

   * particular file as subject to the "Classpath" exception as provided

   * by Sun in the LICENSE file that accompanied this code.

  *

  * This code 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

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

  * CA 95054 USA or visit www.sun.com if you need additional information or

  * have any questions.

  */

 package java.io;

 import java.nio.channels.FileChannel;

 import sun.nio.ch.FileChannelImpl;

 public

 class FileInputStream extends InputStream

 {

     /* File Descriptor - handle to the open file */

     private FileDescriptor fd;

     private FileChannel channel = null;

     private Object closeLock = new Object();

     private volatile boolean closed = false;

     private static ThreadLocal<Boolean> runningFinalize =

                                 new ThreadLocal<Boolean>();

     private static boolean isRunningFinalize() {

         Boolean val;

         if ((val = runningFinalize.get()) != null)

             return val.booleanValue();

         return false;

     }

    

     public FileInputStream(String name) throws FileNotFoundException {

         this(name != null ? new File(name) : null);

     }

    

    public FileInputStream(File file) throws FileNotFoundException {

        String name = (file != null ? file.getPath() : null);

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkRead(name);

        }

        if (name == null) {

            throw new NullPointerException();

        }

        fd = new FileDescriptor();

        fd.incrementAndGetUseCount();

        open(name);

    }

    

    public FileInputStream(FileDescriptor fdObj) {

        SecurityManager security = System.getSecurityManager();

        if (fdObj == null) {

            throw new NullPointerException();

        }

        if (security != null) {

            security.checkRead(fdObj);

        }

        fd = fdObj;

        /*

         * FileDescriptor is being shared by streams.

         * Ensure that it's GC'ed only when all the streams/channels are done

         * using it.

         */

        fd.incrementAndGetUseCount();

    }

    

    private native void open(String name) throws FileNotFoundException;

    

    public native int read() throws IOException;

    

    private native int readBytes(byte b[], int off, int len) throws IOException;

    

    public int read(byte b[]) throws IOException {

        return readBytes(b, 0, b.length);

    }

    

    public int read(byte b[], int off, int len) throws IOException {

        return readBytes(b, off, len);

    }

    

    public native long skip(long n) throws IOException;

    

    public native int available() throws IOException;

    

    public void close() throws IOException {

        synchronized (closeLock) {

            if (closed) {

                return;

            }

            closed = true;

        }

        if (channel != null) {

            /*

             * Decrement the FD use count associated with the channel

             * The use count is incremented whenever a new channel

             * is obtained from this stream.

             */

           fd.decrementAndGetUseCount();

           channel.close();

        }

        /*

         * Decrement the FD use count associated with this stream

         */

        int useCount = fd.decrementAndGetUseCount();

        /*

         * If FileDescriptor is still in use by another stream, the finalizer

         * will not close it.

         */

        if ((useCount <= 0) || !isRunningFinalize()) {

            close0();

        }

    }

    

    public final FileDescriptor getFD() throws IOException {

        if (fd != null) return fd;

        throw new IOException();

    }

    

    public FileChannel getChannel() {

        synchronized (this) {

            if (channel == null) {

                channel = FileChannelImpl.open(fd, true, false, this);

                /*

                 * Increment fd's use count. Invoking the channel's close()

                 * method will result in decrementing the use count set for

                 * the channel.

                 */

                fd.incrementAndGetUseCount();

            }

            return channel;

        }

    }

    private static native void initIDs();

    private native void close0() throws IOException;

    static {

        initIDs();

    }

    

    protected void finalize() throws IOException {

        if ((fd != null) &&  (fd != fd.in)) {

            /*

             * Finalizer should not release the FileDescriptor if another

             * stream is still using it. If the user directly invokes

             * close() then the FileDescriptor is also released.

             */

            runningFinalize.set(Boolean.TRUE);

            try {

                close();

            } finally {

                runningFinalize.set(Boolean.FALSE);

            }

        }

    }

}