file.encoding.
* The only encodings that are guaranteed to be available are "8859_1"
* (the Latin-1 character set) and "UTF8". Unfortunately, Java does not
* provide a mechanism for listing the encodings that are supported in
* a given implementation.
* * Here is a list of standard encoding names that may be available: *
*
OutputStreamWriter
* to write to the specified stream using a caller supplied character
* encoding scheme. Note that due to a deficiency in the Java language
* design, there is no way to determine which encodings are supported.
*
* @param out The OutputStream to write to
* @param encoding_scheme The name of the encoding scheme to use for
* character to byte translation
*
* @exception UnsupportedEncodingException If the named encoding is
* not available.
*/
public OutputStreamWriter (OutputStream out, String encoding_scheme)
throws UnsupportedEncodingException
{
this(out, UnicodeToBytes.getEncoder(encoding_scheme));
}
/**
* This method initializes a new instance of OutputStreamWriter
* to write to the specified stream using the default encoding.
*
* @param out The OutputStream to write to
*/
public OutputStreamWriter (OutputStream out)
{
this(out, UnicodeToBytes.getDefaultEncoder());
}
/**
* This method initializes a new instance of OutputStreamWriter
* to write to the specified stream using a given Charset.
*
* @param out The OutputStream to write to
* @param cs The Charset of the encoding to use
*/
public OutputStreamWriter(OutputStream out, Charset cs)
{
this(out, new CharsetToBytesAdaptor(cs));
}
/**
* This method initializes a new instance of OutputStreamWriter
* to write to the specified stream using a given
* CharsetEncoder.
*
* @param out The OutputStream to write to
* @param enc The CharsetEncoder to encode the output with
*/
public OutputStreamWriter(OutputStream out, CharsetEncoder enc)
{
this(out, new CharsetToBytesAdaptor(enc));
}
/**
* This method closes this stream, and the underlying
* OutputStream
*
* @exception IOException If an error occurs
*/
public void close () throws IOException
{
synchronized (lock)
{
if (out != null)
{
converter.setFinished();
flush();
out.close();
out = null;
}
work = null;
}
}
/**
* This method returns the name of the character encoding scheme currently
* in use by this stream. If the stream has been closed, then this method
* may return null.
*
* @return The encoding scheme name
*/
public String getEncoding ()
{
return out != null ? converter.getName() : null;
}
/**
* This method flushes any buffered bytes to the underlying output sink.
*
* @exception IOException If an error occurs
*/
public void flush () throws IOException
{
synchronized (lock)
{
if (out == null)
throw new IOException("Stream closed");
// Always write -- if we are close()ing then we want to make
// sure the converter is flushed.
if (work == null)
work = new char[100];
writeChars(work, 0, wcount);
wcount = 0;
out.flush();
}
}
/**
* This method writes count characters from the specified
* array to the output stream starting at position offset
* into the array.
*
* @param buf The array of character to write from
* @param offset The offset into the array to start writing chars from
* @param count The number of chars to write.
*
* @exception IOException If an error occurs
*/
public void write (char[] buf, int offset, int count) throws IOException
{
synchronized (lock)
{
if (out == null)
throw new IOException("Stream closed");
if (wcount > 0)
{
writeChars(work, 0, wcount);
wcount = 0;
}
writeChars(buf, offset, count);
}
}
/*
* Writes characters through to the inferior BufferedOutputStream.
* Ignores wcount and the work buffer.
*/
private void writeChars(char[] buf, int offset, int count)
throws IOException
{
do
{
// We must flush if out.count == out.buf.length.
// It is probably a good idea to flush if out.buf is almost full.
// This test is an approximation for "almost full".
if (out.count + count >= out.buf.length)
{
out.flush();
if (out.count != 0)
throw new IOException("unable to flush output byte buffer");
}
converter.setOutput(out.buf, out.count);
int converted = converter.write(buf, offset, count);
// Must set this before we flush the output stream, because
// flushing will reset 'out.count'.
out.count = converter.count;
// Flush if we cannot make progress.
if (converted == 0 && out.count == converter.count)
{
out.flush();
if (out.count != 0)
throw new IOException("unable to flush output byte buffer");
}
offset += converted;
count -= converted;
}
while (count > 0 || converter.havePendingBytes());
}
/**
* This method writes count bytes from the specified
* String starting at position offset into the
* String.
*
* @param str The String to write chars from
* @param offset The position in the String to start
* writing chars from
* @param count The number of chars to write
*
* @exception IOException If an error occurs
*/
public void write (String str, int offset, int count) throws IOException
{
synchronized (lock)
{
if (out == null)
throw new IOException("Stream closed");
if (work == null)
work = new char[100];
int wlength = work.length;
while (count > 0)
{
int size = count;
if (wcount + size > wlength)
{
if (2*wcount > wlength)
{
writeChars(work, 0, wcount);
wcount = 0;
}
if (wcount + size > wlength)
size = wlength - wcount;
}
str.getChars(offset, offset+size, work, wcount);
offset += size;
count -= size;
wcount += size;
}
}
}
/**
* This method writes a single character to the output stream.
*
* @param ch The char to write, passed as an int.
*
* @exception IOException If an error occurs
*/
public void write (int ch) throws IOException
{
synchronized (lock)
{
if (out == null)
throw new IOException("Stream closed");
if (work == null)
work = new char[100];
if (wcount >= work.length)
{
writeChars(work, 0, wcount);
wcount = 0;
}
work[wcount++] = (char) ch;
}
}
} // class OutputStreamWriter