Quadcap Embeddable Server

com/quadcap/io/DotStuffInputStream.java

Go to the documentation of this file.

package com.quadcap.io;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.*;

import com.quadcap.util.Debug;
import com.quadcap.util.Util;

/**
 * A filter input stream that performs dot-unstuffing.
 *
 * @author Stan Bailes
 */

public class DotStuffInputStream extends InputStream {
    InputStream         in;
    
    static final byte   CR      = (byte)'\r';
    static final byte   LF      = (byte)'\n';
    static final byte   DT      = (byte)'.';

    static final int    INIT    = 0;
    static final int    END     = 1;
    static final int    S1      = 2;
    static final int    S2      = 3;
    static final int    S3      = 4;
    static final int    S4      = 5;

    int state                   = INIT;
    int savec                   = -1;

    public DotStuffInputStream(InputStream in) throws IOException {
        this.in = in;
    }

    /**
     * Reads the next byte of data from this input stream. The value 
     * byte is returned as an <code>int</code> in the range 
     * <code>0</code> to <code>255</code>. If no byte is available 
     * because the end of the stream has been reached, the value 
     * <code>-1</code> is returned. This method blocks until input data 
     * is available, the end of the stream is detected, or an exception 
     * is thrown. 
     * <p>
     * The <code>read</code> method of <code>DotStuffInputStream</code>
     * returns -1 when the characteristic 'single dot on a line by itself'
     * end signature, and removes all leading dots otherwise.
     *
     * @return     the next byte of data, or <code>-1</code> if the end of the
     *             stream is reached.
     * @exception  IOException  if an I/O error occurs.
     */
    public int read() throws IOException {
        int c = savec;
        if (savec >= 0) {
            savec = -1;
            return c;
        }

        while (state != END) {
            c = in.read();
            switch (state) {
            case INIT:          // at beginning of line
                switch (c) {
                case DT: state = S1; break;
                case CR: state = S3; return CR;
                case LF: return LF;  // state still INIT
                default: state = S4; return c;
                }
                break;
            case S1:            // seen leading DT
                switch (c) {
                case LF: state = END; break;
                case CR: state = S2; break;
                default: state = S4; return c;
                }
                break;
            case S2:            // seen DT, CR.  Better have LF next.
                switch (c) {
                case LF: state = END; break;
                case CR: state = S3; return CR;
                default: state = S4; return c;
                }
                break;
            case S3:            // seen CR
                state = (c == LF) ? INIT : S4;
                return c;
            case S4:            // just chugging along
                switch (c) {
                case CR: state = S3; return CR;
                case LF: state = INIT; return LF;
                default: return c;
                }
            }
        }
        return -1;
    }

    /**
     * Reads up to <code>len</code> bytes of data from this input stream 
     * into an array of bytes. This method blocks until some input is 
     * available. 
     * 
     * @param      b     the buffer into which the data is read.
     * @param      off   the start offset of the data.
     * @param      len   the maximum number of bytes read.
     * @return     the total number of bytes read into the buffer, or
     *             <code>-1</code> if there is no more data because the end of
     *             the stream has been reached.
     * @exception  IOException  if an I/O error occurs.
     */
    public int read(byte b[], int off, int len) throws IOException {
        int cnt = 0;
        int c;
        while (cnt < len && (c = read()) >= 0) {
            b[off + cnt++] = (byte)c;
        }
        return cnt;
    }

    /**
     * Skips over and discards <code>n</code> bytes of data from the 
     * input stream. The <code>skip</code> method may, for a variety of 
     * reasons, end up skipping over some smaller number of bytes, 
     * possibly <code>0</code>. The actual number of bytes skipped is 
     * returned. 
     *
     * @param      n   the number of bytes to be skipped.
     * @return     the actual number of bytes skipped.
     * @exception  IOException  if an I/O error occurs.
     */
    public long skip(long n) throws IOException {
        int cnt = 0;
        while (cnt < n && read() >= 0) cnt++;
        return cnt;
    }

    
}