jdbm.java

jdbm NMS

    {
        int i = hash(abyte0);
        jdbmBucket jdbmbucket = lookupBucket(i);
        jdbmBucketElement jdbmbucketelement = jdbmbucket.lookup(abyte0, i);
        if(jdbmbucketelement != null)
            return readData(jdbmbucketelement);
        else
            return null;
    }

    public byte[] lookup(String s)
        throws IOException
    {
        byte abyte0[] = new byte[s.length()];
        s.getBytes(0, abyte0.length, abyte0, 0);
        return lookup(abyte0);
    }

    public boolean delete(byte abyte0[])
        throws IOException
    {
        int i = hash(abyte0);
        jdbmBucket jdbmbucket = lookupBucket(i);
        jdbmBucketElement jdbmbucketelement = jdbmbucket.lookup(abyte0, i);
        if(jdbmbucketelement != null)
        {
            jdbmbucket.delete(jdbmbucketelement);
            return true;
        } else
        {
            return false;
        }
    }

    public boolean delete(String s)
        throws IOException
    {
        byte abyte0[] = new byte[s.length()];
        s.getBytes(0, abyte0.length, abyte0, 0);
        return delete(abyte0);
    }

    public void close()
        throws IOException
    {
        try
        {
            save();
        }
        catch(IOException ioexception)
        {
            System.out.println("jdbm: Could not save while closing: " + ioexception.getMessage());
        }
        fd.close();
    }

    public void save()
        throws IOException
    {
        if(header_changed)
        {
            trace("saving header.");
            DataOutputStream dataoutputstream = new DataOutputStream(new FastByteArrayOutputStream(buffer));
            saveHeader(dataoutputstream);
            fd.seek(0L);
            fd.write(buffer);
            header_changed = false;
        }
        if(dir_changed)
        {
            trace("saving directory.");
            byte abyte0[] = new byte[dir_size * 4];
            DataOutputStream dataoutputstream1 = new DataOutputStream(new FastByteArrayOutputStream(abyte0));
            saveDirectory(dataoutputstream1);
            fd.seek(dir_adr);
            fd.write(abyte0);
            dir_changed = false;
        }
        list.saveModified(this);
    }

    public jdbm(File file1)
        throws IOException
    {
        block_size = 1024;
        dir_bits = 3;
        cache_size = 32;
        dir_changed = false;
        header_changed = false;
        boolean flag = file1.exists();
        file = file1;
        fd = new RandomAccessFile(file1, "rw");
        buffer = new byte[block_size];
        list = new LRUList();
        if(flag)
        {
            fd.seek(0L);
            if(fd.read(buffer) != buffer.length)
            {
                fd.close();
                throw new IOException("unable to restore DB header.");
            }
            restoreHeader(new DataInputStream(new ByteArrayInputStream(buffer)));
            fd.seek(dir_adr);
            byte abyte0[] = new byte[dir_size * 4];
            fd.readFully(abyte0);
            if(fd.read(buffer) != buffer.length)
            {
                fd.close();
                throw new IOException("unable to restore DB directory.");
            } else
            {
                restoreDirectory(new DataInputStream(new ByteArrayInputStream(abyte0)));
                loaded_buckets = 0;
                return;
            }
        }
        block_size = 1024;
        dir_bits = 3;
        dir_adr = block_size;
        bucket_elems = (block_size - 60) / 24 + 1;
        for(dir_size = 1 << dir_bits; dir_size * 4 < block_size;)
        {
            dir_size <<= 1;
            dir_bits++;
        }

        if(dir_size * 4 != block_size)
            throw new RuntimeException("block_size can't match dir_size");
        cache_size = 32;
        loaded_buckets = 1;
        diridx = new int[dir_size];
        int i = 2 * block_size;
        LRUEntry lruentry = list.addEntry(new jdbmBucket(this, i, 3));
        for(int j = 0; j < dir_size; j++)
            diridx[j] = i;

        avail_length = (block_size - 36) / 8;
        avail_size = new int[avail_length];
        avail_ptr = new int[avail_length];
        avail_count = 0;
        next_block = 4;
        DataOutputStream dataoutputstream = null;
        dataoutputstream = new DataOutputStream(new FastByteArrayOutputStream(buffer));
        saveHeader(dataoutputstream);
        fd.seek(0L);
        fd.write(buffer);
        dataoutputstream = new DataOutputStream(new FastByteArrayOutputStream(buffer));
        saveDirectory(dataoutputstream);
        fd.seek(dir_adr);
        fd.write(buffer);
        dataoutputstream = new DataOutputStream(new FastByteArrayOutputStream(buffer));
        lruentry.bucket.save(dataoutputstream);
        fd.seek(2 * block_size);
        fd.write(buffer);
    }

    protected boolean getNextBucket(jdbmEnumerator jdbmenumerator)
        throws IOException
    {
        int i = -1;
        int j = -1;
        int k = -1;
        if(jdbmenumerator.didx < 0)
        {
            k = 0;
            j = -1;
            i = diridx[0];
        } else
        if(jdbmenumerator.didx + 1 < dir_size)
        {
            k = jdbmenumerator.didx;
            j = diridx[k++];
            i = diridx[k];
        } else
        {
            return false;
        }
        for(; i == j && k < dir_size; i = diridx[k++]);
        if(k < dir_size)
        {
            LRUEntry lruentry = list.lookupBucket(i);
            if(lruentry == null)
                lruentry = loadBucket(i);
            list.notifyUses(lruentry);
            jdbmenumerator.bucket = lruentry.bucket;
            jdbmenumerator.didx = k;
            jdbmenumerator.bidx = 0;
            return true;
        } else
        {
            return false;
        }
    }

    public Enumeration keys()
    {
        return new jdbmEnumerator(this, true, -1);
    }

    public Enumeration elements()
    {
        return new jdbmEnumerator(this, false, -1);
    }

    public jdbm reorganize(boolean flag)
    {
        Enumeration enumeration = keys();
        int i = 0;
        File file1 = new File(file.getParent(), file.getName() + ".tmp");
        Object obj = null;
        jdbm jdbm2 = null;
        long l = -1L;
        try
        {
            save();
            jdbm jdbm1 = new jdbm(file1);
            if(flag)
            {
                System.out.println("using temp file: " + file1);
                l = System.currentTimeMillis();
            }
            while(enumeration.hasMoreElements()) 
            {
                byte abyte0[] = (byte[])enumeration.nextElement();
                byte abyte1[] = lookup(abyte0);
                if(abyte1 != null)
                    jdbm1.store(abyte0, abyte1, 1);
                else
                if(flag)
                    System.out.println("no value for [" + new String(abyte0) + "]");
                if(flag && ++i % 100 == 0)
                    System.out.println(i + " elements reindexed.");
            }
            jdbm1.save();
            if(flag)
                System.out.println("reorganization done (" + (System.currentTimeMillis() - l) + "ms)");
        }
        catch(Exception exception1)
        {
            file1.delete();
            file1 = null;
            exception1.printStackTrace();
        }
        finally
        {
            if(file1 != null)
            {
                file.delete();
                file1.renameTo(file);
                try
                {
                    jdbm2 = new jdbm(file);
                }
                catch(IOException ioexception)
                {
                    ioexception.printStackTrace();
                }
            }
        }
        return jdbm2;
    }

    public static byte[] getBytes(String s)
    {
        byte abyte0[] = new byte[s.length()];
        s.getBytes(0, abyte0.length, abyte0, 0);
        return abyte0;
    }

    public static void main(String args[])
        throws Exception
    {
        File file1 = new File(args[0]);
        jdbm jdbm1 = new jdbm(file1);
        for(int i = 1; i < args.length; i++)
            if(args[i].equals("-clean"))
                jdbm1.reorganize(true);
            else
            if(args[i].equals("-stat"))
            {
                jdbm1.printHeader(System.out);
                jdbm1.printAvail(System.out);
            } else
            if(args[i].equals("-add"))
            {
                byte abyte0[] = getBytes(args[i + 1]);
                byte abyte2[] = getBytes(args[i + 2]);
                jdbm1.store(abyte0, abyte2, 2);
                i += 3;
            } else
            if(args[i].equals("-get"))
            {
                byte abyte1[] = getBytes(args[i + 1]);
                byte abyte3[] = jdbm1.lookup(abyte1);
                if(abyte3 == null)
                    System.out.println("not found.");
                else
                    System.out.println(new String(abyte3, 0, 0, abyte3.length));
                i += 2;
            } else
            if(args[i].equals("-nadd"))
            {
                int j = Integer.parseInt(args[i + 1]);
                String s = args[i + 2];
                while(--j >= 0) 
                {
                    String s2 = s + "-" + j;
                    String s4 = s + "-value-for-" + j;
                    System.out.println(s2 + "=" + s4);
                    jdbm1.store(getBytes(s2), getBytes(s4), 2);
                }
                i += 3;
            } else
            if(args[i].equals("-nget"))
            {
                int k = Integer.parseInt(args[i + 1]);
                String s1 = args[i + 2];
                while(--k >= 0) 
                {
                    String s3 = s1 + "-" + k;
                    byte abyte4[] = jdbm1.lookup(getBytes(s3));
                    if(abyte4 == null)
                        System.out.println("*** not found.");
                    else
                        System.out.println(s3 + "=" + new String(abyte4, 0, 0, abyte4.length));
                }
                i += 3;
            } else
            if(args[i].equals("-del"))
            {
                if(jdbm1.delete(getBytes(args[i + 1])))
                    System.out.println("deletion succesfull.");
                else
                    System.out.println("element not found.");
                i += 2;
            } else
            {
                System.out.println("[-add <key> <val>] [-get <key>]");
                System.exit(1);
            }

        jdbm1.save();
    }

    private static final int IGNORE_SIZE = 8;
    private static final boolean debug = false;
    public static final int STORE_REPLACE = 1;
    public static final int STORE_INSERT = 2;
    protected static final int BLOCK_SIZE = 1024;
    protected static final int DIR_BITS = 3;
    protected static final int CACHE_SIZE = 32;
    private static final int fsize = 36;
    int block_size;
    int dir_bits;
    int dir_size;
    int dir_adr;
    int cache_size;
    int bucket_elems;
    int next_block;
    int avail_count;
    int avail_length;
    int avail_size[];
    int avail_ptr[];
    File file;
    RandomAccessFile fd;
    int diridx[];
    private byte buffer[];
    private boolean dir_changed;
    private boolean header_changed;
    private LRUList list;
    private int loaded_buckets;
}