Subclasses that intend to support efficient single-character output + * should override this method. + * + * @param c + * int specifying a character to be written + * + * @throws IOException + * If an I/O error occurs + */ + public void write(int c) throws IOException { + synchronized (lock) { + if (writeBuffer == null){ + writeBuffer = new char[writeBufferSize]; + } + writeBuffer[0] = (char) c; + write(writeBuffer, 0, 1); + } + } + + /** + * Writes an array of characters. + * + * @param cbuf + * Array of characters to be written + * + * @throws IOException + * If an I/O error occurs + */ + public void write(char cbuf[]) throws IOException { + write(cbuf, 0, cbuf.length); + } + + /** + * Writes a portion of an array of characters. + * + * @param cbuf + * Array of characters + * + * @param off + * Offset from which to start writing characters + * + * @param len + * Number of characters to write + * + * @throws IOException + * If an I/O error occurs + */ + abstract public void write(char cbuf[], int off, int len) throws IOException; + + /** + * Writes a string. + * + * @param str + * String to be written + * + * @throws IOException + * If an I/O error occurs + */ + public void write(String str) throws IOException { + write(str, 0, str.length()); + } + + /** + * Writes a portion of a string. + * + * @param str + * A String + * + * @param off + * Offset from which to start writing characters + * + * @param len + * Number of characters to write + * + * @throws IndexOutOfBoundsException + * If off is negative, or len is negative, + * or off+len is negative or greater than the length + * of the given string + * + * @throws IOException + * If an I/O error occurs + */ + public void write(String str, int off, int len) throws IOException { + synchronized (lock) { + char cbuf[]; + if (len <= writeBufferSize) { + if (writeBuffer == null) { + writeBuffer = new char[writeBufferSize]; + } + cbuf = writeBuffer; + } else { // Don't permanently allocate very large buffers. + cbuf = new char[len]; + } + str.getChars(off, (off + len), cbuf, 0); + write(cbuf, 0, len); + } + } + + /** + * Appends the specified character sequence to this writer. + * + *
An invocation of this method of the form out.append(csq) + * behaves in exactly the same way as the invocation + * + *
+ * out.write(csq.toString())+ * + *
Depending on the specification of toString for the + * character sequence csq, the entire sequence may not be + * appended. For instance, invoking the toString 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 csq is + * null, then the four characters "null" are + * appended to this writer. + * + * @return This writer + * + * @throws IOException + * If an I/O error occurs + * + * @since 1.5 + */ + public Writer append(CharSequence csq) throws IOException { + if (csq == null) + write("null"); + else + write(csq.toString()); + return this; + } + + /** + * Appends a subsequence of the specified character sequence to this writer. + * Appendable. + * + *
An invocation of this method of the form out.append(csq, start, + * end) when csq is not null behaves in exactly the + * same way as the invocation + * + *
+ * out.write(csq.subSequence(start, end).toString())+ * + * @param csq + * The character sequence from which a subsequence will be + * appended. If csq is null, then characters + * will be appended as if csq contained the four + * characters "null". + * + * @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 writer + * + * @throws IndexOutOfBoundsException + * If start or end are negative, start + * is greater than end, or end is greater than + * csq.length() + * + * @throws IOException + * If an I/O error occurs + * + * @since 1.5 + */ + public Writer append(CharSequence csq, int start, int end) throws IOException { + CharSequence cs = (csq == null ? "null" : csq); + write(cs.subSequence(start, end).toString()); + return this; + } + + /** + * Appends the specified character to this writer. + * + *
An invocation of this method of the form out.append(c) + * behaves in exactly the same way as the invocation + * + *
+ * out.write(c)+ * + * @param c + * The 16-bit character to append + * + * @return This writer + * + * @throws IOException + * If an I/O error occurs + * + * @since 1.5 + */ + public Writer append(char c) throws IOException { + write(c); + return this; + } + + /** + * Flushes the stream. If the stream has saved any characters from the + * various write() methods in a buffer, write them immediately to their + * intended destination. Then, if that destination is another character or + * byte stream, flush it. Thus one flush() invocation will flush all the + * buffers in a chain of Writers and OutputStreams. + * + *
If the intended destination of this stream is an abstraction provided + * by the underlying operating system, for example a file, then flushing the + * stream guarantees only that bytes previously written to the stream are + * passed to the operating system for writing; it does not guarantee that + * they are actually written to a physical device such as a disk drive. + * + * @throws IOException + * If an I/O error occurs + */ + abstract public void flush() throws IOException; + + /** + * Closes the stream, flushing it first. Once the stream has been closed, + * further write() or flush() invocations will cause an IOException to be + * thrown. Closing a previously closed stream has no effect. + * + * @throws IOException + * If an I/O error occurs + */ + abstract public void close() throws IOException; + +}