/**@class java.io.ByteArrayOutputStream
@extends java.io.OutputStream

 This class implements an output stream in which the data is
 written into a byte array. The buffer automatically grows as data
 is written to it.
 The data can be retrieved using <code>toByteArray()</code> and
 <code>toString()</code>.
 <p>
 Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
 this class can be called after the stream has been closed without
 generating an <tt>IOException</tt>.

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

/**Writes the specified byte to this byte array output stream.
@param {Number} b   the byte to be written.
*/
write : function(  ) {},

/**Writes <code>len</code> bytes from the specified byte array
 starting at offset <code>off</code> to this byte array output stream.
@param {Object {byte[]}} b     the data.
@param {Number} off   the start offset in the data.
@param {Number} len   the number of bytes to write.
*/
write : function(  ) {},

/**Writes the complete contents of this byte array output stream to
 the specified output stream argument, as if by calling the output
 stream's write method using <code>out.write(buf, 0, count)</code>.
@param {Object {OutputStream}} out   the output stream to which to write the data.
@exception IOException  if an I/O error occurs.
*/
writeTo : function(  ) {},

/**Resets the <code>count</code> field of this byte array output
 stream to zero, so that all currently accumulated output in the
 output stream is discarded. The output stream can be used again,
 reusing the already allocated buffer space.
@see java.io.ByteArrayInputStream#count
*/
reset : function(  ) {},

/**Creates a newly allocated byte array. Its size is the current
 size of this output stream and the valid contents of the buffer
 have been copied into it.
@return {Number} the current contents of this output stream, as a byte array.
@see java.io.ByteArrayOutputStream#size()
*/
toByteArray : function(  ) {},

/**Returns the current size of the buffer.
@return {Number} the value of the <code>count</code> field, which is the number
          of valid bytes in this output stream.
@see java.io.ByteArrayOutputStream#count
*/
size : function(  ) {},

/**Converts the buffer's contents into a string decoding bytes using the
 platform's default character set. The length of the new <tt>String</tt>
 is a function of the character set, and hence may not be equal to the
 size of the buffer.

 <p> This method always replaces malformed-input and unmappable-character
 sequences with the default replacement string for the platform's
 default character set. The {@linkplain java.nio.charset.CharsetDecoder}
 class should be used when more control over the decoding process is
 required.
@return {String} String decoded from the buffer's contents.
@since JDK1.1
*/
toString : function(  ) {},

/**Converts the buffer's contents into a string by decoding the bytes using
 the specified {@link java.nio.charset.Charset charsetName}. The length of
 the new <tt>String</tt> is a function of the charset, and hence may not be
 equal to the length of the byte array.

 <p> This method always replaces malformed-input and unmappable-character
 sequences with this charset's default replacement string. The {@link java.nio.charset.CharsetDecoder} class should be used when more control
 over the decoding process is required.
@param {String} charsetName  the name of a supported
              {@linkplain java.nio.charset.Charset </code>charset<code>}
@return {String} String decoded from the buffer's contents.
@exception UnsupportedEncodingException
             If the named charset is not supported
@since JDK1.1
*/
toString : function(  ) {},

/**Creates a newly allocated string. Its size is the current size of
 the output stream and the valid contents of the buffer have been
 copied into it. Each character <i>c</i> in the resulting string is
 constructed from the corresponding element <i>b</i> in the byte
 array such that:
 <blockquote><pre>
     c == (char)(((hibyte &amp; 0xff) &lt;&lt; 8) | (b &amp; 0xff))
 </pre></blockquote>
@param {Number} hibyte    the high byte of each resulting Unicode character.
@param hibyte    the high byte of each resulting Unicode character.
@return {String} the current contents of the output stream, as a string.
@see java.io.ByteArrayOutputStream#size()
@see java.io.ByteArrayOutputStream#toString(String)
@see java.io.ByteArrayOutputStream#toString()
*/
toString : function(  ) {},

/**Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
 this class can be called after the stream has been closed without
 generating an <tt>IOException</tt>.
 <p>
*/
close : function(  ) {},


};