package com.android.internal.util;
import android.util.Printer;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
public class FastPrintWriter extends PrintWriter {
private static class DummyWriter extends Writer {
@Override
public void close() throws IOException {
UnsupportedOperationException ex
= new UnsupportedOperationException("Shouldn't be here");
throw ex;
}
@Override
public void flush() throws IOException {
close();
}
@Override
public void write(char[] buf, int offset, int count) throws IOException {
close();
}
};
private final int mBufferLen;
private final char[] mText;
private int mPos;
final private OutputStream mOutputStream;
final private boolean mAutoFlush;
final private String mSeparator;
final private Writer mWriter;
final private Printer mPrinter;
private CharsetEncoder mCharset;
final private ByteBuffer mBytes;
private boolean mIoError;
/**
* Constructs a new {@code PrintWriter} with {@code out} as its target
* stream. By default, the new print writer does not automatically flush its
* contents to the target stream when a newline is encountered.
*
* @param out
* the target output stream.
* @throws NullPointerException
* if {@code out} is {@code null}.
*/
public FastPrintWriter(OutputStream out) {
this(out, false, 8192);
}
/**
* Constructs a new {@code PrintWriter} with {@code out} as its target
* stream. The parameter {@code autoFlush} determines if the print writer
* automatically flushes its contents to the target stream when a newline is
* encountered.
*
* @param out
* the target output stream.
* @param autoFlush
* indicates whether contents are flushed upon encountering a
* newline sequence.
* @throws NullPointerException
* if {@code out} is {@code null}.
*/
public FastPrintWriter(OutputStream out, boolean autoFlush) {
this(out, autoFlush, 8192);
}
/**
* Constructs a new {@code PrintWriter} with {@code out} as its target
* stream and a custom buffer size. The parameter {@code autoFlush} determines
* if the print writer automatically flushes its contents to the target stream
* when a newline is encountered.
*
* @param out
* the target output stream.
* @param autoFlush
* indicates whether contents are flushed upon encountering a
* newline sequence.
* @param bufferLen
* specifies the size of the FastPrintWriter's internal buffer; the
* default is 8192.
* @throws NullPointerException
* if {@code out} is {@code null}.
*/
public FastPrintWriter(OutputStream out, boolean autoFlush, int bufferLen) {
super(new DummyWriter(), autoFlush);
if (out == null) {
throw new NullPointerException("out is null");
}
mBufferLen = bufferLen;
mText = new char[bufferLen];
mBytes = ByteBuffer.allocate(mBufferLen);
mOutputStream = out;
mWriter = null;
mPrinter = null;
mAutoFlush = autoFlush;
mSeparator = System.lineSeparator();
initDefaultEncoder();
}
/**
* Constructs a new {@code PrintWriter} with {@code wr} as its target
* writer. By default, the new print writer does not automatically flush its
* contents to the target writer when a newline is encountered.
*
* <p>NOTE: Unlike PrintWriter, this version will still do buffering inside of
* FastPrintWriter before sending data to the Writer. This means you must call
* flush() before retrieving any data from the Writer.</p>
*
* @param wr
* the target writer.
* @throws NullPointerException
* if {@code wr} is {@code null}.
*/
public FastPrintWriter(Writer wr) {
this(wr, false, 8192);
}
/**
* Constructs a new {@code PrintWriter} with {@code wr} as its target
* writer. The parameter {@code autoFlush} determines if the print writer
* automatically flushes its contents to the target writer when a newline is
* encountered.
*
* @param wr
* the target writer.
* @param autoFlush
* indicates whether to flush contents upon encountering a
* newline sequence.
* @throws NullPointerException
* if {@code out} is {@code null}.
*/
public FastPrintWriter(Writer wr, boolean autoFlush) {
this(wr, autoFlush, 8192);
}
/**
* Constructs a new {@code PrintWriter} with {@code wr} as its target
* writer and a custom buffer size. The parameter {@code autoFlush} determines
* if the print writer automatically flushes its contents to the target writer
* when a newline is encountered.
*
* @param wr
* the target writer.
* @param autoFlush
* indicates whether to flush contents upon encountering a
* newline sequence.
* @param bufferLen
* specifies the size of the FastPrintWriter's internal buffer; the
* default is 8192.
* @throws NullPointerException
* if {@code wr} is {@code null}.
*/
public FastPrintWriter(Writer wr, boolean autoFlush, int bufferLen) {
super(new DummyWriter(), autoFlush);
if (wr == null) {
throw new NullPointerException("wr is null");
}
mBufferLen = bufferLen;
mText = new char[bufferLen];
mBytes = null;
mOutputStream = null;
mWriter = wr;
mPrinter = null;
mAutoFlush = autoFlush;
mSeparator = System.lineSeparator();
initDefaultEncoder();
}
/**
* Constructs a new {@code PrintWriter} with {@code pr} as its target
* printer and the default buffer size. Because a {@link Printer} is line-base,
* autoflush is always enabled.
*
* @param pr
* the target writer.
* @throws NullPointerException
* if {@code pr} is {@code null}.
*/
public FastPrintWriter(Printer pr) {
this(pr, 512);
}
/**
* Constructs a new {@code PrintWriter} with {@code pr} as its target
* printer and a custom buffer size. Because a {@link Printer} is line-base,
* autoflush is always enabled.
*
* @param pr
* the target writer.
* @param bufferLen
* specifies the size of the FastPrintWriter's internal buffer; the
* default is 512.
* @throws NullPointerException
* if {@code pr} is {@code null}.
*/
public FastPrintWriter(Printer pr, int bufferLen) {
super(new DummyWriter(), true);
if (pr == null) {
throw new NullPointerException("pr is null");
}
mBufferLen = bufferLen;
mText = new char[bufferLen];
mBytes = null;
mOutputStream = null;
mWriter = null;
mPrinter = pr;
mAutoFlush = true;
mSeparator = System.lineSeparator();
initDefaultEncoder();
}
private final void initEncoder(String csn) throws UnsupportedEncodingException {
try {
mCharset = Charset.forName(csn).newEncoder();
} catch (Exception e) {
throw new UnsupportedEncodingException(csn);
}
mCharset.onMalformedInput(CodingErrorAction.REPLACE);
mCharset.onUnmappableCharacter(CodingErrorAction.REPLACE);
}
/**
* Flushes this writer and returns the value of the error flag.
*
* @return {@code true} if either an {@code IOException} has been thrown
* previously or if {@code setError()} has been called;
* {@code false} otherwise.
* @see #setError()
*/
public boolean checkError() {
flush();
synchronized (lock) {
return mIoError;
}
}
/**
* Sets the error state of the stream to false.
* @since 1.6
*/
protected void clearError() {
synchronized (lock) {
mIoError = false;
}
}
/**
* Sets the error flag of this writer to true.
*/
protected void setError() {
synchronized (lock) {
mIoError = true;
}
}
private final void initDefaultEncoder() {
mCharset = Charset.defaultCharset().newEncoder();
mCharset.onMalformedInput(CodingErrorAction.REPLACE);
mCharset.onUnmappableCharacter(CodingErrorAction.REPLACE);
}
private void appendLocked(char c) throws IOException {
int pos = mPos;
if (pos >= (mBufferLen-1)) {
flushLocked();
pos = mPos;
}
mText[pos] = c;
mPos = pos+1;
}
private void appendLocked(String str, int i, final int length) throws IOException {
final int BUFFER_LEN = mBufferLen;
if (length > BUFFER_LEN) {
final int end = i + length;
while (i < end) {
int next = i + BUFFER_LEN;
appendLocked(str, i, next < end ? BUFFER_LEN : (end - i));
i = next;
}
return;
}
int pos = mPos;
if ((pos+length) > BUFFER_LEN) {
flushLocked();
pos = mPos;
}
str.getChars(i, i + length, mText, pos);
mPos = pos + length;
}
private void appendLocked(char[] buf, int i, final int length) throws IOException {
final int BUFFER_LEN = mBufferLen;
if (length > BUFFER_LEN) {
final int end = i + length;
while (i < end) {
int next = i + BUFFER_LEN;
appendLocked(buf, i, next < end ? BUFFER_LEN : (end - i));
i = next;
}
return;
}
int pos = mPos;
if ((pos+length) > BUFFER_LEN) {
flushLocked();
pos = mPos;
}
System.arraycopy(buf, i, mText, pos, length);
mPos = pos + length;
}
private void flushBytesLocked() throws IOException {
int position;
if ((position = mBytes.position()) > 0) {
mBytes.flip();
mOutputStream.write(mBytes.array(), 0, position);
mBytes.clear();
}
}
private void flushLocked() throws IOException {
//Log.i("PackageManager", "flush mPos=" + mPos);
if (mPos > 0) {
if (mOutputStream != null) {
CharBuffer charBuffer = CharBuffer.wrap(mText, 0, mPos);
CoderResult result = mCharset.encode(charBuffer, mBytes, true);
while (true) {
if (result.isError()) {
throw new IOException(result.toString());
} else if (result.isOverflow()) {
flushBytesLocked();
result = mCharset.encode(charBuffer, mBytes, true);
continue;
}
break;
}
flushBytesLocked();
mOutputStream.flush();
} else if (mWriter != null) {
mWriter.write(mText, 0, mPos);
mWriter.flush();
} else {
int nonEolOff = 0;
final int sepLen = mSeparator.length();
final int len = sepLen < mPos ? sepLen : mPos;
while (nonEolOff < len && mText[mPos-1-nonEolOff]
== mSeparator.charAt(mSeparator.length()-1-nonEolOff)) {
nonEolOff++;
}
if (nonEolOff >= mPos) {
mPrinter.println("");
} else {
mPrinter.println(new String(mText, 0, mPos-nonEolOff));
}
}
mPos = 0;
}
}
/**
* Ensures that all pending data is sent out to the target. It also
* flushes the target. If an I/O error occurs, this writer's error
* state is set to {@code true}.
*/
@Override
public void flush() {
synchronized (lock) {
try {
flushLocked();
if (mOutputStream != null) {
mOutputStream.flush();
} else if (mWriter != null) {
mWriter.flush();
}
} catch (IOException e) {
setError();
}
}
}
@Override
public void close() {
synchronized (lock) {
try {
flushLocked();
if (mOutputStream != null) {
mOutputStream.close();
} else if (mWriter != null) {
mWriter.close();
}
} catch (IOException e) {
setError();
}
}
}
/**
* Prints the string representation of the specified character array
* to the target.
*
* @param charArray
* the character array to print to the target.
* @see #print(String)
*/
public void print(char[] charArray) {
synchronized (lock) {
try {
appendLocked(charArray, 0, charArray.length);
} catch (IOException e) {
}
}
}
/**
* Prints the string representation of the specified character to the
* target.
*
* @param ch
* the character to print to the target.
* @see #print(String)
*/
public void print(char ch) {
synchronized (lock) {
try {
appendLocked(ch);
} catch (IOException e) {
}
}
}
/**
* Prints a string to the target. The string is converted to an array of
* bytes using the encoding chosen during the construction of this writer.
* The bytes are then written to the target with {@code write(int)}.
* <p>
* If an I/O error occurs, this writer's error flag is set to {@code true}.
*
* @param str
* the string to print to the target.
* @see #write(int)
*/
public void print(String str) {
if (str == null) {
str = String.valueOf((Object) null);
}
synchronized (lock) {
try {
appendLocked(str, 0, str.length());
} catch (IOException e) {
setError();
}
}
}
@Override
public void print(int inum) {
if (inum == 0) {
print("0");
} else {
super.print(inum);
}
}
@Override
public void print(long lnum) {
if (lnum == 0) {
print("0");
} else {
super.print(lnum);
}
}
/**
* Prints a newline. Flushes this writer if the autoFlush flag is set to {@code true}.
*/
public void println() {
synchronized (lock) {
try {
appendLocked(mSeparator, 0, mSeparator.length());
if (mAutoFlush) {
flushLocked();
}
} catch (IOException e) {
setError();
}
}
}
@Override
public void println(int inum) {
if (inum == 0) {
println("0");
} else {
super.println(inum);
}
}
@Override
public void println(long lnum) {
if (lnum == 0) {
println("0");
} else {
super.println(lnum);
}
}
/**
* Prints the string representation of the character array {@code chars} followed by a newline.
* Flushes this writer if the autoFlush flag is set to {@code true}.
*/
public void println(char[] chars) {
print(chars);
println();
}
/**
* Prints the string representation of the char {@code c} followed by a newline.
* Flushes this writer if the autoFlush flag is set to {@code true}.
*/
public void println(char c) {
print(c);
println();
}
/**
* Writes {@code count} characters from {@code buffer} starting at {@code
* offset} to the target.
* <p>
* This writer's error flag is set to {@code true} if this writer is closed
* or an I/O error occurs.
*
* @param buf
* the buffer to write to the target.
* @param offset
* the index of the first character in {@code buffer} to write.
* @param count
* the number of characters in {@code buffer} to write.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code count < 0}, or if {@code
* offset + count} is greater than the length of {@code buf}.
*/
@Override
public void write(char[] buf, int offset, int count) {
synchronized (lock) {
try {
appendLocked(buf, offset, count);
} catch (IOException e) {
}
}
}
/**
* Writes one character to the target. Only the two least significant bytes
* of the integer {@code oneChar} are written.
* <p>
* This writer's error flag is set to {@code true} if this writer is closed
* or an I/O error occurs.
*
* @param oneChar
* the character to write to the target.
*/
@Override
public void write(int oneChar) {
synchronized (lock) {
try {
appendLocked((char) oneChar);
} catch (IOException e) {
}
}
}
/**
* Writes the characters from the specified string to the target.
*
* @param str
* the non-null string containing the characters to write.
*/
@Override
public void write(String str) {
synchronized (lock) {
try {
appendLocked(str, 0, str.length());
} catch (IOException e) {
}
}
}
/**
* Writes {@code count} characters from {@code str} starting at {@code
* offset} to the target.
*
* @param str
* the non-null string containing the characters to write.
* @param offset
* the index of the first character in {@code str} to write.
* @param count
* the number of characters from {@code str} to write.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code count < 0}, or if {@code
* offset + count} is greater than the length of {@code str}.
*/
@Override
public void write(String str, int offset, int count) {
synchronized (lock) {
try {
appendLocked(str, offset, count);
} catch (IOException e) {
}
}
}
/**
* Appends a subsequence of the character sequence {@code csq} to the
* target. This method works the same way as {@code
* PrintWriter.print(csq.subsequence(start, end).toString())}. If {@code
* csq} is {@code null}, then the specified subsequence of the string "null"
* will be written to the target.
*
* @param csq
* the character sequence appended to the target.
* @param start
* the index of the first char in the character sequence appended
* to the target.
* @param end
* the index of the character following the last character of the
* subsequence appended to the target.
* @return this writer.
* @throws StringIndexOutOfBoundsException
* if {@code start > end}, {@code start < 0}, {@code end < 0} or
* either {@code start} or {@code end} are greater or equal than
* the length of {@code csq}.
*/
@Override
public PrintWriter append(CharSequence csq, int start, int end) {
if (csq == null) {
csq = "null";
}
String output = csq.subSequence(start, end).toString();
write(output, 0, output.length());
return this;
}
}
|
