You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
262 lines
8.9 KiB
262 lines
8.9 KiB
// kelondroRowBufferedSet.java
|
|
// (C) 2006 by Michael Peter Christen; mc@anomic.de, Frankfurt a. M., Germany
|
|
// first published 21.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;
|
|
|
|
import java.util.TreeMap;
|
|
import java.util.Map;
|
|
import java.util.Iterator;
|
|
import java.util.Random;
|
|
|
|
public class kelondroRowBufferedSet extends kelondroRowSet {
|
|
|
|
private static final int bufferFlushLimit = 10000;
|
|
private final boolean useRowCollection = true;
|
|
private TreeMap buffer; // this must be a TreeSet bacause HashMap does not work with byte[]
|
|
|
|
public kelondroRowBufferedSet(kelondroRow rowdef) {
|
|
super(rowdef);
|
|
buffer = new TreeMap(kelondroNaturalOrder.naturalOrder);
|
|
}
|
|
|
|
public kelondroRowBufferedSet(kelondroRow rowdef, int objectCount) {
|
|
super(rowdef, objectCount);
|
|
buffer = new TreeMap(kelondroNaturalOrder.naturalOrder);
|
|
}
|
|
|
|
private final void flush() {
|
|
// call only in synchronized environment
|
|
Iterator i = buffer.entrySet().iterator();
|
|
Map.Entry entry;
|
|
while (i.hasNext()) {
|
|
entry = (Map.Entry) i.next();
|
|
super.add((kelondroRow.Entry) entry.getValue());
|
|
}
|
|
buffer.clear();
|
|
}
|
|
|
|
public final void trim() {
|
|
synchronized (buffer) {
|
|
flush();
|
|
super.trim();
|
|
}
|
|
}
|
|
|
|
public void removeOne() {
|
|
synchronized (buffer) {
|
|
if (buffer.size() == 0) {
|
|
super.removeOne();
|
|
} else {
|
|
buffer.remove(buffer.keySet().iterator().next());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void clear() {
|
|
synchronized (buffer) {
|
|
super.clear();
|
|
buffer.clear();
|
|
}
|
|
}
|
|
|
|
public int size() {
|
|
synchronized (buffer) {
|
|
return buffer.size() + super.size();
|
|
}
|
|
}
|
|
|
|
public Iterator elements() {
|
|
synchronized (buffer) {
|
|
flush();
|
|
}
|
|
return super.elements();
|
|
}
|
|
|
|
public void uniq() {
|
|
synchronized (buffer) {
|
|
flush();
|
|
super.uniq();
|
|
}
|
|
}
|
|
|
|
public String toString() {
|
|
synchronized (buffer) {
|
|
flush();
|
|
return super.toString();
|
|
}
|
|
}
|
|
|
|
public byte[] toByteArray() {
|
|
synchronized (buffer) {
|
|
flush();
|
|
return super.toByteArray();
|
|
}
|
|
}
|
|
|
|
public void add(byte[] a) {
|
|
this.add(super.rowdef.newEntry(a));
|
|
}
|
|
|
|
public void add(kelondroRow.Entry a) {
|
|
this.put(a);
|
|
}
|
|
|
|
public kelondroRow.Entry get(byte[] key) {
|
|
synchronized (buffer) {
|
|
if (useRowCollection) {
|
|
kelondroRow.Entry entry = (kelondroRow.Entry) buffer.get(key);
|
|
if (entry != null) return entry;
|
|
return super.get(key);
|
|
} else {
|
|
return (kelondroRow.Entry) buffer.get(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
public kelondroRow.Entry put(kelondroRow.Entry newentry) {
|
|
byte[] key = newentry.getColBytes(super.sortColumn);
|
|
synchronized (buffer) {
|
|
if (useRowCollection) {
|
|
kelondroRow.Entry oldentry = (kelondroRow.Entry) buffer.get(key);
|
|
if (oldentry == null) {
|
|
// try the collection
|
|
oldentry = super.get(key);
|
|
if (oldentry == null) {
|
|
// this was not anywhere
|
|
buffer.put(key, newentry);
|
|
if (buffer.size() > bufferFlushLimit) flush();
|
|
return null;
|
|
} else {
|
|
// replace old entry
|
|
super.put(newentry);
|
|
return oldentry;
|
|
}
|
|
} else {
|
|
// the entry is already in buffer
|
|
// simply replace old entry
|
|
buffer.put(key, newentry);
|
|
return oldentry;
|
|
}
|
|
} else {
|
|
return (kelondroRow.Entry) buffer.put(key, newentry);
|
|
}
|
|
}
|
|
}
|
|
|
|
public kelondroRow.Entry remove(byte[] a) {
|
|
synchronized (buffer) {
|
|
if (useRowCollection) {
|
|
kelondroRow.Entry oldentry = (kelondroRow.Entry) buffer.remove(a);
|
|
if (oldentry == null) {
|
|
// try the collection
|
|
return super.remove(a);
|
|
} else {
|
|
// the entry was in buffer
|
|
return oldentry;
|
|
}
|
|
} else {
|
|
return (kelondroRow.Entry) buffer.remove(a); // test
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeAll(kelondroRowCollection c) {
|
|
// this can be enhanced
|
|
synchronized (buffer) {
|
|
flush();
|
|
super.removeAll(c);
|
|
}
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
String[] test = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "zehn" };
|
|
kelondroRowBufferedSet c = new kelondroRowBufferedSet(new kelondroRow(new int[]{10, 3}));
|
|
c.setOrdering(kelondroNaturalOrder.naturalOrder, 0);
|
|
for (int i = 0; i < test.length; i++) c.add(test[i].getBytes());
|
|
for (int i = 0; i < test.length; i++) c.add(test[i].getBytes());
|
|
c.sort();
|
|
c.remove("fuenf".getBytes());
|
|
Iterator i = c.elements();
|
|
String s;
|
|
System.out.print("INPUT-ITERATOR: ");
|
|
while (i.hasNext()) {
|
|
s = new String((byte[]) i.next()).trim();
|
|
System.out.print(s + ", ");
|
|
if (s.equals("drei")) i.remove();
|
|
}
|
|
System.out.println("");
|
|
System.out.println("INPUT-TOSTRING: " + c.toString());
|
|
c.sort();
|
|
System.out.println("SORTED : " + c.toString());
|
|
c.uniq();
|
|
System.out.println("UNIQ : " + c.toString());
|
|
c.trim();
|
|
System.out.println("TRIM : " + c.toString());
|
|
|
|
// second test
|
|
c = new kelondroRowBufferedSet(new kelondroRow(new int[]{10, 3}));
|
|
c.setOrdering(kelondroNaturalOrder.naturalOrder, 0);
|
|
Random rand = new Random(0);
|
|
long start = System.currentTimeMillis();
|
|
long t, d = 0;
|
|
String w;
|
|
for (long k = 0; k < 60000; k++) {
|
|
t = System.currentTimeMillis();
|
|
w = "a" + Long.toString(rand.nextLong());
|
|
c.add(w.getBytes());
|
|
if (k % 10000 == 0)
|
|
System.out.println("added " + k + " entries in " +
|
|
((t - start) / 1000) + " seconds, " +
|
|
(((t - start) > 1000) ? (k / ((t - start) / 1000)) : k) +
|
|
" entries/second, size = " + c.size());
|
|
}
|
|
System.out.println("bevore sort: " + ((System.currentTimeMillis() - start) / 1000) + " seconds");
|
|
c.sort();
|
|
System.out.println("after sort: " + ((System.currentTimeMillis() - start) / 1000) + " seconds");
|
|
c.uniq();
|
|
System.out.println("after uniq: " + ((System.currentTimeMillis() - start) / 1000) + " seconds");
|
|
System.out.println("RESULT SIZE: " + c.size());
|
|
System.out.println();
|
|
|
|
// third test
|
|
c = new kelondroRowBufferedSet(new kelondroRow(new int[]{10, 3}), 60000);
|
|
c.setOrdering(kelondroNaturalOrder.naturalOrder, 0);
|
|
rand = new Random(0);
|
|
start = System.currentTimeMillis();
|
|
d = 0;
|
|
for (long k = 0; k < 60000; k++) {
|
|
t = System.currentTimeMillis();
|
|
w = "a" + Long.toString(rand.nextLong());
|
|
if (c.get(w.getBytes()) == null) c.add(w.getBytes()); else d++;
|
|
if (k % 10000 == 0)
|
|
System.out.println("added " + k + " entries in " +
|
|
((t - start) / 1000) + " seconds, " +
|
|
(((t - start) > 1000) ? (k / ((t - start) / 1000)) : k) +
|
|
" entries/second, " + d + " double, size = " + c.size() +
|
|
", sum = " + (c.size() + d));
|
|
}
|
|
System.out.println("RESULT SIZE: " + c.size());
|
|
}
|
|
}
|