Quadcap Embeddable Database

com/quadcap/sql/file/BufferedRandomAccess.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;

/**
 * A <code>RandomAccess</code> implementation using a byte array.
 *
 * @author Stan Bailes
 */
public class BufferedRandomAccess extends RandomAccess {
    static final int    BUFSIZE                 = 16384;

    class Buffer {
        byte[]              buf                 = new byte[BUFSIZE];
        long                adr                 = -1;
        boolean             dty                 = false;

        //#ifdef DEBUG
        public String toString() {
            return "Buffer[" + adr + "]" + (dty?"*":"");
        }
        //#endif
    }
    Buffer              b1 = new Buffer();
    Buffer              b2 = new Buffer();
    Buffer              b  = null;

    RandomAccess        ra;
    long                size;

    public BufferedRandomAccess(RandomAccess ra) {
        this.ra = ra;
        size = ra.size();
    }

    /**
     * Return the size of the managed region.
     */
    public long size() {
        return size;
    }

    /**
     * Resize the managed region.
     */
    public void resize(long newSize) throws IOException {
        size = newSize;
        ra.resize(newSize);
    }

    /* Write <tt>len</tt> bytes from position <tt>offset</tt> in buffer
     * <tt>buf</tt> to position <tt>pos</tt> bytes into the managed
     * area.
     */
    public void write(long pos, byte[] buf, int offset, int len)
        throws IOException
    {
        do {
            long pb = pos & ~(BUFSIZE-1);
            long pe = pb + BUFSIZE-1;
            if (pe >= size) pe = size-1;
            int xlen = (int)(pe - pos + 1);
            if (xlen > len) xlen = len;
            if (xlen > 0) {
                getBuffer(pb);
                System.arraycopy(buf, offset, b.buf, (int)(pos-pb), xlen);
                b.dty = true;
                offset += xlen;
                pos += xlen;
                len -= xlen;
            } else {
                len = 0;
            }
        } while (len > 0);
        
    }

    /**
     * Read <tt>len</tt> bytes from location <tt>pos</tt> of the region
     * into the buffer <tt>buf</tt>, starting at <tt>offset</tt>.
     */
    public void read(long pos, byte[] buf, int offset, int len)
        throws IOException
    {
        do {
            long pb = pos & ~(BUFSIZE-1);
            long pe = pb + BUFSIZE-1;
            if (pe >= size) pe = size-1;
            int xlen = (int)(pe - pos + 1);
            if (xlen > len) xlen = len;
            if (xlen > 0) {
                getBuffer(pb);
                System.arraycopy(b.buf, (int)(pos-pb), buf, offset, xlen);
                offset += xlen;
                pos += xlen;
                len -= xlen;
            } else {
                len = 0;
            }
        } while (len > 0);
    }

    final void getBuffer(long addr) throws IOException {
        if (addr == b1.adr) {
            b = b1;
        } else if (addr == b2.adr) {
            b = b2;
        } else {
            b = (b == b1) ? b2 : b1;
            if (b.dty) flush(b);
            b.adr = addr;
            int xlen = (int)(ra.size() - addr);
            if (xlen > BUFSIZE) xlen = BUFSIZE;
            ra.read(addr, b.buf, 0, xlen);
        }
    }
    
    /**
     * Finalization...
     */
    public void close() throws IOException {
        flush();
        ra.close();
    }

    final void flushBuffers() throws IOException {
        flush(b1);
        flush(b2);
    }
    
    public void flush() throws IOException {
        flushBuffers();
        ra.flush();
    }

    final void flush(Buffer b) throws IOException {
        if (b.dty) {
            int xlen = (int)(ra.size() - b.adr);
            if (xlen > BUFSIZE) xlen = BUFSIZE;
            ra.write(b.adr, b.buf, 0, xlen);
            b.dty = false;
        }
    }
}