/**@class java.io.PrintStream
@extends java.lang.Appendable

@extends java.io.Closeable

@extends java.io.FilterOutputStream

 A <code>PrintStream</code> adds functionality to another output stream,
 namely the ability to print representations of various data values
 conveniently.  Two other features are provided as well.  Unlike other output
 streams, a <code>PrintStream</code> never throws an
 <code>IOException</code>; instead, exceptional situations merely set an
 internal flag that can be tested via the <code>checkError</code> method.
 Optionally, a <code>PrintStream</code> can be created so as to flush
 automatically; this means that the <code>flush</code> method is
 automatically invoked after a byte array is written, one of the
 <code>println</code> methods is invoked, or a newline character or byte
 (<code>'\n'</code>) is written.

 <p> All characters printed by a <code>PrintStream</code> are converted into
 bytes using the platform's default character encoding.  The <code>{@link java.io.PrintWriter}</code> class should be used in situations that require writing
 characters rather than bytes.

 @author     Frank Yellin
 @author     Mark Reinhold
 @since      JDK1.0
*/
var PrintStream = {

/**Flushes the stream.  This is done by writing any buffered output bytes to
 the underlying output stream and then flushing that stream.
@see java.io.OutputStream#flush()
*/
flush : function(  ) {},

/**Closes the stream.  This is done by flushing the stream and then closing
 the underlying output stream.
@see java.io.OutputStream#close()
*/
close : function(  ) {},

/**Flushes the stream and checks its error state. The internal error state
 is set to <code>true</code> when the underlying output stream throws an
 <code>IOException</code> other than <code>InterruptedIOException</code>,
 and when the <code>setError</code> method is invoked.  If an operation
 on the underlying output stream throws an
 <code>InterruptedIOException</code>, then the <code>PrintStream</code>
 converts the exception back into an interrupt by doing:
 <pre>
     Thread.currentThread().interrupt();
 </pre>
 or the equivalent.
@return {Boolean} <code>true</code> if and only if this stream has encountered an
         <code>IOException</code> other than
         <code>InterruptedIOException</code>, or the
         <code>setError</code> method has been invoked
*/
checkError : function(  ) {},

/**Writes the specified byte to this stream.  If the byte is a newline and
 automatic flushing is enabled then the <code>flush</code> method will be
 invoked.

 <p> Note that the byte is written as given; to write a character that
 will be translated according to the platform's default character
 encoding, use the <code>print(char)</code> or <code>println(char)</code>
 methods.
@param {Number} b  The byte to be written
@see #print(char)
@see #println(char)
*/
write : function(  ) {},

/**Writes <code>len</code> bytes from the specified byte array starting at
 offset <code>off</code> to this stream.  If automatic flushing is
 enabled then the <code>flush</code> method will be invoked.

 <p> Note that the bytes will be written as given; to write characters
 that will be translated according to the platform's default character
 encoding, use the <code>print(char)</code> or <code>println(char)</code>
 methods.
@param {Object {byte[]}} buf   A byte array
@param {Number} off   Offset from which to start taking bytes
@param {Number} len   Number of bytes to write
*/
write : function(  ) {},

/**Prints a boolean value.  The string produced by <code>{@link java.lang.String#valueOf(boolean)}</code> is translated into bytes
 according to the platform's default character encoding, and these bytes
 are written in exactly the manner of the
 <code>{@link #write}(int)</code> method.
@param {Boolean} b   The <code>boolean</code> to be printed
*/
print : function(  ) {},

/**Prints a character.  The character is translated into one or more bytes
 according to the platform's default character encoding, and these bytes
 are written in exactly the manner of the
 <code>{@link #write}(int)</code> method.
@param {String} c   The <code>char</code> to be printed
*/
print : function(  ) {},

/**Prints an integer.  The string produced by <code>{@link java.lang.String#valueOf(int)}</code> is translated into bytes
 according to the platform's default character encoding, and these bytes
 are written in exactly the manner of the
 <code>{@link #write}(int)</code> method.
@param {Number} i   The <code>int</code> to be printed
@see java.lang.Integer#toString(int)
*/
print : function(  ) {},

/**Prints a long integer.  The string produced by <code>{@link java.lang.String#valueOf(long)}</code> is translated into bytes
 according to the platform's default character encoding, and these bytes
 are written in exactly the manner of the
 <code>{@link #write}(int)</code> method.
@param {Number} l   The <code>long</code> to be printed
@see java.lang.Long#toString(long)
*/
print : function(  ) {},

/**Prints a floating-point number.  The string produced by <code>{@link java.lang.String#valueOf(float)}</code> is translated into bytes
 according to the platform's default character encoding, and these bytes
 are written in exactly the manner of the
 <code>{@link #write}(int)</code> method.
@param {Number} f   The <code>float</code> to be printed
@see java.lang.Float#toString(float)
*/
print : function(  ) {},

/**Prints a double-precision floating-point number.  The string produced by
 <code>{@link java.lang.String#valueOf(double)}</code> is translated into
 bytes according to the platform's default character encoding, and these
 bytes are written in exactly the manner of the <code>{@link #write}(int)</code> method.
@param {Number} d   The <code>double</code> to be printed
@see java.lang.Double#toString(double)
*/
print : function(  ) {},

/**Prints an array of characters.  The characters are converted into bytes
 according to the platform's default character encoding, and these bytes
 are written in exactly the manner of the
 <code>{@link #write}(int)</code> method.
@param {Object {char[]}} s   The array of chars to be printed
@throws NullPointerException  If <code>s</code> is <code>null</code>
*/
print : function(  ) {},

/**Prints a string.  If the argument is <code>null</code> then the string
 <code>"null"</code> is printed.  Otherwise, the string's characters are
 converted into bytes according to the platform's default character
 encoding, and these bytes are written in exactly the manner of the
 <code>{@link #write}(int)</code> method.
@param {String} s   The <code>String</code> to be printed
*/
print : function(  ) {},

/**Prints an object.  The string produced by the <code>{@link java.lang.String#valueOf(Object)}</code> method is translated into bytes
 according to the platform's default character encoding, and these bytes
 are written in exactly the manner of the
 <code>{@link #write}(int)</code> method.
@param {Object {Object}} obj   The <code>Object</code> to be printed
@see java.lang.Object#toString()
*/
print : function(  ) {},

/**Terminates the current line by writing the line separator string.  The
 line separator string is defined by the system property
 <code>line.separator</code>, and is not necessarily a single newline
 character (<code>'\n'</code>).
*/
println : function(  ) {},

/**Prints a boolean and then terminate the line.  This method behaves as
 though it invokes <code>{@link #print}(boolean)</code> and then
 <code>{@link #println}()</code>.
@param {Boolean} x  The <code>boolean</code> to be printed
*/
println : function(  ) {},

/**Prints a character and then terminate the line.  This method behaves as
 though it invokes <code>{@link #print}(char)</code> and then
 <code>{@link #println}()</code>.
@param {String} x  The <code>char</code> to be printed.
*/
println : function(  ) {},

/**Prints an integer and then terminate the line.  This method behaves as
 though it invokes <code>{@link #print}(int)</code> and then
 <code>{@link #println}()</code>.
@param {Number} x  The <code>int</code> to be printed.
*/
println : function(  ) {},

/**Prints a long and then terminate the line.  This method behaves as
 though it invokes <code>{@link #print}(long)</code> and then
 <code>{@link #println}()</code>.
@param {Number} x  a The <code>long</code> to be printed.
*/
println : function(  ) {},

/**Prints a float and then terminate the line.  This method behaves as
 though it invokes <code>{@link #print}(float)</code> and then
 <code>{@link #println}()</code>.
@param {Number} x  The <code>float</code> to be printed.
*/
println : function(  ) {},

/**Prints a double and then terminate the line.  This method behaves as
 though it invokes <code>{@link #print}(double)</code> and then
 <code>{@link #println}()</code>.
@param {Number} x  The <code>double</code> to be printed.
*/
println : function(  ) {},

/**Prints an array of characters and then terminate the line.  This method
 behaves as though it invokes <code>{@link #print(char[])}</code> and
 then <code>{@link #println}()</code>.
@param {Object {char[]}} x  an array of chars to print.
*/
println : function(  ) {},

/**Prints a String and then terminate the line.  This method behaves as
 though it invokes <code>{@link #print}(String)</code> and then
 <code>{@link #println}()</code>.
@param {String} x  The <code>String</code> to be printed.
*/
println : function(  ) {},

/**Prints an Object and then terminate the line.  This method calls
 at first String.valueOf(x) to get the printed object's string value,
 then behaves as
 though it invokes <code>{@link #print}(String)</code> and then
 <code>{@link #println}()</code>.
@param {Object {Object}} x  The <code>Object</code> to be printed.
*/
println : function(  ) {},

/**A convenience method to write a formatted string to this output stream
 using the specified format string and arguments.

 <p> An invocation of this method of the form <tt>out.printf(format,
 args)</tt> behaves in exactly the same way as the invocation

 <pre>
     out.format(format, args) </pre>
@param {String} format
         A format string as described in <a
         href="../util/Formatter.html#syntax">Format string syntax</a>
@param {Object {java.lang.Object[]}} args
         Arguments referenced by the format specifiers in the format
         string.  If there are more arguments than format specifiers, the
         extra arguments are ignored.  The number of arguments is
         variable and may be zero.  The maximum number of arguments is
         limited by the maximum dimension of a Java array as defined by
         <cite>The Java&trade; Virtual Machine Specification</cite>.
         The behaviour on a
         <tt>null</tt> argument depends on the <a
         href="../util/Formatter.html#syntax">conversion</a>.
@throws IllegalFormatException
          If a format string contains an illegal syntax, a format
          specifier that is incompatible with the given arguments,
          insufficient arguments given the format string, or other
          illegal conditions.  For specification of all possible
          formatting errors, see the <a
          href="../util/Formatter.html#detail">Details</a> section of the
          formatter class specification.
@throws NullPointerException
          If the <tt>format</tt> is <tt>null</tt>
@return {Object {java.io.PrintStream}} This output stream
@since 1.5
*/
printf : function(  ) {},

/**A convenience method to write a formatted string to this output stream
 using the specified format string and arguments.

 <p> An invocation of this method of the form <tt>out.printf(l, format,
 args)</tt> behaves in exactly the same way as the invocation

 <pre>
     out.format(l, format, args) </pre>
@param {Object {Locale}} l
         The {@linkplain java.util.Locale locale} to apply during
         formatting.  If <tt>l</tt> is <tt>null</tt> then no localization
         is applied.
@param {String} format
         A format string as described in <a
         href="../util/Formatter.html#syntax">Format string syntax</a>
@param {Object {java.lang.Object[]}} args
         Arguments referenced by the format specifiers in the format
         string.  If there are more arguments than format specifiers, the
         extra arguments are ignored.  The number of arguments is
         variable and may be zero.  The maximum number of arguments is
         limited by the maximum dimension of a Java array as defined by
         <cite>The Java&trade; Virtual Machine Specification</cite>.
         The behaviour on a
         <tt>null</tt> argument depends on the <a
         href="../util/Formatter.html#syntax">conversion</a>.
@throws IllegalFormatException
          If a format string contains an illegal syntax, a format
          specifier that is incompatible with the given arguments,
          insufficient arguments given the format string, or other
          illegal conditions.  For specification of all possible
          formatting errors, see the <a
          href="../util/Formatter.html#detail">Details</a> section of the
          formatter class specification.
@throws NullPointerException
          If the <tt>format</tt> is <tt>null</tt>
@return {Object {java.io.PrintStream}} This output stream
@since 1.5
*/
printf : function(  ) {},

/**Writes a formatted string to this output stream using the specified
 format string and arguments.

 <p> The locale always used is the one returned by {@link java.util.Locale#getDefault() Locale.getDefault()}, regardless of any
 previous invocations of other formatting methods on this object.
@param {String} format
         A format string as described in <a
         href="../util/Formatter.html#syntax">Format string syntax</a>
@param {Object {java.lang.Object[]}} args
         Arguments referenced by the format specifiers in the format
         string.  If there are more arguments than format specifiers, the
         extra arguments are ignored.  The number of arguments is
         variable and may be zero.  The maximum number of arguments is
         limited by the maximum dimension of a Java array as defined by
         <cite>The Java&trade; Virtual Machine Specification</cite>.
         The behaviour on a
         <tt>null</tt> argument depends on the <a
         href="../util/Formatter.html#syntax">conversion</a>.
@throws IllegalFormatException
          If a format string contains an illegal syntax, a format
          specifier that is incompatible with the given arguments,
          insufficient arguments given the format string, or other
          illegal conditions.  For specification of all possible
          formatting errors, see the <a
          href="../util/Formatter.html#detail">Details</a> section of the
          formatter class specification.
@throws NullPointerException
          If the <tt>format</tt> is <tt>null</tt>
@return {Object {java.io.PrintStream}} This output stream
@since 1.5
*/
format : function(  ) {},

/**Writes a formatted string to this output stream using the specified
 format string and arguments.
@param {Object {Locale}} l
         The {@linkplain java.util.Locale locale} to apply during
         formatting.  If <tt>l</tt> is <tt>null</tt> then no localization
         is applied.
@param {String} format
         A format string as described in <a
         href="../util/Formatter.html#syntax">Format string syntax</a>
@param {Object {java.lang.Object[]}} args
         Arguments referenced by the format specifiers in the format
         string.  If there are more arguments than format specifiers, the
         extra arguments are ignored.  The number of arguments is
         variable and may be zero.  The maximum number of arguments is
         limited by the maximum dimension of a Java array as defined by
         <cite>The Java&trade; Virtual Machine Specification</cite>.
         The behaviour on a
         <tt>null</tt> argument depends on the <a
         href="../util/Formatter.html#syntax">conversion</a>.
@throws IllegalFormatException
          If a format string contains an illegal syntax, a format
          specifier that is incompatible with the given arguments,
          insufficient arguments given the format string, or other
          illegal conditions.  For specification of all possible
          formatting errors, see the <a
          href="../util/Formatter.html#detail">Details</a> section of the
          formatter class specification.
@throws NullPointerException
          If the <tt>format</tt> is <tt>null</tt>
@return {Object {java.io.PrintStream}} This output stream
@since 1.5
*/
format : function(  ) {},

/**Appends the specified character sequence to this output stream.

 <p> An invocation of this method of the form <tt>out.append(csq)</tt>
 behaves in exactly the same way as the invocation

 <pre>
     out.print(csq.toString()) </pre>

 <p> Depending on the specification of <tt>toString</tt> for the
 character sequence <tt>csq</tt>, the entire sequence may not be
 appended.  For instance, invoking then <tt>toString</tt> method of a
 character buffer will return a subsequence whose content depends upon
 the buffer's position and limit.
@param {Object {CharSequence}} csq
         The character sequence to append.  If <tt>csq</tt> is
         <tt>null</tt>, then the four characters <tt>"null"</tt> are
         appended to this output stream.
@return {Object {java.io.PrintStream}} This output stream
@since 1.5
*/
append : function(  ) {},

/**Appends a subsequence of the specified character sequence to this output
 stream.

 <p> An invocation of this method of the form <tt>out.append(csq, start,
 end)</tt> when <tt>csq</tt> is not <tt>null</tt>, behaves in
 exactly the same way as the invocation

 <pre>
     out.print(csq.subSequence(start, end).toString()) </pre>
@param {Object {CharSequence}} csq
         The character sequence from which a subsequence will be
         appended.  If <tt>csq</tt> is <tt>null</tt>, then characters
         will be appended as if <tt>csq</tt> contained the four
         characters <tt>"null"</tt>.
@param {Number} start
         The index of the first character in the subsequence
@param {Number} end
         The index of the character following the last character in the
         subsequence
@return {Object {java.io.PrintStream}} This output stream
@throws IndexOutOfBoundsException
          If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>
          is greater than <tt>end</tt>, or <tt>end</tt> is greater than
          <tt>csq.length()</tt>
@since 1.5
*/
append : function(  ) {},

/**Appends the specified character to this output stream.

 <p> An invocation of this method of the form <tt>out.append(c)</tt>
 behaves in exactly the same way as the invocation

 <pre>
     out.print(c) </pre>
@param {String} c
         The 16-bit character to append
@return {Object {java.io.PrintStream}} This output stream
@since 1.5
*/
append : function(  ) {},


};