/**@class java.io.BufferedInputStream
@extends java.io.FilterInputStream

 A <code>BufferedInputStream</code> adds
 functionality to another input stream-namely,
 the ability to buffer the input and to
 support the <code>mark</code> and <code>reset</code>
 methods. When  the <code>BufferedInputStream</code>
 is created, an internal buffer array is
 created. As bytes  from the stream are read
 or skipped, the internal buffer is refilled
 as necessary  from the contained input stream,
 many bytes at a time. The <code>mark</code>
 operation  remembers a point in the input
 stream and the <code>reset</code> operation
 causes all the  bytes read since the most
 recent <code>mark</code> operation to be
 reread before new bytes are  taken from
 the contained input stream.

 @author  Arthur van Hoff
 @since   JDK1.0
*/
var BufferedInputStream = {

/**See
 the general contract of the <code>read</code>
 method of <code>InputStream</code>.
@return {Number} the next byte of data, or <code>-1</code> if the end of the
             stream is reached.
@exception IOException  if this input stream has been closed by
                          invoking its {@link #close()} method,
                          or an I/O error occurs.
@see java.io.FilterInputStream#in
*/
read : function(  ) {},

/**Reads bytes from this byte-input stream into the specified byte array,
 starting at the given offset.

 <p> This method implements the general contract of the corresponding
 <code>{@link java.io.InputStream#read(byte[], int, int) read}</code> method of
 the <code>{@link java.io.InputStream}</code> class.  As an additional
 convenience, it attempts to read as many bytes as possible by repeatedly
 invoking the <code>read</code> method of the underlying stream.  This
 iterated <code>read</code> continues until one of the following
 conditions becomes true: <ul>

   <li> The specified number of bytes have been read,

   <li> The <code>read</code> method of the underlying stream returns
   <code>-1</code>, indicating end-of-file, or

   <li> The <code>available</code> method of the underlying stream
   returns zero, indicating that further input requests would block.

 </ul> If the first <code>read</code> on the underlying stream returns
 <code>-1</code> to indicate end-of-file then this method returns
 <code>-1</code>.  Otherwise this method returns the number of bytes
 actually read.

 <p> Subclasses of this class are encouraged, but not required, to
 attempt to read as many bytes as possible in the same fashion.
@param {Object {byte[]}} b     destination buffer.
@param {Number} off   offset at which to start storing bytes.
@param {Number} len   maximum number of bytes to read.
@return {Number} the number of bytes read, or <code>-1</code> if the end of
             the stream has been reached.
@exception IOException  if this input stream has been closed by
                          invoking its {@link #close()} method,
                          or an I/O error occurs.
*/
read : function(  ) {},

/**See the general contract of the <code>skip</code>
 method of <code>InputStream</code>.
@exception IOException  if the stream does not support seek,
                          or if this input stream has been closed by
                          invoking its {@link #close()} method, or an
                          I/O error occurs.
*/
skip : function(  ) {},

/**Returns an estimate of the number of bytes that can be read (or
 skipped over) from this input stream without blocking by the next
 invocation of a method for this input stream. The next invocation might be
 the same thread or another thread.  A single read or skip of this
 many bytes will not block, but may read or skip fewer bytes.
 <p>
 This method returns the sum of the number of bytes remaining to be read in
 the buffer (<code>count&nbsp;- pos</code>) and the result of calling the
 {@link java.io.FilterInputStream#in in}.available().
@return {Number} an estimate of the number of bytes that can be read (or skipped
             over) from this input stream without blocking.
@exception IOException  if this input stream has been closed by
                          invoking its {@link #close()} method,
                          or an I/O error occurs.
*/
available : function(  ) {},

/**See the general contract of the <code>mark</code>
 method of <code>InputStream</code>.
@param {Number} readlimit   the maximum limit of bytes that can be read before
                      the mark position becomes invalid.
@see java.io.BufferedInputStream#reset()
*/
mark : function(  ) {},

/**See the general contract of the <code>reset</code>
 method of <code>InputStream</code>.
 <p>
 If <code>markpos</code> is <code>-1</code>
 (no mark has been set or the mark has been
 invalidated), an <code>IOException</code>
 is thrown. Otherwise, <code>pos</code> is
 set equal to <code>markpos</code>.
@exception IOException  if this stream has not been marked or,
                  if the mark has been invalidated, or the stream
                  has been closed by invoking its {@link #close()}
                  method, or an I/O error occurs.
@see java.io.BufferedInputStream#mark(int)
*/
reset : function(  ) {},

/**Tests if this input stream supports the <code>mark</code>
 and <code>reset</code> methods. The <code>markSupported</code>
 method of <code>BufferedInputStream</code> returns
 <code>true</code>.
@return {Boolean} a <code>boolean</code> indicating if this stream type supports
          the <code>mark</code> and <code>reset</code> methods.
@see java.io.InputStream#mark(int)
@see java.io.InputStream#reset()
*/
markSupported : function(  ) {},

/**Closes this input stream and releases any system resources
 associated with the stream.
 Once the stream has been closed, further read(), available(), reset(),
 or skip() invocations will throw an IOException.
 Closing a previously closed stream has no effect.
@exception IOException  if an I/O error occurs.
*/
close : function(  ) {},


};