From 0ec8481c10cd8277d84c7c1a785483a0a739e5a0 Mon Sep 17 00:00:00 2001
From: abranson <andrew.branson@cern.ch>
Date: Thu, 4 Aug 2011 00:42:34 +0200
Subject: More code cleanup: Refactored Entity Proxy Subscription to handle
 generics better Rewrote RemoteMap to use TreeMap instead of the internal
 array for order. It now sorts its keys by number if they parse, else as
 strings. Removed a no-longer-in-progress outcome form class

---
 source/com/c2kernel/utils/TransientCache.java | 66 +++++++++++++++++----------
 1 file changed, 41 insertions(+), 25 deletions(-)

(limited to 'source/com/c2kernel/utils/TransientCache.java')

diff --git a/source/com/c2kernel/utils/TransientCache.java b/source/com/c2kernel/utils/TransientCache.java
index 8991b87..d58617e 100644
--- a/source/com/c2kernel/utils/TransientCache.java
+++ b/source/com/c2kernel/utils/TransientCache.java
@@ -1,9 +1,14 @@
 
 package com.c2kernel.utils;
-import java.lang.ref.*;
-import java.util.*;
+import java.lang.ref.Reference;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
 /**************************************************************************
- * TransientCache - Uses transient references to allow unused entries to be 
+ * TransientCache - Uses transient references to allow unused entries to be
  * reaped by the java garbage collector.
  *
  * $Revision: 1.1 $
@@ -13,10 +18,11 @@ import java.util.*;
  * All rights reserved.
  **************************************************************************/
 public abstract class TransientCache<K, V> extends AbstractMap<K, V> {
-    
+
     private Map<K, Reference<V>> map = new Hashtable<K, Reference<V>>();
-    
-    public synchronized Set<Entry<K, V>> entrySet() {
+
+    @Override
+	public synchronized Set<Entry<K, V>> entrySet() {
         Map<K, V> newMap = new Hashtable<K,V>();
         Iterator<Entry<K, Reference<V>>> iter = map.entrySet().iterator();
         while (iter.hasNext()) {
@@ -24,28 +30,30 @@ public abstract class TransientCache<K, V> extends AbstractMap<K, V> {
             Reference<V> ref = me.getValue();
             V o = ref.get();
             if (o == null) {
-                // Delete cleared reference 
+                // Delete cleared reference
                 iter.remove();
             } else {
-                // Copy out interior object 
+                // Copy out interior object
                 newMap.put(me.getKey(), o);
             }
         }
-        // Return set of interior objects 
+        // Return set of interior objects
         return newMap.entrySet();
     }
-    
-    public synchronized V put(K key, V value) {
+
+    @Override
+	public synchronized V put(K key, V value) {
         Reference<V> ref = makeReference(value);
-        ref = (Reference<V>)map.put(key, ref);
+        ref = map.put(key, ref);
         if (ref != null)
             return (ref.get());
         return null;
     }
-    
+
     public abstract Reference<V> makeReference(Object value);
-    
-    public V remove(Object key) {
+
+    @Override
+	public V remove(Object key) {
         Iterator<Entry<K, Reference<V>>> i = map.entrySet().iterator();
         Entry<K, Reference<V>> correctEntry = null;
         if (key == null) {
@@ -72,38 +80,46 @@ public abstract class TransientCache<K, V> extends AbstractMap<K, V> {
     /**
      *
      */
-    public void clear() {
+    @Override
+	public void clear() {
         map.entrySet().clear();
     }
-    
+
     private transient Set<K> keySet = null;
-    
-    public Set<K> keySet() {
+
+    @Override
+	public Set<K> keySet() {
         if (keySet == null) {
             keySet = new AbstractSet<K>() {
-            public Iterator<K> iterator() {
+            @Override
+			public Iterator<K> iterator() {
                 return new Iterator<K>() {
                 private Iterator<Entry<K, Reference<V>>> i = map.entrySet().iterator();
 
-                public boolean hasNext() {
+                @Override
+				public boolean hasNext() {
                     return i.hasNext();
                 }
 
-                public K next() {
+                @Override
+				public K next() {
                     return i.next().getKey();
                 }
 
-                public void remove() {
+                @Override
+				public void remove() {
                     i.remove();
                 }
                         };
             }
 
-            public int size() {
+            @Override
+			public int size() {
                 return TransientCache.this.size();
             }
 
-            public boolean contains(Object k) {
+            @Override
+			public boolean contains(Object k) {
                 return TransientCache.this.containsKey(k);
             }
             };
-- 
cgit v1.2.3