/*

   * Copyright 1994-2006 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.util.concurrent.atomic.AtomicReferenceFieldUpdater;

 public

 class BufferedInputStream extends FilterInputStream {

     private static int defaultBufferSize = 8192;

    

     protected volatile byte buf[];

    

     private static final

         AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =

         AtomicReferenceFieldUpdater.newUpdater

         (BufferedInputStream.class,  byte[].class, "buf");

    

     protected int count;

    

     protected int pos;

    

    protected int markpos = -1;

    

    protected int marklimit;

    

    private InputStream getInIfOpen() throws IOException {

        InputStream input = in;

        if (input == null)

            throw new IOException("Stream closed");

        return input;

    }

    

    private byte[] getBufIfOpen() throws IOException {

        byte[] buffer = buf;

        if (buffer == null)

            throw new IOException("Stream closed");

        return buffer;

    }

    

    public BufferedInputStream(InputStream in) {

        this(in, defaultBufferSize);

    }

    

    public BufferedInputStream(InputStream in, int size) {

        super(in);

        if (size <= 0) {

            throw new IllegalArgumentException("Buffer size <= 0");

        }

        buf = new byte[size];

    }

    

    private void fill() throws IOException {

        byte[] buffer = getBufIfOpen();

        if (markpos < 0)

            pos = 0;            /* no mark: throw away the buffer */

        else if (pos >= buffer.length)  /* no room left in buffer */

            if (markpos > 0) {  /* can throw away early part of the buffer */

                int sz = pos - markpos;

                System.arraycopy(buffer, markpos, buffer, 0, sz);

                pos = sz;

                markpos = 0;

            } else if (buffer.length >= marklimit) {

                markpos = -1;   /* buffer got too big, invalidate mark */

                pos = 0;        /* drop buffer contents */

            } else {            /* grow buffer */

                int nsz = pos * 2;

                if (nsz > marklimit)

                    nsz = marklimit;

                byte nbuf[] = new byte[nsz];

                System.arraycopy(buffer, 0, nbuf, 0, pos);

                if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {

                    // Can't replace buf if there was an async close.

                    // Note: This would need to be changed if fill()

                    // is ever made accessible to multiple threads.

                    // But for now, the only way CAS can fail is via close.

                    // assert buf == null;

                    throw new IOException("Stream closed");

                }

                buffer = nbuf;

            }

        count = pos;

        int n = getInIfOpen().read(buffer, pos, buffer.length - pos);

        if (n > 0)

            count = n + pos;

    }

    

    public synchronized int read() throws IOException {

        if (pos >= count) {

            fill();

            if (pos >= count)

                return -1;

        }

        return getBufIfOpen()[pos++] & 0xff;

    }

    

    private int read1(byte[] b, int off, int len) throws IOException {

        int avail = count - pos;

        if (avail <= 0) {

            /* If the requested length is at least as large as the buffer, and

               if there is no mark/reset activity, do not bother to copy the

               bytes into the local buffer.  In this way buffered streams will

               cascade harmlessly. */

            if (len >= getBufIfOpen().length && markpos < 0) {

                return getInIfOpen().read(b, off, len);

            }

            fill();

            avail = count - pos;

            if (avail <= 0) return -1;

        }

        int cnt = (avail < len) ? avail : len;

        System.arraycopy(getBufIfOpen(), pos, b, off, cnt);

        pos += cnt;

        return cnt;

    }

    

    public synchronized int read(byte b[], int off, int len)

        throws IOException

    {

        getBufIfOpen(); // Check for closed stream

        if ((off | len | (off + len) | (b.length - (off + len))) < 0) {

            throw new IndexOutOfBoundsException();

        } else if (len == 0) {

            return 0;

        }

        int n = 0;

        for (;;) {

            int nread = read1(b, off + n, len - n);

            if (nread <= 0)

                return (n == 0) ? nread : n;

            n += nread;

            if (n >= len)

                return n;

            // if not closed but no bytes available, return

            InputStream input = in;

            if (input != null && input.available() <= 0)

                return n;

        }

    }

    

    public synchronized long skip(long n) throws IOException {

        getBufIfOpen(); // Check for closed stream

        if (n <= 0) {

            return 0;

        }

        long avail = count - pos;

        if (avail <= 0) {

            // If no mark position set then don't keep in buffer

            if (markpos <0)

                return getInIfOpen().skip(n);

            // Fill in buffer to save bytes for reset

            fill();

            avail = count - pos;

            if (avail <= 0)

                return 0;

        }

        long skipped = (avail < n) ? avail : n;

        pos += skipped;

        return skipped;

    }

    

    public synchronized int available() throws IOException {

        return getInIfOpen().available() + (count - pos);

    }

    

    public synchronized void mark(int readlimit) {

        marklimit = readlimit;

        markpos = pos;

    }

    

    public synchronized void reset() throws IOException {

        getBufIfOpen(); // Cause exception if closed

        if (markpos < 0)

            throw new IOException("Resetting to invalid mark");

        pos = markpos;

    }

    

    public boolean markSupported() {

        return true;

    }

    

    public void close() throws IOException {

        byte[] buffer;

        while ( (buffer = buf) != null) {

            if (bufUpdater.compareAndSet(this, buffer, null)) {

                InputStream input = in;

                in = null;

                if (input != null)

                    input.close();

                return;

            }

            // Else retry in case a new buf was CASed in fill()

        }

    }

}