Quadcap Embeddable Database

com/quadcap/sql/io/DataInputStream.java

Go to the documentation of this file.

package com.quadcap.sql.io;

/* Copyright 1999 - 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.BufferedReader;
import java.io.DataInput;
import java.io.EOFException;
import java.io.InputStream;
import java.io.IOException;

import com.quadcap.io.InputStreamReader;

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

/**
 * Implement low level serialization
 */
public class DataInputStream extends InputStream implements DataInput {
    InputStream                 in;
    static final boolean buffered = false;
    
    static final int            MAX = 4096;
    byte[]                      buf = new byte[MAX];
    int                         pos;
    int                         len;

    public DataInputStream(InputStream in) {
        this.in = in;
        this.pos = 0;
        this.len = 0;
    }

    long position;
    public void setPosition(long p) { this.position = p; }
    public long getPosition() { return position; }

    public void setInputStream(InputStream in) {
        this.in = in;
    }
    public InputStream getInputStream() {
        return in;
    }
    
    public void readFully(byte[] b) throws IOException {
        read(b, 0, b.length);
    }
    
    public void readFully(byte[] b, int off, int len) throws IOException {
        read(b, off, len);
    }
    
    public int skipBytes(int n) throws IOException {
        return (int)skip(n);
    }
    
    public boolean readBoolean() throws IOException {
        return read() == 1;
    }
    
    public byte readByte() throws IOException {
        return (byte)read();
    }
    
    public int readUnsignedByte() throws IOException {
        return read();
    }

    public char readChar() throws IOException {
        return (char)readUnsignedShort();
    }
    
    final long readLongByte() throws IOException {
        return readUnsignedByte();
    }    
    
    //#ifdef SMALLDB
    public long readLong() throws IOException {
        long ret = 0;
        long b;
        int shift = 0;
        do {
            b = read();
            ret |= ((b & 0x7f) << shift);
            shift += 7;
        } while ((b & 0x80) != 0);
        return ret;
    }

    public int readInt() throws IOException {
        int ret = 0;
        int b;
        int shift = 0;
        do {
            b = read();
            ret |= ((b & 0x7f) << shift);
            shift += 7;
        } while ((b & 0x80) != 0);
        return ret;
    }

    public short readShort() throws IOException {
        return (short)readInt();
    }

    public int readUnsignedShort() throws IOException {
        return readInt();
    }
    
    //#else
//-    public short readShort() throws IOException {
//-        return (short)readUnsignedShort();
//-    }
//-    
//-    public int readUnsignedShort() throws IOException {
//-        int ret = readUnsignedByte() << 8;
//-        ret += readUnsignedByte();
//-        return ret;
//-    }
//-    
//-    public int readInt() throws IOException {
//-        int ret = readUnsignedByte() << 24;
//-        ret |= (readUnsignedByte() << 16);
//-        ret |= (readUnsignedByte() << 8);
//-        ret |= readUnsignedByte();
//-        return ret;
//-    }
//-
//-    public long readLong() throws IOException {
//-        long ret = readLongByte() << 56;
//-        ret |= (readLongByte() << 48);
//-        ret |= (readLongByte() << 40);
//-        ret |= (readLongByte() << 32);
//-        ret |= (readLongByte() << 24);
//-        ret |= (readLongByte() << 16);
//-        ret |= (readLongByte() << 8);
//-        ret |= readLongByte();
//-        return ret;
//-    }
    //#endif
    
    public float readFloat() throws IOException {
        return Float.intBitsToFloat(readInt());
    }
    
    public double readDouble() throws IOException {
        return Double.longBitsToDouble(readLong());
    }
    
    public String readLine() throws IOException {
        InputStreamReader ns = new InputStreamReader(this);
        BufferedReader r = new BufferedReader(ns);
        return r.readLine();
    }
    
    public String readUTF() throws IOException {
        throw new IOException("readUTF not implemented");
    }

    final boolean fillBuffer() throws IOException {
        boolean ret = pos >= len;
        if (ret) {
            len = in.read(buf, 0, buf.length);
            pos = 0;
            ret = pos >= len;
        }
        return ret;
    }

    public int read() throws IOException {
        int ret = -1;
        if (buffered) {
            if (!fillBuffer()) {
                ret = buf[pos++] & 0xff;
                position++;
            }
        } else {
            ret = in.read();
            if (ret < 0) {
                throw new EOFException();
            }
            position++;
        }
        //#ifdef DEBUG
        if (trace) Debug.println("DIS.read() = " + ret);
        //#endif
        return ret;
    }

    public int read(byte[] b, int off, int cnt) throws IOException {
        int ret = 0;
        //#ifdef DEBUG
        int xoff = off;
        int xcnt = cnt;
        //#endif
        if (buffered) {
            while (cnt > 0 && !fillBuffer()) {
                int amt = len - pos;
                if (amt > cnt) amt = cnt;
                System.arraycopy(buf, pos, b, off, amt);
                cnt -= amt;
                off += amt;
                ret += amt;
                pos += amt;
                position += amt;
            }
        } else {
            while (cnt > 0) {
                int amt = in.read(b, off, cnt);
                ret += amt;
                position += amt;
                off += amt;
                cnt -= amt;
            }
        }
        //#ifdef DEBUG
        if (trace) {
            Debug.println("DIS.read() = " + ret + ": " +
                          Util.hexBytes(b, xoff, ret));
        }
        //#endif
        return ret;
    }

    //#ifdef DEBUG
    static final boolean trace = false;
    //#endif
    
    public int read(byte[] buf) throws IOException {
        return read(buf, 0, buf.length);
    }

    public long skip(long n) throws IOException {
        long ret = 0;
        if (buffered) {
            while (n > 0 && !fillBuffer()) {
                long amt = len - pos;
                if (amt > n) amt = n;
                n -= amt;
                pos += amt;
                position += amt;
            }
        } else {
            ret = in.skip(n);
        }
        return ret;
    }
}