Quadcap Embeddable Database

com/quadcap/sql/file/Block.java

Go to the documentation of this file.

package com.quadcap.sql.file;

/* 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.IOException;

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

/**
 * This class represents a block/page of data in a random access file,
 * which may be cached.  The key is an Integer specifying the block
 * number, while the data is a byte array containing the actual
 * data.
 *
 * @author Stan Bailes
 */
public class Block extends Cacheable implements Page {
    private byte[]              buf;

    public long getPageNum() { return key; }

    /**
     * Initialize this block.  Create the buffer if necessary, and initialize
     * the buffer contents from the underlying store.  We assume that the
     * <code>BlockStore.read()</code> method will fill the buffer with zeros
     * if we're attempting to "read" a block that doesn't exist yet.
     *
     * @param store the underlying <code>BlockStore</code> which manages
     *          the blocks.
     * @param key an <code>Integer</code> specifying the block number.
     */
    public void init(Object store, long key) throws IOException {
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block.init(" + store + ", " + key + ")");
        }
        //#endif
        super.init(store, key);
        BlockStore bs = (BlockStore)store;
        if (buf == null) buf = new byte[bs.blockSize()];
        bs.read(getPageNum(), buf);
        setDirty(false);
    }

    /**
     * Write the contents of the buffer back to the underlying store.
     */
    public final void flush() throws IOException {
        //#ifdef DEBUG
        if (Trace.bit(1)) {
            Debug.println(0, "Block[" + key + "].flush()");
        }
        //#endif
        if (dirty) {
            //#ifdef DEBUG
            if (Trace.bit(0)) {
                Debug.println("flush [" + getPageNum() + "]");
            }
            //#endif
            BlockStore bs = (BlockStore)store;
            bs.write(getPageNum(), buf);
            setDirty(false);
        }
    }

    /**
     * From the Cacheable class, return the underlying data object.
     * When used as a <tt>Block</tt>, we typically use the <tt>read()</tt>
     * and <tt>write</tt> methods to access the underlying data...
     */
    public final Object getData() { return buf; }

    /**
     * Return a reference to the array containing the data for this
     * block, and create a new buffer, so that the reference returned
     * can be used in a subsequent <code>setData</code> call to another
     * buffer.  This allows the contents of one block to be moved to
     * another block with a minimum of array copying.
     */
    public byte[] getDataAndReset() {
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block[" + key + "].getDataAndReset()");
        }
        //#endif
        byte[] r = buf;
        buf = new byte[r.length];
        setDirty(true);
        return r;
    }

    /**
     * From the Cacheable class, set the underlying data object.
     * When used as a <tt>Block</tt>, we typically use the <tt>read()</tt>
     * and <tt>write</tt> methods to access the underlying data...
     */
    public void setData(Object obj) {
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block[" + key + "].setData(" + obj + ")");
        }
        //#endif
        byte[] r = (byte[])obj;
        if (r.length != buf.length) {
            throw new RuntimeException("Bad buffer length!");
        }
        buf = r;
        setDirty(true);
    }

    /**
     * Only a debugging version implemented so far...
     */
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("[key(" + getKey() + "), dirty(" + dirty + "), refcount(" +
                  refCount + ")]");
        return sb.toString();
    }

    /**
     * Read a range of bytes from the page.
     *
     * @param pos the offset in the page of the first byte to read
     * @param pbuf the buffer into which the bytes are placed.
     * @param offset the offset in <code>pbuf</code> where the first byte
     *                  is placed.
     * @param len the number of bytes to read
     */
    public final int read(int pos, byte[] pbuf, int offset, int len) {
        //#ifdef DEBUG
        if (Trace.bit(1)) {
            Debug.println("Block[" + key + "].read(" + pos + ", " + len + ")" +
                          ", offset = " + offset + ", buf.len = " + buf.length +
                          ", pbuf.len = " + pbuf.length);
        }
        //#endif
        
        System.arraycopy(buf, pos, pbuf, offset, len);
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block[" + key + "].read(" + pos + ", " + len +
                          "): " + Util.strBytes(pbuf, offset, len));
        }
        //#endif
        return len;
    }

    /**
     * Write a range of bytes to the page.
     *
     * @param pos the offset in the page of the first byte to write
     * @param pbuf the buffer from which the bytes are obtained
     * @param offset the offset in <code>pbuf</code> of the first byte
     *                  to write
     * @param len the number of bytes to write
     */
    public final int write(int pos, byte[] pbuf, int offset, int len) {
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block[" + key + "].write(" + pos + ", " +
                          Util.strBytes(pbuf, offset, len) + ")");
        }
        //#endif
        System.arraycopy(pbuf, offset, buf, pos, len);
        setDirty(true);
        return len;
    }

    public final byte readByte(int pos) {
        //#ifdef DEBUG
        if (Trace.bit(1)) {
            Debug.println("Block[" + key + "].read(" + (pos) + "): " + buf[pos]);
        }
        //#endif
        return buf[pos];
    }

    public final void writeByte(int pos, byte val) {
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block[" + key + "].write(" + pos + "): " + val);
        }
        //#endif
        buf[pos] = val;
        setDirty(true);
    }

    /**
     * Read a short (2-byte) value from the page.
     *
     * @param pos the offset in the page of the short.
     */
    public final short readShort(int pos) {
        short ret = ByteUtil.getShort(buf, pos);
        //#ifdef DEBUG
        if (Trace.bit(1)) {
            Debug.println("Block[" + key + "].readShort(" + pos + ") = " + ret);
        }
        //#endif
        return ret;
    }

    /**
     * Write a short (2-byte) value to the page.
     *
     * @param pos the offset in the page of the short.
     * @param val the short value to write.
     */
    public final void writeShort(int pos, short val) {
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block[" + key + "].writeShort(" + pos + ", " +
                          val + ")");
        }
        //#endif
        ByteUtil.putShort(buf, pos, val);
        setDirty(true);
    }

    /**
     * Read an integer (4-byte) value from the page.
     *
     * @param pos the offset in the page of the integer.
     */
    public final int readInt(int pos) {
        int ret = ByteUtil.getInt(buf, pos);
        //#ifdef DEBUG
        if (Trace.bit(1)) {
            Debug.println("Block[" + key + "].readInt(" + pos + ") = " + ret);
        }
        //#endif
        return ret;
    }

    /**
     * Write an integer (4-byte) value to the page.
     *
     * @param pos the offset in the page of the integer.
     * @param val the integer value to write.
     */
    public final void writeInt(int pos, int val) {
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block[" + key + "].writeInt(" + pos + ", " +
                          val + ")");
        }
        //#endif
        ByteUtil.putInt(buf, pos, val);
        setDirty(true);
    }

    /**
     * Read a long (8-byte) value from the page.
     *
     * @param pos the offset in the page of the long.
     */
    public final long readLong(int pos) {
        long ret = ByteUtil.getLong(buf, pos);
        //#ifdef DEBUG
        if (Trace.bit(1)) {
            Debug.println("Block[" + key + "].readLong(" + pos + ") = " + ret);
        }
        //#endif
        return ret;
    }

    /**
     * Write a long (8-byte) value to the page.
     *
     * @param pos the offset in the page of the long.
     * @param val the long value to write.
     */
    public final void writeLong(int pos, long val) {
        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Block[" + key + "].writeLong(" + pos + ", " +
                          val + ")");
        }
        //#endif
        ByteUtil.putLong(buf, pos, val);
        setDirty(true);
    }

    public final void takeData(Page p) {
        setData(((Block)p).getDataAndReset());
    }

    public void clear() {
        for (int i = 0; i < buf.length; i++) buf[i] = 0;
        setDirty(true);
    }

    //#ifdef DEBUG
    // used for test below
    void init() {
        buf = new byte[32];
    }

    // A 12 bit (two base64 chars) signature.  Live dangerously.
    public String signature() {
        return signature(buf);
    }
    
    public static String signature(byte[] buf) {
        return signature(buf, 0, buf.length);
    }
    public static String signature(byte[] buf, int off, int cnt) {
        byte[] b = com.quadcap.io.Base64OutputStream.base64;
        int h = 31415;
        long tot = 0;
        for (int i = 0; i < cnt; i++) {
            tot += buf[off+i];
            h ^= (h << 7) ^ (h >> 3) ^ buf[off + i];
        }
        return "" + (char)b[(h >> 1) & 63] + (char)b[(h >> 8) & 63] + (char)b[(h >> 16) & 63] +
            ((tot == 0) ? "*" : "");
    }
        

    public static void main(String args[]) {
        Block b = new Block();
        b.init();
        b.writeInt(20, 128);
        byte[] bufx = new byte[32];
        b.read(20, bufx, 0, 4);
        int v = b.readInt(20);
    }
    //#endif
}