AutoCloseInputStream xref

View Javadoc

    1   /*
    2    * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/java/org/apache/commons/httpclient/AutoCloseInputStream.java,v 1.9 2004/04/18 23:51:34 jsdever Exp $
    3    * $Revision: 505890 $
    4    * $Date: 2007-02-11 12:25:25 +0100 (Sun, 11 Feb 2007) $
    5    *
    6    * ====================================================================
    7    *
    8    *  Licensed to the Apache Software Foundation (ASF) under one or more
    9    *  contributor license agreements.  See the NOTICE file distributed with
    10   *  this work for additional information regarding copyright ownership.
    11   *  The ASF licenses this file to You under the Apache License, Version 2.0
    12   *  (the "License"); you may not use this file except in compliance with
    13   *  the License.  You may obtain a copy of the License at
    14   *
    15   *      http://www.apache.org/licenses/LICENSE-2.0
    16   *
    17   *  Unless required by applicable law or agreed to in writing, software
    18   *  distributed under the License is distributed on an "AS IS" BASIS,
    19   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    20   *  See the License for the specific language governing permissions and
    21   *  limitations under the License.
    22   * ====================================================================
    23   *
    24   * This software consists of voluntary contributions made by many
    25   * individuals on behalf of the Apache Software Foundation.  For more
    26   * information on the Apache Software Foundation, please see
    27   * <http://www.apache.org/>.
    28   *
    29   */
    30
    31  package org.apache.commons.httpclient;
    32
    33  import java.io.FilterInputStream;
    34  import java.io.IOException;
    35  import java.io.InputStream;
    36
    37  /**
    38   * Closes an underlying stream as soon as the end of the stream is reached, and
    39   * notifies a client when it has done so.
    40   *
    41   * @author Ortwin Glueck
    42   * @author Eric Johnson
    43   * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
    44   *
    45   * @since 2.0
    46   */
    47  class AutoCloseInputStream extends FilterInputStream {
    48
    49      /**
    50       * True if this stream is open.  Assume that the underlying stream
    51       * is open until we get an EOF indication.
    52       */
    53      private boolean streamOpen = true;
    54
    55      /** True if the stream closed itself. */
    56      private boolean selfClosed = false;
    57
    58      /**
    59       * The watcher is notified when the contents of the stream have
    60       * been  exhausted
    61       */
    62      private ResponseConsumedWatcher watcher = null;
    63
    64      /**
    65       * Create a new auto closing stream for the provided connection
    66       *
    67       * @param in the input stream to read from
    68       * @param watcher   To be notified when the contents of the stream have been
    69       *  consumed.
    70       */
    71      public AutoCloseInputStream(
    72              final InputStream in, final ResponseConsumedWatcher watcher) {
    73          super(in);
    74          this.watcher = watcher;
    75      }
    76
    77      /**
    78       * Reads the next byte of data from the input stream.
    79       *
    80       * @throws IOException when there is an error reading
    81       * @return the character read, or -1 for EOF
    82       */
    83      public int read() throws IOException {
    84          int l = -1;
    85
    86          if (isReadAllowed()) {
    87              // underlying stream not closed, go ahead and read.
    88              l = super.read();
    89              checkClose(l);
    90          }
    91
    92          return l;
    93      }
    94
    95      /**
    96       * Reads up to <code>len</code> bytes of data from the stream.
    97       *
    98       * @param b a <code>byte</code> array to read data into
    99       * @param off an offset within the array to store data
    100      * @param len the maximum number of bytes to read
    101      * @return the number of bytes read or -1 for EOF
    102      * @throws IOException if there are errors reading
    103      */
    104     public int read(byte[] b, int off, int len) throws IOException {
    105         int l = -1;
    106
    107         if (isReadAllowed()) {
    108             l = super.read(b,  off,  len);
    109             checkClose(l);
    110         }
    111
    112         return l;
    113     }
    114
    115     /**
    116      * Reads some number of bytes from the input stream and stores them into the
    117      * buffer array b.
    118      *
    119      * @param b a <code>byte</code> array to read data into
    120      * @return the number of bytes read or -1 for EOF
    121      * @throws IOException if there are errors reading
    122      */
    123     public int read(byte[] b) throws IOException {
    124         int l = -1;
    125
    126         if (isReadAllowed()) {
    127             l = super.read(b);
    128             checkClose(l);
    129         }
    130         return l;
    131     }
    132
    133     /**
    134      * Obtains the number of bytes that can be read without blocking.
    135      *
    136      * @return  the number of bytes available without blocking
    137      * @throws IOException in case of a problem
    138      */
    139     public int available() throws IOException {
    140         int a = 0; // not -1
    141
    142         if (isReadAllowed()) {
    143             a = super.available();
    144             // no checkClose() here, available() can't trigger EOF
    145         }
    146
    147         return a;
    148     }
    149
    150     /**
    151      * Close the stream, and also close the underlying stream if it is not
    152      * already closed.
    153      * @throws IOException If an IO problem occurs.
    154      */
    155     public void close() throws IOException {
    156         if (!selfClosed) {
    157             selfClosed = true;
    158             notifyWatcher();
    159         }
    160     }
    161
    162     /**
    163      * Close the underlying stream should the end of the stream arrive.
    164      *
    165      * @param readResult    The result of the read operation to check.
    166      * @throws IOException If an IO problem occurs.
    167      */
    168     private void checkClose(int readResult) throws IOException {
    169         if (readResult == -1) {
    170             notifyWatcher();
    171         }
    172     }
    173
    174     /**
    175      * See whether a read of the underlying stream should be allowed, and if
    176      * not, check to see whether our stream has already been closed!
    177      *
    178      * @return <code>true</code> if it is still OK to read from the stream.
    179      * @throws IOException If an IO problem occurs.
    180      */
    181     private boolean isReadAllowed() throws IOException {
    182         if (!streamOpen && selfClosed) {
    183             throw new IOException("Attempted read on closed stream.");
    184         }
    185         return streamOpen;
    186     }
    187
    188     /**
    189      * Notify the watcher that the contents have been consumed.
    190      * @throws IOException If an IO problem occurs.
    191      */
    192     private void notifyWatcher() throws IOException {
    193         if (streamOpen) {
    194             super.close();
    195             streamOpen = false;
    196
    197             if (watcher != null) {
    198                 watcher.responseConsumed();
    199             }
    200         }
    201     }
    202 }
    203