Begin Implementation of Cache

src/main/java/us/harward/commons/cache/Cache.java

@@ -0,0 +1,10 @@
+package us.harward.commons.cache;
+
+public interface Cache<K, V> {
+
+    void put(final K key, final V value);
+
+    V get(final K key);
+
+    V remove(final K key);
+}

src/main/java/us/harward/commons/cache/TTLCache.java

@@ -0,0 +1,59 @@
+package us.harward.commons.cache;
+
+public class TTLCache<K, V> implements Cache<K, V> {
+
+    private final Cache<K, TTLCache.TTLEntry<V>> cache;
+    private final long                           defaultTTLMillis;
+
+    public TTLCache(final long defaultTTLMillis, final Cache<K, TTLCache.TTLEntry<V>> cache) {
+        this.cache = cache;
+        this.defaultTTLMillis = defaultTTLMillis;
+    }
+
+    @Override
+    public void put(final K key, final V value) {
+        final TTLEntry<V> e = new TTLEntry<V>(value, System.currentTimeMillis() + defaultTTLMillis);
+        cache.put(key, e);
+    }
+
+    public void put(final K key, final V value, final long ttlMillis) {
+        final TTLEntry<V> e = new TTLEntry<V>(value, System.currentTimeMillis() + ttlMillis);
+        cache.put(key, e);
+    }
+
+    @Override
+    public V get(final K key) {
+        final TTLEntry<V> e = cache.get(key);
+        return e != null && e.isValid() ? e.getValue() : null;
+    }
+
+    @Override
+    public V remove(K key) {
+        final TTLEntry<V> e = cache.remove(key);
+        return e != null && e.isValid() ? e.getValue() : null;
+    }
+
+    public static class TTLEntry<V> {
+
+        private final V    value;
+        private final long expireMillis;
+
+        public TTLEntry(final V value, final long expireMillis) {
+            this.value = value;
+            this.expireMillis = expireMillis;
+        }
+
+        public V getValue() {
+            return value;
+        }
+
+        public long getExpireMillis() {
+            return expireMillis;
+        }
+
+        public boolean isValid() {
+            return expireMillis >= System.currentTimeMillis();
+        }
+    }
+
+}

src/main/java/us/harward/commons/cache/heap/HeapCache.java

@@ -0,0 +1,97 @@
+package us.harward.commons.cache.heap;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import us.harward.commons.cache.Cache;
+
+/**
+ * Enforces maximum number of entries
+ * 
+ * @author alex
+ * @param <K>
+ * @param <V>
+ */
+public class HeapCache<K, V> implements Cache<K, V> {
+
+    private final int                            maxSize;
+    private final ConcurrentHashMap<K, Entry<V>> map = new ConcurrentHashMap<K, Entry<V>>();
+
+    public HeapCache(int maxSize) {
+        super();
+        this.maxSize = maxSize;
+    }
+
+    @Override
+    public void put(K key, V value) {
+        final Entry<V> e = new Entry<V>(value);
+        map.put(key, e);
+        if (map.size() > maxSize) {
+            purge();
+        }
+    }
+
+    private void purge() {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public V get(K key) {
+        final Entry<V> e = map.get(key);
+        if (e == null) {
+            return null;
+        } else {
+            e.recordHit();
+            return e.getValue();
+        }
+    }
+
+    @Override
+    public V remove(K key) {
+        Entry<V> e = map.remove(key);
+        return e == null ? null : e.getValue();
+    }
+
+    private static class Entry<V> {
+
+        private final V    value;
+        private final long createMillis;
+        private long       accessMillis;
+        private long       hitCount;
+
+        protected Entry(final V value) {
+            this(value, System.currentTimeMillis(), 0, 0);
+        }
+
+        protected Entry(V value, long createMillis, long accessMillis, long hitCount) {
+            this.value = value;
+            this.createMillis = createMillis;
+            this.accessMillis = accessMillis;
+            this.hitCount = hitCount;
+        }
+
+        public void recordHit() {
+            synchronized (this) {
+                accessMillis = System.currentTimeMillis();
+                hitCount++;
+            }
+        }
+
+        public V getValue() {
+            return value;
+        }
+
+        public long getCreateMillis() {
+            return createMillis;
+        }
+
+        public long getAccessMillis() {
+            return accessMillis;
+        }
+
+        public long getHitCount() {
+            return hitCount;
+        }
+
+    }
+
+}

src/main/java/us/harward/commons/cache/heap/SoftRefHeapCache.java

@@ -0,0 +1,32 @@
+package us.harward.commons.cache.heap;
+
+import java.lang.ref.SoftReference;
+
+import us.harward.commons.cache.Cache;
+
+public class SoftRefHeapCache<K, V> implements Cache<K, V> {
+
+    private final HeapCache<K, SoftReference<V>> cache;
+
+    public SoftRefHeapCache(final int maxSize) {
+        this.cache = new HeapCache<K, SoftReference<V>>(maxSize);
+    }
+
+    @Override
+    public void put(K key, V value) {
+        cache.put(key, new SoftReference<V>(value));
+    }
+
+    @Override
+    public V get(K key) {
+        final SoftReference<V> ref = cache.get(key);
+        return ref == null ? null : ref.get();
+    }
+
+    @Override
+    public V remove(K key) {
+        final SoftReference<V> ref = cache.remove(key);
+        return ref == null ? null : ref.get();
+    }
+
+}