jdbmbucket.java

NMS jdbm

// Developed by Kinva Network Inc. 2000


// Source File Name:   jdbmBucket.java

package com.kinva.util.jdbm;

import java.io.*;

// Referenced classes of package com.kinva.util.jdbm:
//            jdbm, jdbmBucketElement

class jdbmBucket
{

    private final boolean arrayStartsWith(byte abyte0[], byte abyte1[])
    {
        int i = Math.min(abyte0.length, abyte1.length);
        for(int j = 0; j < i; j++)
            if(abyte0[j] != abyte1[j])
            {
                db.trace("array doesn't start with.");
                return false;
            }

        db.trace("array matches.");
        return true;
    }

    private final boolean arrayEquals(byte abyte0[], byte abyte1[])
    {
        if(abyte0.length == abyte1.length)
        {
            int i = abyte0.length;
            for(int j = 0; j < i; j++)
                if(abyte0[j] != abyte1[j])
                    return false;

            return true;
        } else
        {
            return false;
        }
    }

    void save(DataOutputStream dataoutputstream)
        throws IOException
    {
        dataoutputstream.writeInt(bits);
        dataoutputstream.writeInt(count);
        for(int i = 0; i < elements.length; i++)
            elements[i].save(dataoutputstream);

        dataoutputstream.writeInt(avail_count);
        for(int j = 0; j < avail_size.length; j++)
        {
            dataoutputstream.writeInt(avail_size[j]);
            dataoutputstream.writeInt(avail_ptr[j]);
        }

        modified = false;
    }

    static jdbmBucket restore(DataInputStream datainputstream, int i, jdbmBucket jdbmbucket)
        throws IOException
    {
        jdbmbucket.fileptr = i;
        jdbmbucket.bits = datainputstream.readInt();
        jdbmbucket.count = datainputstream.readInt();
        for(int j = 0; j < jdbmbucket.elements.length; j++)
            jdbmBucketElement.restore(datainputstream, jdbmbucket.elements[j]);

        jdbmbucket.avail_count = datainputstream.readInt();
        for(int k = 0; k < jdbmbucket.avail_size.length; k++)
        {
            jdbmbucket.avail_size[k] = datainputstream.readInt();
            jdbmbucket.avail_ptr[k] = datainputstream.readInt();
        }

        return jdbmbucket;
    }

    protected jdbmBucketElement lookup(byte abyte0[], int i)
        throws IOException
    {
        int j = i % db.bucket_elems;
        int k = j;
        do
        {
            jdbmBucketElement jdbmbucketelement = elements[j];
            db.trace("lookup: hc = " + i + " at " + j + " " + jdbmbucketelement);
            if(jdbmbucketelement.hashval == -1)
                return null;
            if(jdbmbucketelement.hashval == i && arrayStartsWith(abyte0, jdbmbucketelement.keystart))
            {
                byte abyte1[] = db.readKey(jdbmbucketelement);
                if(arrayEquals(abyte1, abyte0))
                    return jdbmbucketelement;
            }
            j = (j + 1) % elements.length;
        } while(j != k);
        return null;
    }

    protected void add(int i, byte abyte0[], byte abyte1[])
        throws IOException
    {
        if(count >= db.bucket_elems)
            throw new RuntimeException("implementation error.");
        int j = i % db.bucket_elems;
        do
        {
            jdbmBucketElement jdbmbucketelement = elements[j];
            if(jdbmbucketelement.hashval == -1)
            {
                jdbmbucketelement.hashval = i;
                System.arraycopy(abyte0, 0, jdbmbucketelement.keystart, 0, abyte0.length > 4 ? 4 : abyte0.length);
                jdbmbucketelement.key_size = abyte0.length;
                jdbmbucketelement.data_size = abyte1.length;
                jdbmbucketelement.fileptr = db.write(this, abyte0, abyte1);
                modified = true;
                count++;
                return;
            }
            j = (j + 1) % elements.length;
        } while(true);
    }

    private final void removeAvailable(int i)
    {
        modified = true;
        avail_count--;
        if(i == avail_count)
        {
            return;
        } else
        {
            System.arraycopy(avail_size, i + 1, avail_size, i, avail_count - i);
            System.arraycopy(avail_ptr, i + 1, avail_ptr, i, avail_count - i);
            return;
        }
    }

    private void markAvailable(int i, int j)
    {
        modified = true;
        for(int k = 0; k < avail_count; k++)
            if(avail_size[k] >= j)
            {
                System.arraycopy(avail_size, k, avail_size, k + 1, avail_count - k);
                System.arraycopy(avail_ptr, k, avail_ptr, k + 1, avail_count - k);
                avail_count++;
                avail_size[k] = j;
                avail_ptr[k] = i;
                return;
            }

        avail_size[avail_count] = j;
        avail_ptr[avail_count] = i;
        avail_count++;
    }

    private int fixAvailable(int i, int j)
    {
        modified = true;
        int k = avail_ptr[i];
        int l = avail_size[i] -= j;
        int i1 = avail_ptr[i] += j;
        removeAvailable(i);
        if(l <= 8)
            return k;
        if(l >= db.block_size)
            db.markAvailable(i1, l);
        else
            markAvailable(i1, l);
        return k;
    }

    protected void delete(jdbmBucketElement jdbmbucketelement)
    {
        int i = jdbmbucketelement.key_size + jdbmbucketelement.data_size;
        if(i >= db.block_size || avail_count + 1 >= 6)
            db.markAvailable(jdbmbucketelement.fileptr, i);
        else
            markAvailable(jdbmbucketelement.fileptr, jdbmbucketelement.key_size + jdbmbucketelement.data_size);
        int j;
        for(j = jdbmbucketelement.hashval % db.bucket_elems; elements[j] != jdbmbucketelement; j = (j + 1) % db.bucket_elems);
        jdbmbucketelement.hashval = -1;
        count--;
        int k = j;
        for(j = (j + 1) % db.bucket_elems; j != k && elements[j].hashval != -1; j = (j + 1) % db.bucket_elems)
        {
            int l = elements[j].hashval % db.bucket_elems;
            if(k < j && (l <= k || l > j) || k > j && l <= k && l > j)
            {
                elements[k] = elements[j];
                elements[j] = new jdbmBucketElement();
                k = j;
            }
        }

        modified = true;
    }

    protected int allocateSpace(int i)
    {
        for(int j = 0; j < avail_count; j++)
            if(avail_size[j] >= i)
                return fixAvailable(j, i);

        return -1;
    }

    jdbmBucket(jdbm jdbm1, int i, int j)
    {
        modified = false;
        fileptr = -1;
        db = jdbm1;
        fileptr = i;
        elements = new jdbmBucketElement[jdbm1.bucket_elems];
        for(int k = 0; k < elements.length; k++)
            elements[k] = new jdbmBucketElement();

        avail_count = 0;
        avail_size = new int[6];
        avail_ptr = new int[6];
        if(j >= 0)
        {
            avail_count = 1;
            avail_size[0] = jdbm1.block_size;
            avail_ptr[0] = j * jdbm1.block_size;
        }
    }

    private static final int AVAIL_SIZE = 6;
    private static final int IGNORE_SIZE = 8;
    static final int fsize = 60;
    int bits;
    int count;
    jdbmBucketElement elements[];
    int avail_count;
    int avail_size[];
    int avail_ptr[];
    jdbm db;
    boolean modified;
    int fileptr;
}