Quadcap Embeddable Server

com/quadcap/util/text/Scanner.java

Go to the documentation of this file.

package com.quadcap.util.text;

/* 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.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import com.quadcap.util.Debug;

//#ifdef DEBUG
import java.io.ByteArrayOutputStream;
import com.quadcap.io.LogInputStream;
//#endif

/**
 * The class implements a series of low-level stream scanning operations,
 * using OctetMaps to implement 'while' and 'until'.
 * @author Stan Bailes
 */
public class Scanner {
    InputStream                 is;
    StringBuffer                sb              = new StringBuffer();
    int                         pushback        = -1;

    //#ifdef DEBUG
    LogInputStream              log             = null;
    ByteArrayOutputStream       bos             = null;

    public Scanner(InputStream is, boolean saveit) {
        if (saveit) {
            bos = new ByteArrayOutputStream();
            this.is = new LogInputStream(is, bos, "");
        } else {
            this.is = is;
        }
    }

    public String getLog() { return bos.toString(); }
    //#endif

    /**
     * Construct a new scanner, attached to the specified input stream.
     *
     * @param is the stream to scan.
     */
    public Scanner(InputStream is) {
        this.is = is;
    }

    public void reset(InputStream is) {
        this.is = is;
        //#ifdef DEBUG
        if (bos != null) {
            bos.reset();
            this.is = new LogInputStream(is, bos, "");
        }
        //#endif
        pushback = -1;
    }

    final int read() throws IOException {
        int c = pushback;
        if (c >= 0) {
            pushback = -1;
        } else {
            c = is.read();
        }
        return c;
    }

    final void unread(int c) {
        pushback = c;
    }

    /**
     * Read and discard characters until a character is found which
     * <b>is not</b> in the map.  Then push back the terminating character.
     *
     * @param map the set of characters to skip.
     * @exception IOException if an I/O exception is thrown
     */
    final public void skipWhile(OctetMap map) throws IOException {
        int c;
        while (map.has(c = read()) && c >= 0) continue;
        if (c >= 0) unread(c);
    }

    /**
     * Read and discard characters until a character is found which
     * <b>is</b> in the map.  Then push back the terminating character.
     *
     * @param map the set of characters which skip.
     * @exception IOException if an I/O exception is thrown
     */
    final public void skipUntil(OctetMap map) throws IOException {
        int c;
        while (!map.has(c = read()) && c >= 0) continue;
        if (c >= 0) unread(c);
    }
    
    /**
     * Return the next portion of the stream which consists of characters
     * <b>IN</b> the specified set.
     *
     * @param map the set of characters to parse.
     * @exception IOException if an I/O exception is thrown
     */
    final public String parseWhile(OctetMap map) throws IOException {
        sb.setLength(0);
        int c;
        while (map.has(c = read()) && c >= 0) {
            sb.append((char)c);
        }
        if (c >= 0) unread(c);
        return sb.toString();
    }

    /**
     * Return the next portion of the stream which consists of characters
     * <b>NOT IN</b> the specified set.
     *
     * @param map the set of characters to parse.
     * @exception IOException if an I/O exception is thrown
     */
    final public String parseUntil(OctetMap map) throws IOException {
        sb.setLength(0);
        int c;
        while (!map.has(c = read()) && c >= 0) {
            sb.append((char)c);
        }
        if (c >= 0) unread(c);
        return sb.toString();
    }


    /**
     * Read the next character, and verify that it is equal to the expected
     * value.
     *
     * @param expected the expected character
     * @exception IOException if the character read from the stream is not
     *                  equal to the specified character.
     */
    final public void matchChar(int expected) throws IOException {
        int c = read();
        if (c != expected) {
            if (c < 0x1f || expected < 0x1f) {
                throw new IOException("Expected: " + expected + ", got " + c);
            } else {
                throw new IOException("Expected: " + expected + "(" +
                                      (char)expected + "), got " + c + "(" +
                                      (char)c + ")");
            }
        }
    }

    /**
     * Read the next string using the specified map, and verify that it
     * <b>IS</b> equal to the expected value.
     *
     * @param expected the expected string
     * @exception IOException if the character read from the stream is not
     *                  equal to the specified character.
     */
    final public void matchString(OctetMap map, String expected)
        throws IOException
    {
        String actual = parseWhile(map);
        if (!actual.equals(expected)) {
            throw new IOException("Expected: " + expected +
                                  ", got: " + actual);
        }
    }

    /**
     * Read the next string using the specified map, and verify that it
     * <b>IS</b> equal to the expected value, if all characters in both
     * strings are converted to monocase.
     *
     * @param expected the expected string
     * @exception IOException if the character read from the stream is not
     *                  equal to the specified character.
     */
    final public void matchStringIgnoreCase(OctetMap map,
                                            String expected)
        throws IOException
    {
        String actual = parseWhile(map);
        if (!actual.equalsIgnoreCase(expected)) {
            throw new IOException("Expected: " + expected +
                                  ", got: '" + actual + "', next char = " +
                                  ((char)peek()) + " (" + peek() + ")");
        }
    }

    /**
     * Peek ahead one character in the stream by reading, then pushing back
     * the character.
     *
     * @return the next character from the stream.
     * @exception IOException if an exception is thrown when the character
     *                  is read.
     */
    final public int peek() throws IOException {
        if (pushback > 0) {
            return pushback;
        } else {
            int c = read();
            unread(c);
            return c;
        }
    }

    /**
     * Copy bytes from an input stream to an output stream until a byte
     * not in the specified set is found.  That byte is returned, or -1
     * the end of file is reached.
     *
     * @param is the input stream from which bytes are is.read
     * @param os the output stream to which bytes are written
     * @param map the set of valid byte to copy
     * @return the first non matching byte
     * @exception IOException may be thrown
     */
    public static int copyWhile(InputStream is, OutputStream os, OctetMap map)
        throws IOException
    {
        int c = is.read();
        while (c >= 0 && map.has(c)) {
            os.write(c);
            c = is.read();
        }
        return c;
    }

    /**
     * Copy bytes from an input stream to an output stream until a byte
     * in the specified set is found.  That byte is returned, or -1
     * the end of file is reached.
     *
     * @param is the input stream from which bytes are is.read
     * @param os the output stream to which bytes are written
     * @param map the set of valid delimiter bytes
     * @return the first matching byte
     * @exception IOException may be thrown
     */
    public static int copyUntil(InputStream is, OutputStream os, OctetMap map)
        throws IOException
    {
        int c = is.read();
        while (c >= 0 && !map.has(c)) {
            os.write(c);
            c = is.read();
        }
        return c;
    }

    public static int copyUntil(InputStream is, OutputStream os, int dc)
        throws IOException
    {
        int c = is.read();
        while (c >= 0 && c != dc) {
            os.write(c);
            c = is.read();
        }
        return c;
    }

    /**
     * Copy bytes from <code>in</code> to <code>out</code> until the
     * specified string is is.read from <code>in</code.  The string bytes
     * are not written to <code>out</code>
     *
     * @param is the input stream from which bytes are is.read
     * @param os the output stream to which bytes are written
     * @param s the delimiter string
     * @return < 0 if end of file is reached before the string is found,
     *          >= 0 otherwise
     * @exception IOException may be thrown
     */
    public static int copyUntil(BufferedInputStream is, OutputStream os,
                                String s)
        throws IOException
    {
        if (s.length() == 0) throw new IOException("empty target");
        
        int ret = -1;
        int dc = s.charAt(0) & 0xff;
        for (boolean found = false; !found; ) {
            if (copyUntil(is, os, dc) < 0) return -1;
            
            is.mark(s.length());
            found = true;
            for (int i = 1; found && i < s.length(); i++) {
                int c = 0;
                if ((c = is.read()) != s.charAt(i)) {
                    for (int j = 0; j < i; j++) os.write(s.charAt(j));

                    if (c < 0) return -1;

                    is.reset();
                    found = false;
                }
            }
        }
        return 1;
    }

    /**
     * Read and discard characters until a character is found which
     * <b>is not</b> equal to the specified character.  Return the
     * terminating character.
     *
     * @param dc the character to discard
     * @exception IOException if an I/O exception is thrown
     */
    public static int skipWhile(InputStream is, int dc) throws IOException {
        int c;
        while (dc == (c = is.read())) continue;
        return c;
    }
}