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
{
CharsetEncoder encoder;
String encodingName;
this.out = out;
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
try
{
// Don't use NIO if avoidable
if(EncodingHelper.isISOLatin1(encoding_scheme))
{
encodingName = "ISO8859_1";
encoder = null;
}
else
{
/*
* Workaround for encodings with a byte-order-mark.
* We only want to write it once per stream.
*/
try
{
if(encoding_scheme.equalsIgnoreCase("UnicodeBig") ||
encoding_scheme.equalsIgnoreCase("UTF-16") ||
encoding_scheme.equalsIgnoreCase("UTF16"))
{
encoding_scheme = "UTF-16BE";
out.write((byte)0xFE);
out.write((byte)0xFF);
}
else if(encoding_scheme.equalsIgnoreCase("UnicodeLittle"))
{
encoding_scheme = "UTF-16LE";
out.write((byte)0xFF);
out.write((byte)0xFE);
}
}
catch(IOException ioe)
{
}
Charset cs = EncodingHelper.getCharset(encoding_scheme);
if(cs == null)
throw new UnsupportedEncodingException("Encoding "+encoding_scheme+
" unknown");
encoder = cs.newEncoder();
encodingName = EncodingHelper.getOldCanonical(cs.name());
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
}
}
catch(RuntimeException e)
{
// Default to ISO Latin-1, will happen if this is called, for instance,
// before the NIO provider is loadable.
encoder = null;
encodingName = "ISO8859_1";
}
this.encoder = encoder;
this.encodingName = encodingName;
}
/**
* 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)
{
CharsetEncoder encoder;
String encodingName;
this.out = out;
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
try
{
String encoding = System.getProperty("file.encoding");
Charset cs = Charset.forName(encoding);
encoder = cs.newEncoder();
encodingName = EncodingHelper.getOldCanonical(cs.name());
}
catch(RuntimeException e)
{
encoder = null;
encodingName = "ISO8859_1";
}
if(encoder != null)
{
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
}
this.encoder = encoder;
this.encodingName = encodingName;
}
/**
* 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
*
* @since 1.5
*/
public OutputStreamWriter(OutputStream out, Charset cs)
{
this.out = out;
encoder = cs.newEncoder();
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
encodingName = EncodingHelper.getOldCanonical(cs.name());
}
/**
* 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
*
* @since 1.5
*/
public OutputStreamWriter(OutputStream out, CharsetEncoder enc)
{
this.out = out;
encoder = enc;
outputBuffer = CharBuffer.allocate(BUFFER_SIZE);
Charset cs = enc.charset();
if (cs == null)
encodingName = "US-ASCII";
else
encodingName = EncodingHelper.getOldCanonical(cs.name());
}
/**
* This method closes this stream, and the underlying
* OutputStream
*
* @exception IOException If an error occurs
*/
public void close () throws IOException
{
if(out == null)
return;
flush();
out.close ();
out = 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 ? encodingName : null;
}
/**
* This method flushes any buffered bytes to the underlying output sink.
*
* @exception IOException If an error occurs
*/
public void flush () throws IOException
{
if(out != null){
if(outputBuffer != null){
char[] buf = new char[outputBuffer.position()];
if(buf.length > 0){
outputBuffer.flip();
outputBuffer.get(buf);
writeConvert(buf, 0, buf.length);
outputBuffer.clear();
}
}
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
{
if(out == null)
throw new IOException("Stream is closed.");
if(buf == null)
throw new IOException("Buffer is null.");
if(outputBuffer != null)
{
if(count >= outputBuffer.remaining())
{
int r = outputBuffer.remaining();
outputBuffer.put(buf, offset, r);
writeConvert(outputBuffer.array(), 0, BUFFER_SIZE);
outputBuffer.clear();
offset += r;
count -= r;
// if the remaining bytes is larger than the whole buffer,
// just don't buffer.
if(count >= outputBuffer.remaining()){
writeConvert(buf, offset, count);
return;
}
}
outputBuffer.put(buf, offset, count);
} else writeConvert(buf, offset, count);
}
/**
* Converts and writes characters.
*/
private void writeConvert (char[] buf, int offset, int count)
throws IOException
{
if(encoder == null)
{
byte[] b = new byte[count];
for(int i=0;iString 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
{
if(str == null)
throw new IOException("String is null.");
write(str.toCharArray(), offset, count);
}
/**
* 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
{
// No buffering, no encoding ... just pass through
if (encoder == null && outputBuffer == null) {
out.write(nullConversion((char)ch));
} else {
if (outputBuffer != null) {
if (outputBuffer.remaining() == 0) {
writeConvert(outputBuffer.array(), 0, BUFFER_SIZE);
outputBuffer.clear();
}
outputBuffer.put((char)ch);
} else {
writeConvert(new char[]{ (char)ch }, 0, 1);
}
}
}
} // class OutputStreamWriter