this
*/
protected Object lock;
/**
* This is the default no-argument constructor for this class. This method
* will set up the class to synchronize criticial sections on itself.
*/
protected Writer()
{
lock = this;
}
/**
* This method initializes a Writer that will synchronize
* on the specified Object.
*
* @param lock The Object to use for synchronizing critical
* sections. Must not be null.
*/
protected Writer(Object lock)
{
if (lock == null)
throw new NullPointerException();
this.lock = lock;
}
/**
* This method forces any data that may have been buffered to be written
* to the underlying output device. Please note that the host environment
* might perform its own buffering unbeknowst to Java. In that case, a
* write made (for example, to a disk drive) might be cached in OS
* buffers instead of actually being written to disk.
*
* @exception IOException If an error occurs
*/
public abstract void flush() throws IOException;
/**
* This method closes the stream. Any internal or native resources
* associated
* with this stream are freed. Any subsequent attempt to access the stream
* might throw an exception.
*
* This method in this class does nothing.
*
* @exception IOException If an error occurs
*/
public abstract void close() throws IOException;
/**
* This method writes a single char to the output stream.
*
* @param b The char to be written to the output stream, passed as an int
*
* @exception IOException If an error occurs
*/
public void write(int b) throws IOException
{
char[] buf = new char[1];
buf[0] = (char)b;
write(buf, 0, buf.length);
}
/**
* This method all the writes char from the passed array to the output
* stream. This method is equivalent to
* write(buf, 0, buf.length) which
* is exactly how it is implemented in this class.
*
* @param buf The array of char to write
*
* @exception IOException If an error occurs
*/
public void write(char[] buf) throws IOException
{
write(buf, 0, buf.length);
}
/**
* This method writes len char from the specified array
* buf starting at index offset into the array.
*
* Subclasses must provide an implementation of this abstract method.
*
* @param buf The array of char to write from
* @param offset The index into the array to start writing from
* @param len The number of char to write
*
* @exception IOException If an error occurs
*/
public abstract void write(char[] buf, int offset, int len)
throws IOException;
/**
* This method writes all the characters in a String to the
* output.
*
* @param str The String whose chars are to be written.
*
* @exception IOException If an error occurs
*/
public void write(String str) throws IOException
{
write(str, 0, str.length());
}
/**
* This method writes len chars from the String
* starting at position offset.
*
* @param str The String that is to be written
* @param offset The character offset into the String to start
* writing from
* @param len The number of chars to write
*
* @exception IOException If an error occurs
*/
public void write(String str, int offset, int len) throws IOException
{
// FIXME - for libgcj re-write using native code to not require
// copied buffer.
char[] buf = new char[len];
str.getChars(offset, offset + len, buf, 0);
write(buf, 0, len);
}
/** @since 1.5 */
public Writer append(char c) throws IOException
{
write(c);
return this;
}
/** @since 1.5 */
public Writer append(CharSequence cs) throws IOException
{
write(cs == null ? "null" : cs.toString());
return this;
}
/** @since 1.5 */
public Writer append(CharSequence cs, int start, int end) throws IOException
{
write(cs == null ? "null" : cs.subSequence(start, end).toString());
return this;
}
}