UTF8StreamReader.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.io;
 
import java.io.CharConversionException;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
 
public final class UTF8StreamReader extends Reader {
 
    private InputStream _inputStream;
 
    private int _start;
 
    private int _end;
 
    private final byte[] _bytes;
 
    public UTF8StreamReader() {
        _bytes = new byte[2048];
    }
 
    public UTF8StreamReader(int capacity) {
        _bytes = new byte[capacity];
    }
 
    public UTF8StreamReader setInput(InputStream inStream) {
        if (_inputStream != null)
            throw new IllegalStateException("Reader not closed or reset");
        _inputStream = inStream;
        return this;
    }
 
    public boolean ready() throws IOException {
        if (_inputStream == null)
            throw new IOException("Stream closed");
        return ((_end - _start) > 0) || (_inputStream.available() != 0);
    }
 
    public void close() throws IOException {
        if (_inputStream != null) {
            _inputStream.close();
            reset();
        }
    }
 
    public int read() throws IOException {
        byte b = _bytes[_start];
        return ((b >= 0) && (_start++ < _end)) ? b : read2();
    }
 
    // Reads one full character, blocks if necessary.
    private int read2() throws IOException {
        if (_start < _end) {
            byte b = _bytes[_start++];
 
            // Decodes UTF-8.
            if ((b >= 0) && (_moreBytes == 0)) {
                // 0xxxxxxx
                return b;
            } else if (((b & 0xc0) == 0x80) && (_moreBytes != 0)) {
                // 10xxxxxx (continuation byte)
                _code = (_code << 6) | (b & 0x3f); // Adds 6 bits to code.
                if (--_moreBytes == 0) {
                    return _code;
                } else {
                    return read2();
                }
            } else if (((b & 0xe0) == 0xc0) && (_moreBytes == 0)) {
                // 110xxxxx
                _code = b & 0x1f;
                _moreBytes = 1;
                return read2();
            } else if (((b & 0xf0) == 0xe0) && (_moreBytes == 0)) {
                // 1110xxxx
                _code = b & 0x0f;
                _moreBytes = 2;
                return read2();
            } else if (((b & 0xf8) == 0xf0) && (_moreBytes == 0)) {
                // 11110xxx
                _code = b & 0x07;
                _moreBytes = 3;
                return read2();
            } else if (((b & 0xfc) == 0xf8) && (_moreBytes == 0)) {
                // 111110xx
                _code = b & 0x03;
                _moreBytes = 4;
                return read2();
            } else if (((b & 0xfe) == 0xfc) && (_moreBytes == 0)) {
                // 1111110x
                _code = b & 0x01;
                _moreBytes = 5;
                return read2();
            } else {
                throw new CharConversionException("Invalid UTF-8 Encoding");
            }
        } else { // No more bytes in buffer.
            if (_inputStream == null)
                throw new IOException("No input stream or stream closed");
            _start = 0;
            _end = _inputStream.read(_bytes, 0, _bytes.length);
            if (_end > 0) {
                return read2(); // Continues.
            } else { // Done.
                if (_moreBytes == 0) {
                    return -1;
                } else { // Incomplete sequence.
                    throw new CharConversionException(
                            "Unexpected end of stream");
                }
            }
        }
    }
 
    private int _code;
 
    private int _moreBytes;
 
    public int read(char cbuf[], int off, int len) throws IOException {
        if (_inputStream == null)
            throw new IOException("No input stream or stream closed");
        if (_start >= _end) { // Fills buffer.
            _start = 0;
            _end = _inputStream.read(_bytes, 0, _bytes.length);
            if (_end <= 0) { // Done.
                return _end;
            }
        }
        final int off_plus_len = off + len;
        for (int i = off; i < off_plus_len;) {
            // assert(_start < _end)
            byte b = _bytes[_start];
            if ((b >= 0) && (++_start < _end)) {
                cbuf[i++] = (char) b; // Most common case.
            } else if (b < 0) {
                if (i < off_plus_len - 1) { // Up to two 'char' can be read.
                    int code = read2();
                    if (code < 0x10000) {
                        cbuf[i++] = (char) code;
                    } else if (code <= 0x10ffff) { // Surrogates.
                        cbuf[i++] = (char) (((code - 0x10000) >> 10) + 0xd800);
                        cbuf[i++] = (char) (((code - 0x10000) & 0x3ff) + 0xdc00);
                    } else {
                        throw new CharConversionException("Cannot convert U+"
                                + Integer.toHexString(code)
                                + " to char (code greater than U+10FFFF)");
                    }
                    if (_start < _end) {
                        continue;
                    }
                }
                return i - off;
            } else { // End of buffer (_start >= _end).
                cbuf[i++] = (char) b;
                return i - off;
            }
        }
        return len;
    }
 
    public void read(Appendable dest) throws IOException {
        if (_inputStream == null)
            throw new IOException("No input stream or stream closed");
        while (true) {
            if (_start >= _end) { // Fills buffer.
                _start = 0;
                _end = _inputStream.read(_bytes, 0, _bytes.length);
                if (_end <= 0) { // Done.
                    break;
                }
            }
            byte b = _bytes[_start];
            if (b >= 0) {
                dest.append((char) b); // Most common case.
                _start++;
            } else {
                int code = read2();
                if (code < 0x10000) {
                    dest.append((char) code);
                } else if (code <= 0x10ffff) { // Surrogates.
                    dest.append((char) (((code - 0x10000) >> 10) + 0xd800));
                    dest.append((char) (((code - 0x10000) & 0x3ff) + 0xdc00));
                } else {
                    throw new CharConversionException("Cannot convert U+"
                            + Integer.toHexString(code)
                            + " to char (code greater than U+10FFFF)");
                }
            }
        }
    }
 
    public void reset() {
        _code = 0;
        _end = 0;
        _inputStream = null;
        _moreBytes = 0;
        _start = 0;
    }
 
    public UTF8StreamReader setInputStream(InputStream inStream) {
        return this.setInput(inStream);
    }
}