Quadcap Embeddable Database

com/quadcap/sql/io/DataOutputStream.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.*;

import java.io.DataOutput;
import java.io.IOException;
import java.io.OutputStream;

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

/**
 * This class implements data output somewhat more efficiently than
 * the JDK version.  It also implements buffering and counting,
 * to help us avoid extra layers of stream classes.
 *
 * 4/2/03: XX What JDK version?  this hasn't been examined recently...
 *
 * @author Stan Bailes
 */
public class DataOutputStream extends OutputStream implements DataOutput {
    static final int                    MAX     = 4096;
    OutputStream                        out;
    byte[]                              buf     = new byte[MAX];
    byte[]                              tbuf    = new byte[16];
    Object[]                            bufs    = null;
    int                                 bufsCnt = 0;
    int                                 pos     = 0;
    int                                 siz     = -1;
    int                                 count   = 0;

    public DataOutputStream(OutputStream out) {
        this.out = out;
    }

    public void reset(OutputStream out) {
        this.out = out;
        bufsCnt = 0;
        pos = 0;
        count = 0;
        siz = -1;
        if (bufs != null && bufs.length > 0) {
            buf = (byte[])bufs[0];
        }
    }

    final Object[] resize(Object[] array, int size) {
        Object[] narray = new Object[size];
        System.arraycopy(array, 0, narray, 0, array.length);
        return narray;
    }

    public final void writeBuf() throws IOException {
        //#ifdef DEBUG
        if (trace) Debug.println("writeBuf(), buf = " + buf + ", bufsCnt = " +
                                 bufsCnt);
        //#endif
        
        if (out != null) {
            //#ifdef DEBUG
            if (trace) Debug.println("-----------------------------write:\n " +
                                     Util.strBytes(buf, 0, MAX));
            //#endif
            out.write(buf, 0, MAX);
            count += MAX;
        } else {
            if (bufs == null) {
                bufs = new Object[8];
            } else if (bufsCnt+1 >= bufs.length) {
                bufs = resize(bufs, bufsCnt * 2);
            }
            bufs[bufsCnt++] = buf;
            buf = (byte[])bufs[bufsCnt];
            if (buf == null) {
                buf = new byte[MAX];
                bufs[bufsCnt] = buf;
            }
        }
        pos = 0;
    }

    public final void write(int c) throws IOException {
        //#ifdef DEBUG
        if (trace) Debug.println("[" + pos + "]: write(" + c + ")");
        //#endif
        if (pos >= MAX) {
            writeBuf();
        }
        buf[pos++] = (byte)c;   
    }

    public final void write(byte[] b) throws IOException {
        write(b, 0, b.length);
    }
    
    public final void write(byte[] b, int off, int len) throws IOException {
        //#ifdef DEBUG
        if (trace) {
            Debug.println("[" + pos + "]: write(" +
                          Util.strBytes(b, off, len) + ")");
        }
        //#endif
        if (out != null && len > MAX) {
            flush();
            out.write(b, off, len);
            count += len;            
            return;
        }
        int npos = pos + len;
        while (npos >= MAX) {
            final int slen = MAX - pos;
            System.arraycopy(b, off, buf, pos, slen);
            writeBuf();
            len -= slen;
            off += slen;
            npos = pos + len;
        }
        if (len > 0) {
            System.arraycopy(b, off, buf, pos, len);
            pos = npos;
        }
    }

    public final void writeBoolean(boolean v) throws IOException {
        write(v ? 1 : 0);
    }

    public final void writeByte(int v) throws IOException {
        //#ifdef DEBUG
        if (trace) Debug.println("writeByte(" + v + ")");
        //#endif        
        if (pos >= MAX) writeBuf();
        buf[pos++] = (byte)v;   
    }
    
    //#ifdef SMALLDB
    public void writeLong(long v) throws IOException {
        while (true) {
            if (pos >= MAX) writeBuf();
            if ((v & 0xffffffffffffff80L) != 0) {
                buf[pos++] = (byte)(0x80 + (v & 0x7f));
                v >>>= 7;
            } else {
                buf[pos++] = (byte)(v & 0x7f);
                break;
            }
        }
    }
    public void writeInt(int v) throws IOException {
        //#ifdef DEBUG
        if (trace) Debug.println("[" + pos + "].writeInt(" + v + ")");
        //#endif                
        while (true) {
            if (pos >= MAX) writeBuf();
            if ((v & 0xffffff80) != 0) {
                buf[pos++] = (byte)(0x80 + (v & 0x7f));
                v >>>= 7;
            } else {
                buf[pos++] = (byte)(v & 0x7f);
                break;
            }
        }
    }

    public void writeShort(int v) throws IOException {
        writeInt(v);
    }
    public void writeChar(int v) throws IOException {
        writeInt(v);
    }
    
    //#else
//-    public final void writeShort(int v) throws IOException {
        //#ifdef DEBUG
//-        if (trace) Debug.println("writeShort(" + v + ")");
        //#endif
//-        if (pos + 1 >= MAX) {
//-            if (pos >= MAX) writeBuf();
//-            buf[pos++] = (byte)((v >>> 8) & 0xFF);
//-            if (pos >= MAX) writeBuf();
//-            buf[pos++] = (byte)((v >>> 0) & 0xFF);
//-        } else {
//-            buf[pos++] = (byte)((v >>> 8) & 0xFF);
//-            buf[pos++] = (byte)((v >>> 0) & 0xFF);
//-        }
//-    }
//-
//-    public final void writeChar(int v) throws IOException {
//-     writeShort(v);
//-    }
//-
//-    public final void writeInt(int v) throws IOException {
        //#ifdef DEBUG
//-        if (trace) Debug.println("writeInt(" + v + ") " +
//-                                 Util.hexBytes(Util.bytes(v)));
        //#endif
//-     tbuf[0] = (byte)((v >>> 24) & 0xFF);
//-     tbuf[1] = (byte)((v >>> 16) & 0xFF);
//-     tbuf[2] = (byte)((v >>> 8 ) & 0xFF);
//-     tbuf[3] = (byte)((v >>> 0 ) & 0xFF);
//-        write(tbuf, 0, 4);
//-    }
//-
//-    public final void writeLong(long v) throws IOException {
        //#ifdef DEBUG
//-        if (trace) Debug.println("writeLong(" + v + ")");
        //#endif
//-        
//-     tbuf[0] = (byte)((v >>> 56) & 0xFF);
//-     tbuf[1] = (byte)((v >>> 48) & 0xFF);
//-     tbuf[2] = (byte)((v >>> 40) & 0xFF);
//-     tbuf[3] = (byte)((v >>> 32) & 0xFF);
//-     tbuf[4] = (byte)((v >>> 24) & 0xFF);
//-     tbuf[5] = (byte)((v >>> 16) & 0xFF);
//-     tbuf[6] = (byte)((v >>> 8 ) & 0xFF);
//-     tbuf[7] = (byte)((v >>> 0 ) & 0xFF);
//-     write(tbuf, 0, 8);
//-    }
    //#endif

    public final void writeFloat(float v) throws IOException {
        writeInt(Float.floatToIntBits(v));
    }

    public final void writeDouble(double v) throws IOException {
        writeLong(Double.doubleToLongBits(v));
    }

    public final void writeBytes(String s) throws IOException {
        //#ifdef DEBUG
        if (trace) Debug.println("writeBytes(" + s + ")");
        //#endif
        int len = s.length();
        int off = 0;
        while (len + pos >= MAX) {
            int slen = MAX - pos;
            s.getBytes(off, off + slen, buf, pos);
            writeBuf();
            off += slen;
            len -= slen;
        }
        if (len > 0) {
            s.getBytes(off, len, buf, pos);
            pos += len;
        }
    }            
    
    public final void writeChars(String s) throws IOException {
        //#ifdef DEBUG
        if (trace) Debug.println("writeChars(" + s + ")");
        //#endif
        final int len = s.length();
        for (int i = 0 ; i < len ; i++) {
            int v = s.charAt(i);
            writeChar(v);
        }
    }

    public final void writeUTF(String str) throws IOException {
        throw new IOException("UTF write not implemented");
    }

    public final void flush() throws IOException {
        if (out != null) {
            //#ifdef DEBUG
            if (trace) Debug.println("flush, pos = " + pos);
            //#endif
            if (pos > 0) {
                //#ifdef DEBUG
                if (trace) Debug.println("flush(" + pos + "): " +
                                         Util.strBytes(buf, 0, pos));
                //#endif      
                out.write(buf, 0, pos);
                count += pos;
                pos = 0;
            }
            out.flush();
        }
    }

    public final void close() throws IOException {
        flush();
        if (out != null) out.close();
    }

    public int size() {
        int s = bufsCnt * MAX + pos;
        if (siz >= 0) {
            if (s > siz) siz = -1;
            else s = siz;
        }
        return s;
    }

    public final void setCount(int count) {
        this.count = count;
    }

    public final int getCount() {
        if (out == null) {
            return count;
        } else {
            return count + size();
        }
    }

    public final void setPosition(int p) {
        //#ifdef DEBUG
        if (trace) Debug.println("setPosition(" + p + ")");
        //#endif
        int s = size();
        if (p < s && s > siz) siz = s;
        bufsCnt = p / MAX;
        pos = p % MAX;
        if (bufs != null) {
            buf = (byte[])bufs[bufsCnt];
        }
    }

    public final int getPosition() {
        return size();
    }

    public byte[] toByteArray() {
        int len = size();
        setPosition(len);
        byte[] ret = new byte[len];
        int p = 0;
        for (int i = 0; i < bufsCnt; i++) {
            byte[] b = (byte[])bufs[i];
            System.arraycopy(b, 0, ret, p, Math.min(MAX, len));
            p += MAX;
            len -= MAX;
        }
        if (buf != null) {
            System.arraycopy(buf, 0, ret, p, pos);
        }
        return ret;
    }

    //#ifdef DEBUG
    public static void test1() throws IOException {
        FileOutputStream fos = new FileOutputStream("dos.out");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        byte[] bufx = new byte[2000];
        for (int i = 0; i < bufx.length; i++) {
            bufx[i] = (byte)(i & 0xff);
        }
        int cnt = 0;
        for (int i = 1; i < bufx.length; i++) {
            oos.write(bufx, 0, i);
            cnt += i;
            if (cnt != oos.getCount()) throw new RuntimeException("bad count, i = " + i);
            oos.flush();
            
        }
        oos.flush();
        fos.close();

        FileInputStream fis = new FileInputStream("dos.out");
        BufferedInputStream bis = new BufferedInputStream(fis);
        for (int i = 1; i < bufx.length; i++) {
            bis.read(bufx, 0, i);
            for (int j = 0; j < i; j++) {
                if ((bufx[j] & 0xff)!= (j&0xff)) {
                    throw new RuntimeException("bad, i = " + i + ", j = " + j);
                }
            }
        }
        fis.close();
    }
            
            

    public static void main(String args[]) {
        try {
//              ObjectOutputStream out = new ObjectOutputStream();
//              out.setPosition(6);
//              out.writeInt(0xaabbccdd);
//              out.setPosition(0);
//              out.writeInt(0xffeeddcc);
//              for (int i = 0; i < 2000; i++) {
//                  out.writeInt(i);
//              }
//              out.setPosition(0);
//              out.writeInt(0x11223344);
//              out.writeInt(0x55667788);
//              System.out.println(Util.strBytes(out.toByteArray()));
            test1();
        } catch (Throwable t) {
            Debug.print(t);
        }
    }

    boolean trace = false;
    public void setTrace(boolean t) {
        this.trace = t;
    }
    //#endif
}