WriterToUTF8Bufferedpublic final class WriterToUTF8Buffered extends Writer | This class writes unicode characters to a byte stream (java.io.OutputStream)
as quickly as possible. It buffers the output in an internal
buffer which must be flushed to the OutputStream when done. This flushing
is done via the close() flush() or flushBuffer() method. |
| Fields Summary |
|---|
| private static final int | BYTES_MAXnumber of bytes that the byte buffer can hold.
This is a fixed constant is used rather than m_outputBytes.lenght for performance. | | private static final int | CHARS_MAXnumber of characters that the character buffer can hold.
This is 1/3 of the number of bytes because UTF-8 encoding
can expand one unicode character by up to 3 bytes. | | private final OutputStream | m_osThe byte stream to write to. (sc & sb remove final to compile in JDK 1.1.8) | | private final byte[] | m_outputBytesThe internal buffer where data is stored.
(sc & sb remove final to compile in JDK 1.1.8) | | private final char[] | m_inputChars | | private int | countThe number of valid bytes in the buffer. This value is always
in the range 0 through m_outputBytes.length; elements
m_outputBytes[0] through m_outputBytes[count-1] contain valid
byte data. |
| Constructors Summary |
|---|
public WriterToUTF8Buffered(OutputStream out)Create an buffered UTF-8 writer.
m_os = out;
// get 3 extra bytes to make buffer overflow checking simpler and faster
// we won't have to keep checking for a few extra characters
m_outputBytes = new byte[BYTES_MAX + 3];
// Big enough to hold the input chars that will be transformed
// into output bytes in m_ouputBytes.
m_inputChars = new char[CHARS_MAX + 1];
count = 0;
// the old body of this constructor, before the buffersize was changed to a constant
// this(out, 8*1024);
|
| Methods Summary |
|---|
| public void | close()Close the stream, flushing it first. Once a stream has been closed,
further write() or flush() invocations will cause an IOException to be
thrown. Closing a previously-closed stream, however, has no effect.
flushBuffer();
m_os.close();
| | public void | directWrite(java.lang.String s)
final int length = s.length();
if (length >= BYTES_MAX - count)
{
// The requested length is greater than the unused part of the buffer
flushBuffer();
if (length >= BYTES_MAX)
{
/*
* The requested length exceeds the size of the buffer,
* so don't bother to buffer this one, just write it out
* directly. The buffer is already flushed so this is a
* safe thing to do.
*/
final int start = 0;
int chunks = 1 + length/CHARS_MAX;
for (int chunk =0 ; chunk < chunks; chunk++)
{
int start_chunk = start + ((length*chunk)/chunks);
int end_chunk = start + ((length*(chunk+1))/chunks);
int len_chunk = (end_chunk - start_chunk);
s.getChars(start_chunk,end_chunk, m_inputChars,0);
this.directWrite(m_inputChars,0, len_chunk);
}
return;
}
}
s.getChars(0, length , m_inputChars, 0);
final char[] chars = m_inputChars;
final byte[] buf_loc = m_outputBytes; // local reference for faster access
int count_loc = count; // local integer for faster access
int i = 0;
while( i < length)
buf_loc[count_loc++] = (byte)chars[i++];
// Store the local integer back into the instance variable
count = count_loc;
| | private void | directWrite(char[] chars, int start, int length)Writes out the character array
if (length >= BYTES_MAX - count)
{
// The requested length is greater than the unused part of the buffer
flushBuffer();
if (length >= BYTES_MAX)
{
/*
* The requested length exceeds the size of the buffer.
* Cut the buffer up into chunks, each of which will
* not cause an overflow to the output buffer m_outputBytes,
* and make multiple recursive calls.
*/
int chunks = 1 + length/CHARS_MAX;
for (int chunk =0 ; chunk < chunks; chunk++)
{
int start_chunk = start + ((length*chunk)/chunks);
int end_chunk = start + ((length*(chunk+1))/chunks);
int len_chunk = (end_chunk - start_chunk);
this.directWrite(chars,start_chunk, len_chunk);
}
return;
}
}
final int n = length+start;
final byte[] buf_loc = m_outputBytes; // local reference for faster access
int count_loc = count; // local integer for faster access
for(int i=start; i < n ; i++ )
buf_loc[count_loc++] = (byte) buf_loc[i];
// Store the local integer back into the instance variable
count = count_loc;
| | public void | flush()Flush the stream. If the stream has saved any characters from the
various write() methods in a buffer, write them immediately to their
intended destination. Then, if that destination is another character or
byte stream, flush it. Thus one flush() invocation will flush all the
buffers in a chain of Writers and OutputStreams.
flushBuffer();
m_os.flush();
| | public void | flushBuffer()Flush the internal buffer
if (count > 0)
{
m_os.write(m_outputBytes, 0, count);
count = 0;
}
| | public java.io.OutputStream | getOutputStream()Get the output stream where the events will be serialized to.
return m_os;
| | public void | write(int c)Write a single character. The character to be written is contained in
the 16 low-order bits of the given integer value; the 16 high-order bits
are ignored.
Subclasses that intend to support efficient single-character output
should override this method.
/* If we are close to the end of the buffer then flush it.
* Remember the buffer can hold a few more bytes than BYTES_MAX
*/
if (count >= BYTES_MAX)
flushBuffer();
if (c < 0x80)
{
m_outputBytes[count++] = (byte) (c);
}
else if (c < 0x800)
{
m_outputBytes[count++] = (byte) (0xc0 + (c >> 6));
m_outputBytes[count++] = (byte) (0x80 + (c & 0x3f));
}
else
{
m_outputBytes[count++] = (byte) (0xe0 + (c >> 12));
m_outputBytes[count++] = (byte) (0x80 + ((c >> 6) & 0x3f));
m_outputBytes[count++] = (byte) (0x80 + (c & 0x3f));
}
| | public void | write(char[] chars, int start, int length)Write a portion of an array of characters.
// We multiply the length by three since this is the maximum length
// of the characters that we can put into the buffer. It is possible
// for each Unicode character to expand to three bytes.
int lengthx3 = 3*length;
if (lengthx3 >= BYTES_MAX - count)
{
// The requested length is greater than the unused part of the buffer
flushBuffer();
if (lengthx3 >= BYTES_MAX)
{
/*
* The requested length exceeds the size of the buffer.
* Cut the buffer up into chunks, each of which will
* not cause an overflow to the output buffer m_outputBytes,
* and make multiple recursive calls.
* Be careful about integer overflows in multiplication.
*/
final int chunks = 1 + length/CHARS_MAX;
int end_chunk = start;
for (int chunk = 1; chunk <= chunks; chunk++)
{
int start_chunk = end_chunk;
end_chunk = start + (int) ((((long) length) * chunk) / chunks);
int len_chunk = (end_chunk - start_chunk);
this.write(chars,start_chunk, len_chunk);
}
return;
}
}
final int n = length+start;
final byte[] buf_loc = m_outputBytes; // local reference for faster access
int count_loc = count; // local integer for faster access
int i = start;
{
/* This block could be omitted and the code would produce
* the same result. But this block exists to give the JIT
* a better chance of optimizing a tight and common loop which
* occurs when writing out ASCII characters.
*/
char c;
for(; i < n && (c = chars[i])< 0x80 ; i++ )
buf_loc[count_loc++] = (byte)c;
}
for (; i < n; i++)
{
final char c = chars[i];
if (c < 0x80)
buf_loc[count_loc++] = (byte) (c);
else if (c < 0x800)
{
buf_loc[count_loc++] = (byte) (0xc0 + (c >> 6));
buf_loc[count_loc++] = (byte) (0x80 + (c & 0x3f));
}
else
{
buf_loc[count_loc++] = (byte) (0xe0 + (c >> 12));
buf_loc[count_loc++] = (byte) (0x80 + ((c >> 6) & 0x3f));
buf_loc[count_loc++] = (byte) (0x80 + (c & 0x3f));
}
}
// Store the local integer back into the instance variable
count = count_loc;
| | public void | write(java.lang.String s)Write a string.
// We multiply the length by three since this is the maximum length
// of the characters that we can put into the buffer. It is possible
// for each Unicode character to expand to three bytes.
final int length = s.length();
int lengthx3 = 3*length;
if (lengthx3 >= BYTES_MAX - count)
{
// The requested length is greater than the unused part of the buffer
flushBuffer();
if (lengthx3 >= BYTES_MAX)
{
/*
* The requested length exceeds the size of the buffer,
* so break it up in chunks that don't exceed the buffer size.
*/
final int start = 0;
int chunks = 1 + length/CHARS_MAX;
for (int chunk =0 ; chunk < chunks; chunk++)
{
int start_chunk = start + ((length*chunk)/chunks);
int end_chunk = start + ((length*(chunk+1))/chunks);
int len_chunk = (end_chunk - start_chunk);
s.getChars(start_chunk,end_chunk, m_inputChars,0);
this.write(m_inputChars,0, len_chunk);
}
return;
}
}
s.getChars(0, length , m_inputChars, 0);
final char[] chars = m_inputChars;
final int n = length;
final byte[] buf_loc = m_outputBytes; // local reference for faster access
int count_loc = count; // local integer for faster access
int i = 0;
{
/* This block could be omitted and the code would produce
* the same result. But this block exists to give the JIT
* a better chance of optimizing a tight and common loop which
* occurs when writing out ASCII characters.
*/
char c;
for(; i < n && (c = chars[i])< 0x80 ; i++ )
buf_loc[count_loc++] = (byte)c;
}
for (; i < n; i++)
{
final char c = chars[i];
if (c < 0x80)
buf_loc[count_loc++] = (byte) (c);
else if (c < 0x800)
{
buf_loc[count_loc++] = (byte) (0xc0 + (c >> 6));
buf_loc[count_loc++] = (byte) (0x80 + (c & 0x3f));
}
else
{
buf_loc[count_loc++] = (byte) (0xe0 + (c >> 12));
buf_loc[count_loc++] = (byte) (0x80 + ((c >> 6) & 0x3f));
buf_loc[count_loc++] = (byte) (0x80 + (c & 0x3f));
}
}
// Store the local integer back into the instance variable
count = count_loc;
|
|
