/*

   * 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 FileOutputStream extends OutputStream

 {
    

     private FileDescriptor fd;

     private FileChannel channel= null;

     private boolean append = false;

     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 FileOutputStream(String name) throws FileNotFoundException {

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

    }

    

    public FileOutputStream(String name, boolean append)

        throws FileNotFoundException

    {

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

    }

    

    public FileOutputStream(File file) throws FileNotFoundException {

        this(file, false);

    }

    

    public FileOutputStream(File file, boolean append)

        throws FileNotFoundException

    {

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

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkWrite(name);

        }

        if (name == null) {

            throw new NullPointerException();

        }

        fd = new FileDescriptor();

        fd.incrementAndGetUseCount();

        this.append = append;

        if (append) {

            openAppend(name);

        } else {

            open(name);

        }

    }

    

    public FileOutputStream(FileDescriptor fdObj) {

        SecurityManager security = System.getSecurityManager();

        if (fdObj == null) {

            throw new NullPointerException();

        }

        if (security != null) {

            security.checkWrite(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;

    

    private native void openAppend(String name) throws FileNotFoundException;

    

    public native void write(int b) throws IOException;

    

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

    

    public void write(byte b[]) throws IOException {

        writeBytes(b, 0, b.length);

    }

    

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

        writeBytes(b, off, len);

    }

    

    public void close() throws IOException {

        synchronized (closeLock) {

            if (closed) {

                return;

            }

            closed = true;

        }

        if (channel != null) {

            /*

             * Decrement 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 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, false, true, this, append);

                /*

                 * 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;

        }

    }

    

    protected void finalize() throws IOException {

        if (fd != null) {

            if (fd == fd.out || fd == fd.err) {

                flush();

            } else {

                /*

                 * 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);

                }

            }

        }

    }

    private native void close0() throws IOException;

    private static native void initIDs();

    static {

        initIDs();

    }

}