code cleanup

Author: chaosfox

nbproject/project.properties

@@ -30,12 +30,12 @@ includes=**
 jar.compress=false
 javac.classpath=
 # Space-separated list of extra javac options
-javac.compilerargs=
+javac.compilerargs=-Xlint
 javac.deprecation=false
 javac.processorpath=\
     ${javac.classpath}
-javac.source=1.5
-javac.target=1.5
+javac.source=1.6
+javac.target=1.6
 javac.test.classpath=\
     ${javac.classpath}:\
     ${build.classes.dir}:\

src/org/voile/MemoryPool.java

@@ -12,16 +12,16 @@ public class MemoryPool {
     private final TreeSet<Block> freeSpace;
 
     private int limit;
-    private final boolean growable;
+    private final boolean canGrow;
 
     /** creates a new pool of space
      * @param offset where to start the count
      * @param length the size of the pool
-     * @param growable grow as needed when allocate
+     * @param canGrow grow as needed when allocate
      */
-    public MemoryPool(int offset, int length, boolean growable) {
+    public MemoryPool(int offset, int length, boolean canGrow) {
         this.limit = length;
-        this.growable = growable;
+        this.canGrow = canGrow;
 
         freeSpace = new TreeSet<Block>();
         free(new Block(offset, limit-offset));
@@ -38,7 +38,7 @@ public Block allocate(int size) {
         Block b = findFreeBlock(size);
 
         if (b == null) {
-            if (!growable) return null;
+            if (!canGrow) return null;
 
             // create more space
             free(new Block(limit, size));
@@ -54,7 +54,7 @@ public Block allocate(int size) {
      * @return whether it have the block
      */
     public boolean checkSpace(int size) {
-        if (growable) return true;
+        if (canGrow) return true;
 
         Block b = findFreeBlock(size);
         return b != null;
@@ -69,9 +69,13 @@ public boolean checkSpace(int size) {
      */
     private Block checkout(Block b, int size) {
         freeSpace.remove(b);
-        Block nb = b.split(size);
-        if(b.length>0)freeSpace.add(b);
-        return nb;
+
+        // split b size bytes
+        Block [] ab = Block.splitBlock(b, size);
+        
+        // if there is extra space, add it back
+        if(ab[1].length>0)freeSpace.add(ab[1]);
+        return ab[0];
     }
 
     /** 
@@ -81,7 +85,7 @@ private Block checkout(Block b, int size) {
      */
     private Block findFreeBlock(int size) {
 
-        // iterate in order min~max
+        // iteration is ordered min ~ max
         for (Block b : freeSpace) {
             if (b.length >= size) 
                 return b;
@@ -117,37 +121,41 @@ public void free(Block b) {
 
         if (b.start + b.length > limit) limit = b.start + b.length; // grows with free
 
+        // query adjacent blocks
         Block prev = freeSpace.floor(b);
         Block next = freeSpace.higher(b);
 
         if (prev != null && prev.start + prev.length > b.start) {
-            new RuntimeException("DEBUG PRV " + prev.start + "+" + prev.length + ">" + b.start).printStackTrace();
-            System.exit(1);
+            throw new RuntimeException("Corrupted. DEBUG PRV " + prev.start + "+" + prev.length + ">" + b.start);
         }
         if (next != null && next.start < b.start + b.length) {
-            new RuntimeException("DEBUG NEX " + next.start + "<" + b.start + "+" + b.length).printStackTrace();
-            System.exit(1);
+            throw new RuntimeException("Corrupted. DEBUG NEX " + next.start + "<" + b.start + "+" + b.length);
         }
 
-        if(b.merge(prev))freeSpace.remove(prev);
-        if(b.merge(next))freeSpace.remove(next);
+        // merge them if possible
+        
+        Block n = Block.mergeBlocks(b, prev);
+        if(n != null) { freeSpace.remove(prev); b = n; }
+
+        n = Block.mergeBlocks(b, next);
+        if(n != null) { freeSpace.remove(next); b = n; }
 
         freeSpace.add(b);
     }
 
     @Override
     public String toString() {
-        String s = "";
+        StringBuilder sb = new StringBuilder();
         for (Block b : freeSpace) {
-            s += "BLOCK [" + b.start + "] ~ " + b.length + "\n";
+            sb.append(b).append("\n");
         }
-        return s;
+        return sb.toString();
     }
 
     public static class Block implements Comparable<Block> {
 
-        int start;
-        int length;
+        final int start;
+        final int length;
 
         public Block(int start, int length) {
             this.start = start;
@@ -173,26 +181,46 @@ public int hashCode() {
             hash = 53 * hash + this.length;
             return hash;
         }
-        public boolean merge(Block b) {
-            if(b == null)return false;
+
+        @Override
+        public String toString() {
+            return "BLOCK["+start+":"+length+"]";
+        }
+
+        /**
+         * merge 2 blocks into one IF their positions
+         * are adjacent to each other, otherwise NULL
+         * @param a block to merge
+         * @param b another block to merge
+         * @return merged block or NULL if merge is not possible
+         */
+        public static Block mergeBlocks(Block a, Block b) {
+            if(a == null || b == null)return null;
+
             // left merge
-            if(b.start + b.length == this.start) {
-                this.start = b.start;
-                this.length += b.length;
-                return true;
+            if(b.start + b.length == a.start) {
+                return new Block(b.start, a.length + b.length);
             }
+
             // right merge
-            if (b.start == this.start + this.length) {
-                this.length += b.length;
-                return true;
+            if (b.start == a.start + a.length) {
+                return new Block(a.start, a.length + b.length);
             }
-            return false;
+            return null;
         }
-        public Block split(int size) {
-            Block b = new Block(this.start, size);
-            this.start += size;
-            this.length -= size;
-            return b;
+
+        /**
+         * split a block into
+         *   a block with size bytes from the start of the original
+         *   a block with the extra bytes from the original
+         * @param b the original block
+         * @param size to split the first block
+         * @return an array with the 2 new blocks
+         */
+        public static Block[] splitBlock(Block b, int size) {
+            Block nb = new Block(b.start, size);
+            b = new Block(b.start + size, b.length - size);
+            return new Block[]{nb, b};
         }
     }
 }

src/org/voile/VoileFile.java

@@ -1,9 +1,22 @@
 package org.voile;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.RandomAccessFile;
+import java.io.Serializable;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
 import org.voile.MemoryPool.Block;
 
 /**
@@ -12,9 +25,9 @@
 public class VoileFile<K extends Serializable, V extends Serializable> {
 
     private static final int INT_SIZE = Integer.SIZE / Byte.SIZE;
-    private static final int INDEX_ENTRY_SIZE = INT_SIZE + INT_SIZE + INT_SIZE;
+    private static final int INDEX_ENTRY_SIZE = 3 * INT_SIZE;
 
-    private static final int INDEX_START = INT_SIZE + INT_SIZE;
+    private static final int INDEX_START = 2 * INT_SIZE;
 
     private static final Comparator<Entry> dataPointerComparator = new Comparator<Entry>() {
         @Override
@@ -43,11 +56,13 @@ public VoileFile(File f) throws IOException {
             updateMainHeader();
         }
         else {
+            // read existing file
             final int numEntries = file.readInt();
             final int dataStartPointer = file.readInt();
 
             ArrayList<Entry> entry_list = new ArrayList<Entry>(numEntries);
 
+            // read index, numEntries x (dataPointer, dataLength, keySize) 
             for (int i = 0; i < numEntries; i++) {
                 Block header = new Block((int) file.getFilePointer(), INDEX_ENTRY_SIZE);
                 Block data = new Block(file.readInt(), file.readInt());
@@ -65,6 +80,8 @@ public VoileFile(File f) throws IOException {
             int end = (int) file.length();
             dataSpace = new MemoryPool(end, end, true);
 
+            // re-construct the free space pool based on the
+            // holes missing between the index entries
             Collections.sort(entry_list, dataPointerComparator);
             int d_pos = dataStartPointer;
             for (Entry e : entry_list) {
@@ -92,30 +109,34 @@ public V put(K key, V value) throws IOException {
         Entry e = index.get(key);
         ByteBuffer key_data = object2bin(key);
         ByteBuffer value_data = object2bin(value);
-        System.err.println("put key[" + key + "] [" + value + "]");
-        V old_value = null;
 
-        if (e != null) { // update
+        Logger.getLogger(this.getClass().getName()).log(Level.INFO, "put key[{0}] [{1}]", new Object[]{key, value});
 
-            //noinspection unchecked
-            old_value = (V) bin2object(readValue(e));
+        V old_value = null;
 
-            // we got enough space to update ?
+        // if there's already a entry at this key
+        if (e != null) {
+
+            // if we got enough space, update
             if (value_data.remaining() + e.keySize <= e.data.length) {
 
-                // split the block
-                Block nb = e.data.split(value_data.remaining() + e.keySize);
+                //noinspection unchecked
+                old_value = (V) bin2object(readValue(e)); // get old value first
+
+                // split the data block
+                Block[] split_block = Block.splitBlock(e.data, value_data.remaining() + e.keySize);
 
-                dataSpace.free(e.data); // free old
-                e.data = nb; // store new block
-                
+                dataSpace.free(split_block[1]); // free extra space
+                e.data = split_block[0]; // store new block
+
+                // write new data
                 chan.write(value_data, e.data.start + e.keySize);
                 writeEntry(e);
+
                 return old_value;
             }
-            // else, need remove-insert again
-            System.err.print("put--");
-            remove(key);
+            // else, we need to remove and then insert again
+            old_value = remove(key);
         }
         // insert new
 
@@ -148,7 +169,7 @@ public V remove(K key) throws IOException {
         final Entry e = index.get(key);
         if (e == null) return null;
 
-        System.err.println("remove [" + key + "]");
+        Logger.getLogger(this.getClass().getName()).log(Level.INFO, "remove [{0}]", key);
 
         @SuppressWarnings({"unchecked"})
         V old_value = (V) bin2object(readValue(e));
@@ -186,6 +207,7 @@ private void removeEntry(Entry e) throws IOException {
         headerSpace.free(last_p);
     }
 
+
     private void updateMainHeader() throws IOException {
         file.seek(0);
         file.writeInt(index.size());
@@ -199,33 +221,26 @@ private Entry allocate(int keySize, int valueSize) throws IOException {
         freeHeaderSpace();
         Block header = headerSpace.allocate(INDEX_ENTRY_SIZE);
         Block data = dataSpace.allocate(size);
-        Entry e = new Entry(header, data, keySize);
-        //e.header = header;
-        //e.data = data;
-        return e;
+        return new Entry(header, data, keySize);
     }
 
     private void freeHeaderSpace() throws IOException {
         while (!headerSpace.checkSpace(INDEX_ENTRY_SIZE)) {
             Entry f = findBlockAt(headerSpace.getLimit());
 
             if (f == null) { // freed maybe ?
-                System.err.println(dataSpace);
-                System.err.println(headerSpace);
                 Block b = dataSpace.allocateAt(headerSpace.getLimit());
 
                 if (b != null) {
                     headerSpace.free(b); // pass the space to the header
-                    System.err.println("found on data " + b);
                     continue;
                 } else {
-                    throw new IOException("LOL ");
+                    throw new IOException("Corrupted: Couldn't get extra space for the header.");
                 }
             }
 
             // find a new place to the data
             Block data = dataSpace.allocate(f.data.length);
-            int dp = data.start;
 
             // read the data
             ByteBuffer key_data = readKey(f);
@@ -243,9 +258,7 @@ private void freeHeaderSpace() throws IOException {
     }
 
     private Entry findBlockAt(int targetFp) {
-        System.err.println("target " + targetFp);
         for (Entry e : index.values()) {
-            System.err.println(e.data.start + " " + e.data.length);
             if (e.data.start == targetFp) return e;
         }
         return null;
@@ -277,12 +290,12 @@ private ByteBuffer readValue(Entry e) throws IOException {
         return value_data;
     }
 
-    private ByteBuffer object2bin(Serializable o) {
+    private ByteBuffer object2bin(Serializable o) throws IOException {
         ByteArrayOutputStream bao = new ByteArrayOutputStream();
         try {
             new ObjectOutputStream(bao).writeObject(o);
-        } catch (IOException ignored) {
-            return null;
+        } catch (IOException ex) {
+            throw ex;
         }
         return ByteBuffer.wrap(bao.toByteArray());
     }
@@ -292,10 +305,9 @@ private Serializable bin2object(ByteBuffer blob) throws IOException {
 
         try {
             return (Serializable) new ObjectInputStream(new ByteBufferInputStream(blob)).readObject();
-        } catch (ClassNotFoundException ignored) {
-            ignored.printStackTrace(); //TODO: is this a problem ?
+        } catch (ClassNotFoundException cnfe) {
+            throw new RuntimeException(cnfe);
         }
-        return null;
     }
 
     static class Entry {