[Mulgara-svn] r771 - projects/xa2/object-pool/src

[andrae at mulgara.org]

Author: andrae
Date: 2008-04-10 21:52:20 -0700 (Thu, 10 Apr 2008)
New Revision: 771

Modified:
   projects/xa2/object-pool/src/MemoryTrie.java
   projects/xa2/object-pool/src/MemoryTrieTest.java
Log:
Converted Trie from String->long to byte[]->long.


Modified: projects/xa2/object-pool/src/MemoryTrie.java
===================================================================
--- projects/xa2/object-pool/src/MemoryTrie.java	2008-04-11 03:10:23 UTC (rev 770)
+++ projects/xa2/object-pool/src/MemoryTrie.java	2008-04-11 04:52:20 UTC (rev 771)
@@ -21,7 +21,7 @@
     this.root = null;
   }
 
-  public void insert(String key, long value) {
+  public void insert(byte[] key, long value) {
     if (root == null) {
       root = new TrieBranch(key, value);
     } else {
@@ -33,7 +33,7 @@
     }
   }
 
-  public long lookup(String key) throws NotFound {
+  public long lookup(byte[] key) throws NotFound {
     if (root == null) {
       throw new NotFound();
     }
@@ -71,15 +71,15 @@
     private Map<Byte, TrieNode> children;
     private TrieLeaf term;
 
-    public TrieBranch(String str, long value) {
+    public TrieBranch(byte[] key, long value) {
       super();
       this.children = new HashMap<Byte, TrieNode>();
-      this.term = new TrieLeaf(str, value);
+      this.term = new TrieLeaf(key, value);
       this.offset = term.key.length;
       this.least = this.term;
     }
 
-    public TrieBranch(TrieBranch oldRoot, String key, long value) {
+    public TrieBranch(TrieBranch oldRoot, byte[] key, long value) {
       this(oldRoot, new TrieLeaf(key, value));
     }
 
@@ -129,12 +129,12 @@
       }
     }
 
-    public void insert(String str, long value) throws InsertAbove {
-      insert(new TrieLeaf(str, value), 0);
+    public void insert(byte[] key, long value) throws InsertAbove {
+      insert(new TrieLeaf(key, value), 0);
     }
 
-    public long lookup(String str) throws NotFound {
-      return lookup(str.getBytes(), 0);
+    public long lookup(byte[] key) throws NotFound {
+      return lookup(key, 0);
     }
 
     protected void insert(TrieLeaf node, int parentLcp) throws InsertAbove {
@@ -201,9 +201,10 @@
     final byte[] key;
     final long value;
 
-    public TrieLeaf(String key, long value) {
+    public TrieLeaf(byte[] key, long value) {
       super();
-      this.key = key.getBytes();
+      this.key = new byte[key.length];
+      System.arraycopy(key, 0, this.key, 0, key.length);
       this.value = value;
       this.least = this;
     }

Modified: projects/xa2/object-pool/src/MemoryTrieTest.java
===================================================================
--- projects/xa2/object-pool/src/MemoryTrieTest.java	2008-04-11 03:10:23 UTC (rev 770)
+++ projects/xa2/object-pool/src/MemoryTrieTest.java	2008-04-11 04:52:20 UTC (rev 771)
@@ -22,7 +22,7 @@
   }
 
   public static void testWithFile(File file) throws Exception {
-    Map<String, Long> namesMap = new HashMap<String, Long>();
+    Map<byte[], Long> namesMap = new HashMap<byte[], Long>();
     MemoryTrie namesTrie = new MemoryTrie();
 
     System.out.println("Inserting lines from " + file);
@@ -30,15 +30,15 @@
     long n = 0;
     String name = names.readLine();
     while (name != null) {
-      namesMap.put(name, n);
-      namesTrie.insert(name, n);
+      namesMap.put(name.getBytes(), n);
+      namesTrie.insert(name.getBytes(), n);
       name = names.readLine();
       n++;
     }
     names.close();
 
     System.out.println("Checking lines from " + file);
-    for (String key : namesMap.keySet()) {
+    for (byte[] key : namesMap.keySet()) {
       if (namesTrie.lookup(key) != namesMap.get(key)) {
         throw new IllegalStateException("Trie doesn't match Map");
       }
@@ -46,4 +46,47 @@
     
     System.out.println("Test Succeeded with " + file);
   }
+/*
+  public static void testWithRandomFile(File file) throws Exception {
+    Map<byte[], Long> namesMap = new HashMap<byte[], Long[]>();
+    MemoryTrie namesTrie = new MemoryTrie();
+
+    System.out.println("Inserting random bytes from " + file);
+    FileChannel chan = new FileInputStream(file).getChannel();
+    ByteBuffer buffer = ByteBuffer.allocate(134*1024).clear().limit(0);
+    // Set limit to 0 so initial compact works correctly.
+
+    long n = 0;
+    byte[] key;
+    while (n < 5000) {
+      if (buffer.hasRemaining() < 67*1024 && chan.read(buffer.compact()) == -1) {
+        break;
+      }
+      buffer.flip();
+
+      key = new byte[buffer.getShort()];
+      buffer.get(key);
+      namesMap.put(key, n++);
+      namesTrie.insert(key, n);
+
+      for (i = 0; i < 10; i++) {
+        key = new byte[buffer.getByte()];
+        buffer.get(key);
+        namesMap.put(key, n++);
+        namesTrie.insert(key, n);
+      }
+    }
+    chan.close();
+
+    System.out.println("Checking random bytes from " + file);
+    for (byte[] key : namesMap.keySet()) {
+      if (namesTrie.lookup(key) != namesMap.get(key)) {
+        throw new IllegalStateException("Trie doesn't match Map");
+      }
+    }
+    
+    System.out.println("Test Succeeded with " + file);
+  }
+  */
+
 }