Quadcap Embeddable Database

com/quadcap/sql/file/SubPage.java

Go to the documentation of this file.

package com.quadcap.sql.file;

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

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

/**
 * This class implements a page allocated by a sub-page allocator.
 *
 * @author Stan Bailes
 */
public class SubPage implements Page {
    SubPageManager              pm;
    BlockFile                   file;
    long                        pageNum;
    int                         pageOffset;
    Block                       block           = null;

    /**
     * Construct a new SubPage
     */
    public SubPage(SubPageManager pm, long pageNum) throws IOException {
        this.pm = pm;
        this.file = pm.file;
        this.pageNum = pageNum;
        this.pageOffset = pm.pageOffset(pageNum);
        this.block = file.getBlock(SubPageManager.pageBlock(pageNum));
    }
    
    /**
     * Return this page's number
     */
    public long getPageNum() {
        return pageNum;
    }

    /**
     * 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 int read(int pos, byte[] pbuf, int offset, int len) {
        //#ifdef PARANOID
//-        if (pos < 0 || (pos+len) > pm.getPageSize()) {
//-            throw new ArrayIndexOutOfBoundsException("Bad read(" + pos + ", " + len + ")");
//-        }
        //#endif
        return block.read(pos + pageOffset, pbuf, offset, 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 int write(int pos, byte[] pbuf, int offset, int len) {
        //#ifdef PARANOID
//-        if (pos < 0 || pos >= pm.getPageSize()) {
//-            throw new ArrayIndexOutOfBoundsException("Bad write(" + pos + ", " + len + ")");
//-        }
        //#endif
        return block.write(pos + pageOffset, pbuf, offset, len);
    }

    /**
     * Read an integer (4-byte) value from the page.
     *
     * @param pos the offset in the page of the integer.
     */
    public int readInt(int pos) {
        return block.readInt(pos + pageOffset);
    }

    /**
     * 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 void writeInt(int pos, int val) {
        block.writeInt(pos + pageOffset, val);
    }

    /**
     * Read a long (8-byte) value from the page.
     *
     * @param pos the offset in the page of the long.
     */
    public long readLong(int pos) {
        return block.readLong(pos + pageOffset);
    }

    /**
     * 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 void writeLong(int pos, long val) {
        block.writeLong(pos + pageOffset, val);
    }

    /**
     * Move the contents of the other page to this page, and zero out
     * the other page.
     */
    public void takeData(Page p) {
        byte[] buf = new byte[pm.pageSize];
        p.read(0, buf, 0, pm.pageSize);
        write(0, buf, 0, pm.pageSize);
        for (int i = 0; i < buf.length; i++) buf[i] = 0;
        p.write(0, buf, 0, pm.pageSize);
    }

    public void clear() {
        byte[] buf = new byte[pm.pageSize];
        for (int i = 0; i < buf.length; i++) buf[i] = 0;
        write(0, buf, 0, pm.pageSize);
    }
    
    public void decrRefCount() {
        if (block != null) {
            block.decrRefCount();
            block = null;
        }
    }

    //#ifdef DEBUG
    public String toString() {
        return "Page(" + SubPageManager.toString(pageNum) + ")";
    }
    //#endif

}