package java.io;

import ej.annotation.Nullable;

/**
 * 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.
 */
public class PrintStream extends FilterOutputStream implements Appendable, Closeable {

	/**
	 * Creates a new print stream. This stream will not flush automatically.
	 *
	 * @param out
	 *        The output stream to which values and objects will be printed
	 */
	public PrintStream(OutputStream out) {
		super(out);
		throw new RuntimeException();
	}

	/**
	 * Creates a new print stream.
	 *
	 * @param out
	 *        The output stream to which values and objects will be printed
	 * @param autoFlush
	 *        A boolean; if true, the output buffer will be flushed whenever 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
	 */
	public PrintStream(OutputStream out, boolean autoFlush) {
		super(out);
		throw new RuntimeException();
	}

	/**
	 * Creates a new print stream.
	 *
	 * @param out
	 *        The output stream to which values and objects will be printed
	 * @param autoFlush
	 *        A boolean; if true, the output buffer will be flushed whenever 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
	 * @param encoding
	 *        The name of a supported character encoding
	 *
	 * @throws UnsupportedEncodingException
	 *         If the named encoding is not supported
	 *
	 */
	public PrintStream(OutputStream out, boolean autoFlush, String encoding) throws UnsupportedEncodingException {
		super(out);
		throw new RuntimeException();
	}

	/**
	 * Appends the specified character to this output stream.
	 *
	 * <p>
	 * An invocation of this method of the form <code>out.append(c)</code> behaves in exactly the same way
	 * as the invocation
	 *
	 * <pre>
	 * out.print(c)
	 * </pre>
	 *
	 * @param c
	 *        The 16-bit character to append
	 *
	 * @return This output stream
	 */
	@Override
	public PrintStream append(char c) {
		throw new RuntimeException();
	}

	/**
	 * Appends the specified character sequence to this output stream.
	 *
	 * <p>
	 * An invocation of this method of the form <code>out.append(csq)</code> behaves in exactly the same way
	 * as the invocation
	 *
	 * <pre>
	 * out.print(csq.toString())
	 * </pre>
	 *
	 * <p>
	 * Depending on the specification of <code>toString</code> for the character sequence <code>csq</code>, the
	 * entire sequence may not be appended. For instance, invoking then <code>toString</code> method of a
	 * character buffer will return a subsequence whose content depends upon the buffer's position and
	 * limit.
	 *
	 * @param csq
	 *        The character sequence to append. If <code>csq</code> is <code>null</code>, then the four
	 *        characters <code>"null"</code> are appended to this output stream.
	 *
	 * @return This output stream
	 */
	@Override
	public PrintStream append(@Nullable CharSequence csq) {
		throw new RuntimeException();
	}

	/**
	 * Appends a subsequence of the specified character sequence to this output stream.
	 *
	 * <p>
	 * An invocation of this method of the form <code>out.append(csq, start,
	 * end)</code> when <code>csq</code> is not <code>null</code>, behaves in exactly the same way as the
	 * invocation
	 *
	 * <pre>
	 * out.print(csq.subSequence(start, end).toString())
	 * </pre>
	 *
	 * @param csq
	 *        The character sequence from which a subsequence will be appended. If <code>csq</code> is
	 *        <code>null</code>, then characters will be appended as if <code>csq</code> contained the four
	 *        characters <code>"null"</code>.
	 *
	 * @param start
	 *        The index of the first character in the subsequence
	 *
	 * @param end
	 *        The index of the character following the last character in the subsequence
	 *
	 * @return This output stream
	 *
	 * @throws IndexOutOfBoundsException
	 *         If <code>start</code> or <code>end</code> are negative, <code>start</code> is greater than
	 *         <code>end</code>, or <code>end</code> is greater than <code>csq.length()</code>
	 */
	@Override
	public PrintStream append(@Nullable CharSequence csq, int start, int end) {
		throw new RuntimeException();
	}

	/**
	 * 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 <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
	 */
	public boolean checkError() {
		throw new RuntimeException();
	}

	/**
	 * Clears the internal error state of this stream.
	 *
	 * <p>
	 * This method will cause subsequent invocations of {@link #checkError()} to return <code>false</code>
	 * until another write operation fails and invokes {@link #setError()}.
	 */
	protected void clearError() {
		throw new RuntimeException();
	}

	/**
	 * Closes the stream. This is done by flushing the stream and then closing the underlying output
	 * stream.
	 *
	 * @see java.io.OutputStream#close()
	 */
	@Override
	public void close() {
		throw new RuntimeException();
	}

	/**
	 * 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()
	 */
	@Override
	public void flush() {
		throw new RuntimeException();
	}

	/**
	 * 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 b
	 *        The <code>boolean</code> to be printed
	 */
	public void print(boolean b) {
		throw new RuntimeException();
	}

	/**
	 * 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 c
	 *        The <code>char</code> to be printed
	 */
	public void print(char c) {
		throw new RuntimeException();
	}

	/**
	 * 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 s
	 *        The array of chars to be printed
	 *
	 * @throws NullPointerException
	 *         If <code>s</code> is <code>null</code>
	 */
	public void print(char[] s) {
		throw new RuntimeException();
	}

	/**
	 * 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 d
	 *        The <code>double</code> to be printed
	 * @see java.lang.Double#toString(double)
	 */
	public void print(double d) {
		throw new RuntimeException();
	}

	/**
	 * 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 f
	 *        The <code>float</code> to be printed
	 * @see java.lang.Float#toString(float)
	 */
	public void print(float f) {
		throw new RuntimeException();
	}

	/**
	 * 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 i
	 *        The <code>int</code> to be printed
	 * @see java.lang.Integer#toString(int)
	 */
	public void print(int i) {
		throw new RuntimeException();
	}

	/**
	 * 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 l
	 *        The <code>long</code> to be printed
	 * @see java.lang.Long#toString(long)
	 */
	public void print(long l) {
		throw new RuntimeException();
	}

	/**
	 * 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 obj
	 *        The <code>Object</code> to be printed
	 * @see java.lang.Object#toString()
	 */
	public void print(@Nullable Object obj) {
		throw new RuntimeException();
	}

	/**
	 * 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 s
	 *        The <code>String</code> to be printed
	 */
	public void print(@Nullable String s) {
		throw new RuntimeException();
	}

	/**
	 * 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>).
	 */
	public void println() {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        The <code>boolean</code> to be printed
	 */
	public void println(boolean x) {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        The <code>char</code> to be printed.
	 */
	public void println(char x) {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        an array of chars to print.
	 */
	public void println(char[] x) {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        The <code>double</code> to be printed.
	 */
	public void println(double x) {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        The <code>float</code> to be printed.
	 */
	public void println(float x) {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        The <code>int</code> to be printed.
	 */
	public void println(int x) {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        a The <code>long</code> to be printed.
	 */
	public void println(long x) {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        The <code>Object</code> to be printed.
	 */
	public void println(@Nullable Object x) {
		throw new RuntimeException();
	}

	/**
	 * 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 x
	 *        The <code>String</code> to be printed.
	 */
	public void println(@Nullable String x) {
		throw new RuntimeException();
	}

	/**
	 * Sets the error state of the stream to <code>true</code>.
	 *
	 * <p>
	 * This method will cause subsequent invocations of {@link #checkError()} to return <code>true</code>
	 * until {@link #clearError()} is invoked.
	 */
	protected void setError() {
		throw new RuntimeException();
	}

	/**
	 * 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 buf
	 *        A byte array
	 * @param off
	 *        Offset from which to start taking bytes
	 * @param len
	 *        Number of bytes to write
	 */
	@Override
	public void write(byte[] buf, int off, int len) {
		throw new RuntimeException();
	}

	/**
	 * 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 b
	 *        The byte to be written
	 * @see #print(char)
	 * @see #println(char)
	 */
	@Override
	public void write(int b) {
		throw new RuntimeException();
	}
}