added new objectMap (can replace HashMap and should use less memory, …

…but is slower)

git-svn-id: https://svn.berlios.de/svnroot/repos/yacy/trunk@2211 6c8d7289-2bf4-0310-a012-ef5d649a1542

source/de/anomic/kelondro/kelondroCollection.java

@@ -196,6 +196,13 @@ public void removeAll(kelondroCollection c) {
         }
     }
 
+    public void removeOne() {
+        if (chunkcount == 0) return;
+        if (chunkcount == sortbound) sortbound--;
+        chunkcount--;
+        this.lastTimeWrote = System.currentTimeMillis();
+    }
+
     public void clear() {
         this.chunkcount = 0;
         this.chunkcache = new byte[0];
@@ -257,8 +264,7 @@ protected int find(byte[] a, int length) {
         if (this.order == null) return iterativeSearch(a, length);
 
         // check if a re-sorting make sense
-        if (this.chunkcount - this.sortbound > 1200) sort(Math.min(a.length, this.chunksize));
-        //if ((this.chunkcount - this.sortbound) / (this.chunkcount + 1) * 100 > 20) sort();
+        if ((this.chunkcount - this.sortbound) > 90) sort(Math.min(a.length, this.chunksize));
 
         // first try to find in sorted area
         int p = binarySearch(a, length);
@@ -315,7 +321,7 @@ public void sort(kelondroOrder newOrder, int keylen) {
     public void sort(int keylen) {
         assert (this.order != null);
         if (this.sortbound == this.chunkcount) return; // this is already sorted
-        //System.out.println("SORT");
+        //System.out.println("SORT(chunkcount=" + this.chunkcount + ", sortbound=" + this.sortbound + ")");
         if (this.sortbound > 1) {
             qsort(keylen, 0, this.sortbound, this.chunkcount);
         } else {

source/de/anomic/kelondro/kelondroCollectionIntMap.java

@@ -64,7 +64,7 @@ public synchronized int puti(byte[] key, int i) {
             return oldi;
         }
     }
-
+    
     public synchronized int geti(byte[] key) {
         int index = -1;
         synchronized (chunkcache) {
@@ -87,4 +87,9 @@ public synchronized int removei(byte[] key) {
             return (int) indexentry.getColLongB256(1);
         }
     }
+
+    public static void main(String[] args) {
+
+    }
+
 }

source/de/anomic/kelondro/kelondroCollectionObjectMap.java

@@ -0,0 +1,82 @@
+// kelondroCollectionObjectMap.java
+// (C) 2006 by Michael Peter Christen; mc@anomic.de, Frankfurt a. M., Germany
+// first published 08.06.2006 on http://www.anomic.de
+//
+// $LastChangedDate: 2006-04-02 22:40:07 +0200 (So, 02 Apr 2006) $
+// $LastChangedRevision: 1986 $
+// $LastChangedBy: orbiter $
+//
+// LICENSE
+// 
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+package de.anomic.kelondro;
+
+public class kelondroCollectionObjectMap extends kelondroCollection {
+
+    // use this only, if key objects can ensure perfect hashing!
+    // (that means, the hash computation must be unique)
+    // this is given for kelondroRecords.Entry objects
+
+    private kelondroRow indexrow;
+
+    public kelondroCollectionObjectMap(int payloadSize, int objectCount) {
+        super(4 + payloadSize, objectCount);
+
+        // initialize row
+        this.indexrow = new kelondroRow(new int[]{4, payloadSize});
+    }
+
+    public byte[] get(Object key) {
+        kelondroRow.Entry indexentry = indexrow.newEntry(super.get(objKey2byteKey(key)));
+        if (indexentry == null) return null;
+        return indexentry.getColBytes(1);
+    }
+
+    public byte[] put(Object obj, byte[] value) {
+        int index = -1;
+        byte[] key = objKey2byteKey(obj);
+        //System.out.println("ObjectMap PUT " + obj.hashCode() + ", size=" + size());
+        synchronized (chunkcache) {
+            index = find(key, 4);
+        }
+        if (index < 0) {
+            kelondroRow.Entry indexentry = indexrow.newEntry();
+            indexentry.setCol(0, key);
+            indexentry.setCol(1, value);
+            add(indexentry.bytes());
+            return null;
+        } else {
+            kelondroRow.Entry indexentry = indexrow.newEntry(get(index));
+            byte[] old = indexentry.getColBytes(1);
+            indexentry.setCol(1, value);
+            set(index, indexentry.bytes());
+            return old;
+        }
+    }
+
+    public byte[] remove(Object key) {
+        kelondroRow.Entry indexentry = indexrow.newEntry(super.remove(objKey2byteKey(key)));
+        if (indexentry == null) return null;
+        return indexentry.getColBytes(1);
+    }
+
+    private byte[] objKey2byteKey(Object obj) {
+        int i = obj.hashCode();
+        byte[] b = kelondroNaturalOrder.encodeLong((long) i, 4);
+        return b;
+    }
+
+}