351 lines
10 KiB
Java
351 lines
10 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
|
||
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||
|
|
*
|
||
|
|
* This code is free software; you can redistribute it and/or modify it
|
||
|
|
* under the terms of the GNU General Public License version 2 only, as
|
||
|
|
* published by the Free Software Foundation. Oracle designates this
|
||
|
|
* particular file as subject to the "Classpath" exception as provided
|
||
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
||
|
|
*
|
||
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
||
|
|
* accompanied this code).
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU General Public License version
|
||
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
||
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||
|
|
*
|
||
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||
|
|
* or visit www.oracle.com if you need additional information or have any
|
||
|
|
* questions.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
*/
|
||
|
|
|
||
|
|
package sun.nio.cs;
|
||
|
|
|
||
|
|
import java.io.*;
|
||
|
|
import java.nio.*;
|
||
|
|
import java.nio.channels.*;
|
||
|
|
import java.nio.charset.*;
|
||
|
|
|
||
|
|
public class StreamEncoder extends Writer
|
||
|
|
{
|
||
|
|
|
||
|
|
private static final int DEFAULT_BYTE_BUFFER_SIZE = 8192;
|
||
|
|
|
||
|
|
private volatile boolean isOpen = true;
|
||
|
|
|
||
|
|
private void ensureOpen() throws IOException {
|
||
|
|
if (!isOpen)
|
||
|
|
throw new IOException("Stream closed");
|
||
|
|
}
|
||
|
|
|
||
|
|
// Factories for java.io.OutputStreamWriter
|
||
|
|
public static StreamEncoder forOutputStreamWriter(OutputStream out,
|
||
|
|
Object lock,
|
||
|
|
String charsetName)
|
||
|
|
throws UnsupportedEncodingException
|
||
|
|
{
|
||
|
|
String csn = charsetName;
|
||
|
|
if (csn == null)
|
||
|
|
csn = Charset.defaultCharset().name();
|
||
|
|
try {
|
||
|
|
if (Charset.isSupported(csn))
|
||
|
|
return new StreamEncoder(out, lock, Charset.forName(csn));
|
||
|
|
} catch (IllegalCharsetNameException x) { }
|
||
|
|
throw new UnsupportedEncodingException (csn);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static StreamEncoder forOutputStreamWriter(OutputStream out,
|
||
|
|
Object lock,
|
||
|
|
Charset cs)
|
||
|
|
{
|
||
|
|
return new StreamEncoder(out, lock, cs);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static StreamEncoder forOutputStreamWriter(OutputStream out,
|
||
|
|
Object lock,
|
||
|
|
CharsetEncoder enc)
|
||
|
|
{
|
||
|
|
return new StreamEncoder(out, lock, enc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Factory for java.nio.channels.Channels.newWriter
|
||
|
|
|
||
|
|
public static StreamEncoder forEncoder(WritableByteChannel ch,
|
||
|
|
CharsetEncoder enc,
|
||
|
|
int minBufferCap)
|
||
|
|
{
|
||
|
|
return new StreamEncoder(ch, enc, minBufferCap);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// -- Public methods corresponding to those in OutputStreamWriter --
|
||
|
|
|
||
|
|
// All synchronization and state/argument checking is done in these public
|
||
|
|
// methods; the concrete stream-encoder subclasses defined below need not
|
||
|
|
// do any such checking.
|
||
|
|
|
||
|
|
public String getEncoding() {
|
||
|
|
if (isOpen())
|
||
|
|
return encodingName();
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void flushBuffer() throws IOException {
|
||
|
|
synchronized (lock) {
|
||
|
|
if (isOpen())
|
||
|
|
implFlushBuffer();
|
||
|
|
else
|
||
|
|
throw new IOException("Stream closed");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void write(int c) throws IOException {
|
||
|
|
char cbuf[] = new char[1];
|
||
|
|
cbuf[0] = (char) c;
|
||
|
|
write(cbuf, 0, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void write(char cbuf[], int off, int len) throws IOException {
|
||
|
|
synchronized (lock) {
|
||
|
|
ensureOpen();
|
||
|
|
if ((off < 0) || (off > cbuf.length) || (len < 0) ||
|
||
|
|
((off + len) > cbuf.length) || ((off + len) < 0)) {
|
||
|
|
throw new IndexOutOfBoundsException();
|
||
|
|
} else if (len == 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
implWrite(cbuf, off, len);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void write(CharBuffer cb) throws IOException {
|
||
|
|
int position = cb.position();
|
||
|
|
try {
|
||
|
|
synchronized (lock) {
|
||
|
|
ensureOpen();
|
||
|
|
implWrite(cb);
|
||
|
|
}
|
||
|
|
} finally {
|
||
|
|
cb.position(position);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void write(String str, int off, int len) throws IOException {
|
||
|
|
/* Check the len before creating a char buffer */
|
||
|
|
if (len < 0)
|
||
|
|
throw new IndexOutOfBoundsException();
|
||
|
|
char cbuf[] = new char[len];
|
||
|
|
str.getChars(off, off + len, cbuf, 0);
|
||
|
|
write(cbuf, 0, len);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void flush() throws IOException {
|
||
|
|
synchronized (lock) {
|
||
|
|
ensureOpen();
|
||
|
|
implFlush();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void close() throws IOException {
|
||
|
|
synchronized (lock) {
|
||
|
|
if (!isOpen)
|
||
|
|
return;
|
||
|
|
implClose();
|
||
|
|
isOpen = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private boolean isOpen() {
|
||
|
|
return isOpen;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// -- Charset-based stream encoder impl --
|
||
|
|
|
||
|
|
private Charset cs;
|
||
|
|
private CharsetEncoder encoder;
|
||
|
|
private ByteBuffer bb;
|
||
|
|
|
||
|
|
// Exactly one of these is non-null
|
||
|
|
private final OutputStream out;
|
||
|
|
private WritableByteChannel ch;
|
||
|
|
|
||
|
|
// Leftover first char in a surrogate pair
|
||
|
|
private boolean haveLeftoverChar = false;
|
||
|
|
private char leftoverChar;
|
||
|
|
private CharBuffer lcb = null;
|
||
|
|
|
||
|
|
private StreamEncoder(OutputStream out, Object lock, Charset cs) {
|
||
|
|
this(out, lock,
|
||
|
|
cs.newEncoder()
|
||
|
|
.onMalformedInput(CodingErrorAction.REPLACE)
|
||
|
|
.onUnmappableCharacter(CodingErrorAction.REPLACE));
|
||
|
|
}
|
||
|
|
|
||
|
|
private StreamEncoder(OutputStream out, Object lock, CharsetEncoder enc) {
|
||
|
|
super(lock);
|
||
|
|
this.out = out;
|
||
|
|
this.ch = null;
|
||
|
|
this.cs = enc.charset();
|
||
|
|
this.encoder = enc;
|
||
|
|
|
||
|
|
// This path disabled until direct buffers are faster
|
||
|
|
if (false && out instanceof FileOutputStream) {
|
||
|
|
ch = ((FileOutputStream)out).getChannel();
|
||
|
|
if (ch != null)
|
||
|
|
bb = ByteBuffer.allocateDirect(DEFAULT_BYTE_BUFFER_SIZE);
|
||
|
|
}
|
||
|
|
if (ch == null) {
|
||
|
|
bb = ByteBuffer.allocate(DEFAULT_BYTE_BUFFER_SIZE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private StreamEncoder(WritableByteChannel ch, CharsetEncoder enc, int mbc) {
|
||
|
|
this.out = null;
|
||
|
|
this.ch = ch;
|
||
|
|
this.cs = enc.charset();
|
||
|
|
this.encoder = enc;
|
||
|
|
this.bb = ByteBuffer.allocate(mbc < 0
|
||
|
|
? DEFAULT_BYTE_BUFFER_SIZE
|
||
|
|
: mbc);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void writeBytes() throws IOException {
|
||
|
|
bb.flip();
|
||
|
|
int lim = bb.limit();
|
||
|
|
int pos = bb.position();
|
||
|
|
assert (pos <= lim);
|
||
|
|
int rem = (pos <= lim ? lim - pos : 0);
|
||
|
|
|
||
|
|
if (rem > 0) {
|
||
|
|
if (ch != null) {
|
||
|
|
if (ch.write(bb) != rem)
|
||
|
|
assert false : rem;
|
||
|
|
} else {
|
||
|
|
out.write(bb.array(), bb.arrayOffset() + pos, rem);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
bb.clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
private void flushLeftoverChar(CharBuffer cb, boolean endOfInput)
|
||
|
|
throws IOException
|
||
|
|
{
|
||
|
|
if (!haveLeftoverChar && !endOfInput)
|
||
|
|
return;
|
||
|
|
if (lcb == null)
|
||
|
|
lcb = CharBuffer.allocate(2);
|
||
|
|
else
|
||
|
|
lcb.clear();
|
||
|
|
if (haveLeftoverChar)
|
||
|
|
lcb.put(leftoverChar);
|
||
|
|
if ((cb != null) && cb.hasRemaining())
|
||
|
|
lcb.put(cb.get());
|
||
|
|
lcb.flip();
|
||
|
|
while (lcb.hasRemaining() || endOfInput) {
|
||
|
|
CoderResult cr = encoder.encode(lcb, bb, endOfInput);
|
||
|
|
if (cr.isUnderflow()) {
|
||
|
|
if (lcb.hasRemaining()) {
|
||
|
|
leftoverChar = lcb.get();
|
||
|
|
if (cb != null && cb.hasRemaining())
|
||
|
|
flushLeftoverChar(cb, endOfInput);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (cr.isOverflow()) {
|
||
|
|
assert bb.position() > 0;
|
||
|
|
writeBytes();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
cr.throwException();
|
||
|
|
}
|
||
|
|
haveLeftoverChar = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
void implWrite(char[] cbuf, int off, int len)
|
||
|
|
throws IOException
|
||
|
|
{
|
||
|
|
CharBuffer cb = CharBuffer.wrap(cbuf, off, len);
|
||
|
|
implWrite(cb);
|
||
|
|
}
|
||
|
|
|
||
|
|
void implWrite(CharBuffer cb)
|
||
|
|
throws IOException
|
||
|
|
{
|
||
|
|
if (haveLeftoverChar) {
|
||
|
|
flushLeftoverChar(cb, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
while (cb.hasRemaining()) {
|
||
|
|
CoderResult cr = encoder.encode(cb, bb, false);
|
||
|
|
if (cr.isUnderflow()) {
|
||
|
|
assert (cb.remaining() <= 1) : cb.remaining();
|
||
|
|
if (cb.remaining() == 1) {
|
||
|
|
haveLeftoverChar = true;
|
||
|
|
leftoverChar = cb.get();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (cr.isOverflow()) {
|
||
|
|
assert bb.position() > 0;
|
||
|
|
writeBytes();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
cr.throwException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void implFlushBuffer() throws IOException {
|
||
|
|
if (bb.position() > 0)
|
||
|
|
writeBytes();
|
||
|
|
}
|
||
|
|
|
||
|
|
void implFlush() throws IOException {
|
||
|
|
implFlushBuffer();
|
||
|
|
if (out != null)
|
||
|
|
out.flush();
|
||
|
|
}
|
||
|
|
|
||
|
|
void implClose() throws IOException {
|
||
|
|
flushLeftoverChar(null, true);
|
||
|
|
try {
|
||
|
|
for (;;) {
|
||
|
|
CoderResult cr = encoder.flush(bb);
|
||
|
|
if (cr.isUnderflow())
|
||
|
|
break;
|
||
|
|
if (cr.isOverflow()) {
|
||
|
|
assert bb.position() > 0;
|
||
|
|
writeBytes();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
cr.throwException();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bb.position() > 0)
|
||
|
|
writeBytes();
|
||
|
|
if (ch != null)
|
||
|
|
ch.close();
|
||
|
|
else
|
||
|
|
out.close();
|
||
|
|
} catch (IOException x) {
|
||
|
|
encoder.reset();
|
||
|
|
throw x;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
String encodingName() {
|
||
|
|
return ((cs instanceof HistoricallyNamedCharset)
|
||
|
|
? ((HistoricallyNamedCharset)cs).historicalName()
|
||
|
|
: cs.name());
|
||
|
|
}
|
||
|
|
}
|