Code example for SessionInputBuffer

Methods: read, readLine

0
            nextChunk(); 
            if (this.eof) {
                return -1; 
            } 
        } 
        final int b = in.read();
        if (b != -1) {
            pos++;
            if (pos >= chunkSize) {
                state = CHUNK_CRLF;
            } 
        } 
        return b;
    } 
 
    /** 
     * Read some bytes from the stream. 
     * @param b The byte array that will hold the contents from the stream. 
     * @param off The offset into the byte array at which bytes will start to be 
     * placed. 
     * @param len the maximum number of bytes that can be returned. 
     * @return The number of bytes returned or -1 if the end of stream has been 
     * reached. 
     * @throws IOException in case of an I/O error 
     */ 
    @Override 
    public int read (final byte[] b, final int off, final int len) throws IOException {
 
        if (closed) {
            throw new IOException("Attempted read from closed stream.");
        } 
 
        if (eof) {
            return -1; 
        } 
        if (state != CHUNK_DATA) {
            nextChunk(); 
            if (eof) {
                return -1; 
            } 
        } 
        final int bytesRead = in.read(b, off, Math.min(len, chunkSize - pos));
        if (bytesRead != -1) {
            pos += bytesRead;
            if (pos >= chunkSize) {
                state = CHUNK_CRLF;
            } 
            return bytesRead;
        } else { 
            eof = true;
            throw new TruncatedChunkException("Truncated chunk " 
                    + "( expected size: " + chunkSize
                    + "; actual size: " + pos + ")");
        } 
    } 
 
    /** 
     * Read some bytes from the stream. 
     * @param b The byte array that will hold the contents from the stream. 
     * @return The number of bytes returned or -1 if the end of stream has been 
     * reached. 
     * @throws IOException in case of an I/O error 
     */ 
    @Override 
    public int read (final byte[] b) throws IOException {
        return read(b, 0, b.length);
    } 
 
    /** 
     * Read the next chunk. 
     * @throws IOException in case of an I/O error 
     */ 
    private void nextChunk() throws IOException { 
        chunkSize = getChunkSize();
        if (chunkSize < 0) {
            throw new MalformedChunkCodingException("Negative chunk size");
        } 
        state = CHUNK_DATA;
        pos = 0;
        if (chunkSize == 0) {
            eof = true;
            parseTrailerHeaders(); 
        } 
    } 
 
    /** 
     * Expects the stream to start with a chunksize in hex with optional 
     * comments after a semicolon. The line must end with a CRLF: "a3; some 
     * comment\r\n" Positions the stream at the start of the next line. 
     */ 
    private int getChunkSize() throws IOException { 
        final int st = this.state;
        switch (st) {
        case CHUNK_CRLF:
            this.buffer.clear();
            final int bytesRead1 = this.in.readLine(this.buffer);
            if (bytesRead1 == -1) {
                return 0; 
            } 
            if (!this.buffer.isEmpty()) {
                throw new MalformedChunkCodingException(
                    "Unexpected content at the end of chunk"); 
            } 
            state = CHUNK_LEN;
            //$FALL-THROUGH$ 
        case CHUNK_LEN:
            this.buffer.clear();
            final int bytesRead2 = this.in.readLine(this.buffer);
            if (bytesRead2 == -1) {
                return 0; 
            } 
            int separator = this.buffer.indexOf(';');
            if (separator < 0) {