javolution.io.UTF8StreamWriter Class Reference

Inheritance diagram for javolution.io.UTF8StreamWriter:

Collaboration diagram for javolution.io.UTF8StreamWriter:

Public Member Functions
	UTF8StreamWriter ()
	UTF8StreamWriter (int capacity)
UTF8StreamWriter	setOutput (OutputStream out)
void	write (char c) throws IOException
void	write (int code) throws IOException
void	write (char cbuf[], int off, int len) throws IOException
void	write (String str, int off, int len) throws IOException
void	write (CharSequence csq) throws IOException
void	flush () throws IOException
void	close () throws IOException
void	reset ()
UTF8StreamWriter	setOutputStream (OutputStream out)

Private Member Functions
void	write2 (int c) throws IOException
void	flushBuffer () throws IOException

Private Attributes
OutputStream	_outputStream
final byte[]	_bytes
int	_index
char	_highSurrogate

Detailed Description

A UTF-8 stream writer.

This writer supports surrogate char pairs (representing characters in the range [U+10000 .. U+10FFFF]). It can also be used to write characters from their unicodes (31 bits) directly (ref. write(int)).

Instances of this class can be reused for different output streams and can be part of a higher level component (e.g. serializer) in order to avoid dynamic buffer allocation when the destination output changes. Also wrapping using a java.io.BufferedWriter is unnescessary as instances of this class embed their own data buffers.

Note: This writer is unsynchronized and always produces well-formed UTF-8 sequences.

Author

Jean-Marie Dautelle

Version

2.0, December 9, 2004

Definition at line 36 of file UTF8StreamWriter.java.

Constructor & Destructor Documentation

UTF8StreamWriter() [1/2]

javolution.io.UTF8StreamWriter.UTF8StreamWriter

(

)

Creates a UTF-8 writer having a byte buffer of moderate capacity (2048).

Definition at line 56 of file UTF8StreamWriter.java.

                              {
        _bytes = new byte[2048];
    }

References javolution.io.UTF8StreamWriter._bytes.

UTF8StreamWriter() [2/2]

javolution.io.UTF8StreamWriter.UTF8StreamWriter

(

int

capacity

)

Creates a UTF-8 writer having a byte buffer of specified capacity.

Parameters

capacity

the capacity of the byte buffer.

Definition at line 65 of file UTF8StreamWriter.java.

                                          {
        _bytes = new byte[capacity];
    }

References javolution.io.UTF8StreamWriter._bytes.

Member Function Documentation

close()

void javolution.io.UTF8StreamWriter.close

(

)

throws IOException

Closes and resets this writer for reuse.

Exceptions

IOException

if an I/O error occurs

Definition at line 306 of file UTF8StreamWriter.java.

                                           {
        if (_outputStream != null) {
            flushBuffer();
            _outputStream.close();
            reset();
        }
    }

References javolution.io.UTF8StreamWriter._outputStream, javolution.io.UTF8StreamWriter.flushBuffer(), and javolution.io.UTF8StreamWriter.reset().

Referenced by javolution.xml.ws.WebServiceClient.invoke().

Here is the call graph for this function:

Here is the caller graph for this function:

flush()

void javolution.io.UTF8StreamWriter.flush

(

)

throws IOException

Flushes 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.

Exceptions

IOException

if an I/O error occurs.

Definition at line 296 of file UTF8StreamWriter.java.

                                           {
        flushBuffer();
        _outputStream.flush();
    }

References javolution.io.UTF8StreamWriter._outputStream, and javolution.io.UTF8StreamWriter.flushBuffer().

Here is the call graph for this function:

flushBuffer()

void javolution.io.UTF8StreamWriter.flushBuffer ( ) throws IOException

private

Flushes the internal bytes buffer.

Exceptions

IOException

if an I/O error occurs

Definition at line 319 of file UTF8StreamWriter.java.

                                                  {
        if (_outputStream == null)
            throw new IOException("Stream closed");
        _outputStream.write(_bytes, 0, _index);
        _index = 0;
    }

References javolution.io.UTF8StreamWriter._bytes, javolution.io.UTF8StreamWriter._index, and javolution.io.UTF8StreamWriter._outputStream.

Referenced by javolution.io.UTF8StreamWriter.close(), javolution.io.UTF8StreamWriter.flush(), javolution.io.UTF8StreamWriter.write(), and javolution.io.UTF8StreamWriter.write2().

Here is the caller graph for this function:

reset()

void javolution.io.UTF8StreamWriter.reset

(

)

Definition at line 326 of file UTF8StreamWriter.java.

                        {
        _highSurrogate = 0;
        _index = 0;
        _outputStream = null;
    }

References javolution.io.UTF8StreamWriter._highSurrogate, javolution.io.UTF8StreamWriter._index, and javolution.io.UTF8StreamWriter._outputStream.

Referenced by javolution.io.UTF8StreamWriter.close(), javolution.xml.ws.WebServiceClient.invoke(), and javolution.xml.internal.stream.XMLStreamWriterImpl.reset().

Here is the caller graph for this function:

setOutput()

UTF8StreamWriter javolution.io.UTF8StreamWriter.setOutput

(

OutputStream

out

)

Sets the output stream to use for writing until this writer is closed. For example:[code] Writer writer = new UTF8StreamWriter().setOutputStream(out); [/code] is equivalent but writes faster than [code] Writer writer = new java.io.OutputStreamWriter(out, "UTF-8"); [/code]

Parameters

out	the output stream.

Returns

this UTF-8 writer.

Exceptions

IllegalStateException

if this writer is being reused and it has not been closed or reset.

Definition at line 82 of file UTF8StreamWriter.java.

                                                        {
        if (_outputStream != null)
            throw new IllegalStateException("Writer not closed or reset");
        _outputStream = out;
        return this;
    }

References javolution.io.UTF8StreamWriter._outputStream.

Referenced by javolution.xml.ws.WebServiceClient.invoke(), javolution.xml.internal.stream.XMLStreamWriterImpl.setOutput(), and javolution.io.UTF8StreamWriter.setOutputStream().

Here is the caller graph for this function:

setOutputStream()

UTF8StreamWriter javolution.io.UTF8StreamWriter.setOutputStream

(

OutputStream

out

)

Deprecated:

Replaced by setOutput(OutputStream)

Definition at line 335 of file UTF8StreamWriter.java.

                                                              {
        return this.setOutput(out);
    }

References javolution.io.UTF8StreamWriter.setOutput().

Here is the call graph for this function:

write() [1/5]

void javolution.io.UTF8StreamWriter.write

(

char

c

)

throws IOException

Writes a single character. This method supports 16-bits character surrogates.

Parameters

c	char the character to be written (possibly a surrogate).

Exceptions

IOException

if an I/O error occurs.

Definition at line 97 of file UTF8StreamWriter.java.

                                                 {
        if ((c < 0xd800) || (c > 0xdfff)) {
            write((int) c);
        } else if (c < 0xdc00) { // High surrogate.
            _highSurrogate = c;
        } else { // Low surrogate.
            int code = ((_highSurrogate - 0xd800) << 10) + (c - 0xdc00)
                    + 0x10000;
            write(code);
        }
    }

References javolution.io.UTF8StreamWriter._highSurrogate.

Referenced by javolution.io.UTF8StreamWriter.write().

Here is the caller graph for this function:

write() [2/5]

void javolution.io.UTF8StreamWriter.write	(	char	cbuf[],
		int	off,
		int	len
	)		throws IOException

Writes a portion of an array of characters.

Parameters

cbuf	the array of characters.
off	the offset from which to start writing characters.
len	the number of characters to write.

Exceptions

IOException

if an I/O error occurs.

Definition at line 228 of file UTF8StreamWriter.java.

                                                                        {
        final int off_plus_len = off + len;
        for (int i = off; i < off_plus_len;) {
            char c = cbuf[i++];
            if (c < 0x80) {
                _bytes[_index] = (byte) c;
                if (++_index >= _bytes.length) {
                    flushBuffer();
                }
            } else {
                write(c);
            }
        }
    }

References javolution.io.UTF8StreamWriter._bytes, javolution.io.UTF8StreamWriter._index, javolution.io.UTF8StreamWriter.flushBuffer(), and javolution.io.UTF8StreamWriter.write().

Here is the call graph for this function:

write() [3/5]

void javolution.io.UTF8StreamWriter.write

(

CharSequence

csq

)

throws IOException

Writes the specified character sequence.

Parameters

csq	the character sequence.

Exceptions

IOException

if an I/O error occurs

Definition at line 272 of file UTF8StreamWriter.java.

                                                           {
        final int length = csq.length();
        for (int i = 0; i < length;) {
            char c = csq.charAt(i++);
            if (c < 0x80) {
                _bytes[_index] = (byte) c;
                if (++_index >= _bytes.length) {
                    flushBuffer();
                }
            } else {
                write(c);
            }
        }
    }

References javolution.io.UTF8StreamWriter._bytes, javolution.io.UTF8StreamWriter._index, javolution.io.UTF8StreamWriter.flushBuffer(), and javolution.io.UTF8StreamWriter.write().

Here is the call graph for this function:

write() [4/5]

void javolution.io.UTF8StreamWriter.write

(

int

code

)

throws IOException

Writes a character given its 31-bits Unicode.

Parameters

code	the 31 bits Unicode of the character to be written.

Exceptions

IOException

if an I/O error occurs.

Definition at line 117 of file UTF8StreamWriter.java.

                                                   {
        if ((code & 0xffffff80) == 0) {
            _bytes[_index] = (byte) code;
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
        } else { // Writes more than one byte.
            write2(code);
        }
    }

References javolution.io.UTF8StreamWriter._bytes, javolution.io.UTF8StreamWriter._index, javolution.io.UTF8StreamWriter.flushBuffer(), and javolution.io.UTF8StreamWriter.write2().

Here is the call graph for this function:

write() [5/5]

void javolution.io.UTF8StreamWriter.write	(	String	str,
		int	off,
		int	len
	)		throws IOException

Writes a portion of a string.

Parameters

str	a String.
off	the offset from which to start writing characters.
len	the number of characters to write.

Exceptions

IOException

if an I/O error occurs

Definition at line 251 of file UTF8StreamWriter.java.

                                                                       {
        final int off_plus_len = off + len;
        for (int i = off; i < off_plus_len;) {
            char c = str.charAt(i++);
            if (c < 0x80) {
                _bytes[_index] = (byte) c;
                if (++_index >= _bytes.length) {
                    flushBuffer();
                }
            } else {
                write(c);
            }
        }
    }

References javolution.io.UTF8StreamWriter._bytes, javolution.io.UTF8StreamWriter._index, javolution.io.UTF8StreamWriter.flushBuffer(), and javolution.io.UTF8StreamWriter.write().

Here is the call graph for this function:

write2()

void javolution.io.UTF8StreamWriter.write2 ( int  c ) throws IOException

private

Definition at line 128 of file UTF8StreamWriter.java.

                                                  {
        if ((c & 0xfffff800) == 0) { // 2 bytes.
            _bytes[_index] = (byte) (0xc0 | (c >> 6));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | (c & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
        } else if ((c & 0xffff0000) == 0) { // 3 bytes.
            _bytes[_index] = (byte) (0xe0 | (c >> 12));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 6) & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | (c & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
        } else if ((c & 0xff200000) == 0) { // 4 bytes.
            _bytes[_index] = (byte) (0xf0 | (c >> 18));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 12) & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 6) & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | (c & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
        } else if ((c & 0xf4000000) == 0) { // 5 bytes.
            _bytes[_index] = (byte) (0xf8 | (c >> 24));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 18) & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 12) & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 6) & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | (c & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
        } else if ((c & 0x80000000) == 0) { // 6 bytes.
            _bytes[_index] = (byte) (0xfc | (c >> 30));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 24) & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 18) & 0x3f));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 12) & 0x3F));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | ((c >> 6) & 0x3F));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
            _bytes[_index] = (byte) (0x80 | (c & 0x3F));
            if (++_index >= _bytes.length) {
                flushBuffer();
            }
        } else {
            throw new CharConversionException("Illegal character U+"
                    + Integer.toHexString(c));
        }
    }

References javolution.io.UTF8StreamWriter._bytes, javolution.io.UTF8StreamWriter._index, and javolution.io.UTF8StreamWriter.flushBuffer().

Referenced by javolution.io.UTF8StreamWriter.write().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_bytes

final byte [] javolution.io.UTF8StreamWriter._bytes

private

Holds the bytes' buffer.

Definition at line 46 of file UTF8StreamWriter.java.

Referenced by javolution.io.UTF8StreamWriter.flushBuffer(), javolution.io.UTF8StreamWriter.UTF8StreamWriter(), javolution.io.UTF8StreamWriter.write(), and javolution.io.UTF8StreamWriter.write2().

_highSurrogate

char javolution.io.UTF8StreamWriter._highSurrogate

private

Definition at line 109 of file UTF8StreamWriter.java.

Referenced by javolution.io.UTF8StreamWriter.reset(), and javolution.io.UTF8StreamWriter.write().

_index

int javolution.io.UTF8StreamWriter._index

private

Holds the bytes buffer index.

Definition at line 51 of file UTF8StreamWriter.java.

Referenced by javolution.io.UTF8StreamWriter.flushBuffer(), javolution.io.UTF8StreamWriter.reset(), javolution.io.UTF8StreamWriter.write(), and javolution.io.UTF8StreamWriter.write2().

_outputStream

OutputStream javolution.io.UTF8StreamWriter._outputStream

private

Holds the current output stream or null if closed.

Definition at line 41 of file UTF8StreamWriter.java.

Referenced by javolution.io.UTF8StreamWriter.close(), javolution.io.UTF8StreamWriter.flush(), javolution.io.UTF8StreamWriter.flushBuffer(), javolution.io.UTF8StreamWriter.reset(), and javolution.io.UTF8StreamWriter.setOutput().

---

The documentation for this class was generated from the following file:

• UTF8StreamWriter.java