home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / java / io / bufferedinputstream.java < prev    next >
Text File  |  1995-08-11  |  7KB  |  220 lines
  1. /*
  2.  * @(#)BufferedInputStream.java    1.15 95/05/10 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.io;
  21.  
  22. /**
  23.  * A buffered input stream. This stream lets you read characters
  24.  * from a stream without causing a read every time. The data
  25.  * is read into a buffer, subsequent reads result in a fast
  26.  * buffer access.
  27.  *
  28.  * @version     1.15, 10 May 1995
  29.  * @author    Arthur van Hoff
  30.  */
  31. public
  32. class BufferedInputStream extends FilterInputStream {
  33.     /**
  34.      * The buffer.
  35.      */
  36.     protected byte buf[];
  37.  
  38.     /**
  39.      * The number of bytes in the buffer.
  40.      */
  41.     protected int count;
  42.  
  43.     /**
  44.      * The current position in the buffer.
  45.      */
  46.     protected int pos;
  47.     
  48.     /**
  49.      * The position in the buffer of the current mark.
  50.      * -1 if there is no current mark.
  51.      */
  52.     protected int markpos = -1;
  53.  
  54.     /**
  55.      * The maximum readahead allowed after a mark() before
  56.      * subsequent calls to reset() fail.
  57.      */
  58.     protected int marklimit;
  59.  
  60.     /**
  61.      * Creates a new buffered stream with a default
  62.      * buffer size.
  63.      * @param in     the input stream
  64.      */
  65.     public BufferedInputStream(InputStream in) {
  66.     this(in, 2048);
  67.     }
  68.  
  69.     /**
  70.      * Creates a new buffered stream with a given
  71.      * buffer size.
  72.      * @param in         the input stream
  73.      * @param size    the buffer size
  74.      */
  75.     public BufferedInputStream(InputStream in, int size) {
  76.     super(in);
  77.     buf = new byte[size];
  78.     }
  79.  
  80.     /**
  81.      * Fill the buffer with more data, taking into account
  82.      * shuffling and other tricks for dealing with marks.
  83.      * Assumes that its being called by a syncronized method.
  84.      * Also assumes that all data has already been read,
  85.      * hence pos>count.
  86.      */
  87.     private void fill() {
  88.     if (markpos < 0)
  89.         pos = 0;        /* no mark: throw away the buffer */
  90.     else if (pos >= buf.length)    /* no room left in buffer */
  91.         if (markpos > 0) {    /* can throw away early part of the buffer */
  92.         int sz = pos - markpos;
  93.         System.arraycopy(buf, markpos, buf, 0, sz);
  94.         pos = sz;
  95.         markpos = 0;
  96.         } else if (buf.length >= marklimit) {
  97.         markpos = -1;    /* buffer got too big, invalidate mark */
  98.         pos = 0;    /* drop buffer contents */
  99.         } else {        /* grow buffer */
  100.         int nsz = pos * 2;
  101.         if (nsz > marklimit)
  102.             nsz = marklimit;
  103.         byte nbuf[] = new byte[nsz];
  104.         System.arraycopy(buf, 0, nbuf, 0, pos);
  105.         buf = nbuf;
  106.         }
  107.     int n = in.read(buf, pos, buf.length - pos);
  108.     count = n <= 0 ? 0 : n + pos;
  109.     }
  110.  
  111.  
  112.     /**
  113.      * Reads a byte. Will block if no input is available.
  114.      * @return     the byte read, or -1 if the end of the
  115.      *        stream is reached.
  116.      * @exception IOException i/o error occurred
  117.      */
  118.     public synchronized int read() {
  119.     if (pos >= count) {
  120.         fill();
  121.         if (count == 0)
  122.         return -1;
  123.     }
  124.     return buf[pos++] & 0xff;
  125.     }
  126.  
  127.     /**
  128.      * Reads into an array of bytes.
  129.      * Blocks until some input is available.
  130.      * This method should be overridden in a subclass for
  131.      * efficiency (the default implementation reads 1 byte
  132.      * at a time).
  133.      * @param b    the buffer into which the data is read
  134.      * @param off the start offset of the data
  135.      * @param len the maximum number of bytes read
  136.      * @return  the actual number of bytes read, -1 is
  137.      *         returned when the end of the stream is reached.
  138.      * @exception IOException i/o error occurred
  139.      */
  140.     public synchronized int read(byte b[], int off, int len) {
  141.     int avail = count - pos;
  142.     if (avail <= 0) {
  143.         fill();
  144.         avail = count - pos;
  145.         if (avail <= 0)
  146.         return -1;
  147.     }
  148.     int cnt = (avail < len) ? avail : len;
  149.     System.arraycopy(buf, pos, b, off, cnt);
  150.     pos += cnt;
  151.     return cnt;
  152.     }
  153.  
  154.     /**
  155.      * Skips bytes of input.
  156.      * @param n     bytes to be skipped
  157.      * @return    actual number of bytes skipped
  158.      * @exception IOException i/o error occurred
  159.      */
  160.     public synchronized int skip(int n) {
  161.     int avail = count - pos;
  162.  
  163.     if (avail >= n) {
  164.         pos += n;
  165.         return n;
  166.     }
  167.  
  168.     pos += avail;
  169.     return avail + in.skip(n - avail);
  170.     }
  171.  
  172.     /**
  173.      * Returns the number of bytes that can be read
  174.      * without blocking. This is the total of the number
  175.      * of bytes in the buffer and the number of bytes
  176.      * available from the input stream.
  177.      * @return the number of available bytes
  178.      */
  179.     public synchronized int available() {
  180.     return (count - pos) + in.available();
  181.     }
  182.  
  183.     /**
  184.      * Mark the current position in the input stream.  A subsequent
  185.      * call to reset() will reposition the stream at the last
  186.      * marked position so that subsequent reads will re-read
  187.      * the same bytes.  The stream promises to allow readlimit bytes
  188.      * to be read before the mark position gets invalidated.
  189.      */
  190.     public synchronized void mark(int readlimit) {
  191.     marklimit = readlimit;
  192.     markpos = pos;
  193.     }
  194.  
  195.     /**
  196.      * Reposition the stream to the last marked position.  If the
  197.      * stream has not been marked, or if the mark has been invalidated,
  198.      * an IOException is thrown.  Stream marks are intended to be used in
  199.      * situations where you need to read ahead a little to see what's in
  200.      * the stream.  Often this is most easily done by invoking some
  201.      * general parser.  If the stream is of the type handled by the
  202.      * parse, it just chugs along happily.  If the stream is *not* of
  203.      * that type, the parser should toss an exception when it fails,
  204.      * which, if it happens within readlimit bytes, allows the outer
  205.      * code to reset the stream and try another parser.
  206.      */
  207.     public synchronized void reset() {
  208.     if (markpos < 0)
  209.         throw new IOException("Resetting to invalid mark");
  210.     pos = markpos;
  211.     }
  212.  
  213.     /**
  214.      * Return true since this stream type supports mark/reset
  215.      */
  216.     public boolean markSupported() {
  217.     return true;
  218.     }
  219. }
  220.