Merge of trunk version 9-19

Cache.java

@@ -0,0 +1,114 @@
+import java.util.HashMap;
+
+public class Cache<K, V>
+{
+	private final int size;
+	private int len;
+
+	private CacheNode head;
+	private CacheNode tail;
+
+	private class CacheNode
+	{
+		public CacheNode prev;
+		public CacheNode next;
+		public K key;
+		public V value;
+
+		public CacheNode(K key, V value)
+		{
+			this.key = key;
+			this.value = value;
+			prev = null;
+			next = null;
+		}
+
+		public void unlink()
+		{
+			if(prev == null) {
+				head = next;
+			} else {
+				prev.next = next;
+			}
+
+			if(next == null) {
+				tail = prev;
+			} else {
+				next.prev = prev;
+			}
+
+			prev = null;
+			next = null;
+
+			len --;
+		}
+
+		public void append()
+		{
+			if(tail == null) {
+				head = this;
+				tail = this;
+			} else {
+				tail.next = this;
+				prev = tail;
+				tail = this;
+			}
+
+			len ++;
+		}
+	}
+
+	private HashMap<K, CacheNode> map;
+
+	public Cache(int size)
+	{
+		this.size = size;
+		len = 0;
+
+		head = null;
+		tail = null;
+
+		map = new HashMap<K, CacheNode>();
+	}
+
+	/* returns value for key, if key exists in the cache
+	 * otherwise null */
+	public V get(K key)
+	{
+		CacheNode n = map.get(key);
+		if(n == null)
+			return null;
+		return n.value;
+	}
+
+	/* puts a new key-value pair in the cache
+	 * if the key existed already, the value is updated, and the old value is returned
+	 * if the key didn't exist, it is added; the oldest value (now pushed out of the
+	 * cache) may be returned, or null if the cache isn't yet full */
+	public V put(K key, V value)
+	{
+		CacheNode n = map.get(key);
+		if(n == null) {
+			V ret = null;
+
+			if(len >= size) {
+				CacheNode first = head;
+				first.unlink();
+				map.remove(first.key);
+				ret = first.value;
+			}
+
+			CacheNode add = new CacheNode(key, value);
+			add.append();
+			map.put(key, add);
+
+			return ret;
+		} else {
+			n.unlink();
+			V old = n.value;
+			n.value = value;
+			n.append();
+			return old;
+		}
+	}
+}