Merge separate hashmaps for persistent cache into one

This isn’t type-safe, but re-using that same hashmap for both keys and
classloaders allows to reduce the number of members in Context. Also
we can re-use the same hashMap for other things as well in the coming
commits, e.g. timestamps.

5 files changed, 50 insertions, 51 deletions

diff --git a/nailgun_launcher/CbtURLClassLoader.java b/nailgun_launcher/CbtURLClassLoader.java
index 38fc905..e3d597e 100644
--- a/nailgun_launcher/CbtURLClassLoader.java
+++ b/nailgun_launcher/CbtURLClassLoader.java
@@ -15,10 +15,7 @@ public class CbtURLClassLoader extends java.net.URLClassLoader{
       + "\n)"
     );
   }
-  ClassLoaderCache2<Class> cache = new ClassLoaderCache2<Class>(
-    new ConcurrentHashMap<String, Object>(),
-    new ConcurrentHashMap<Object, Class>()
-  );
+  JavaCache<Class> cache = new JavaCache<Class>( new ConcurrentHashMap<Object,Object>() );
   public Class loadClass(String name) throws ClassNotFoundException{
     Class _class = super.loadClass(name);
     if(_class == null) throw new ClassNotFoundException(name);
diff --git a/nailgun_launcher/ClassLoaderCache2.java b/nailgun_launcher/ClassLoaderCache2.java
deleted file mode 100644
index bf9ca3b..0000000
--- a/nailgun_launcher/ClassLoaderCache2.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package cbt;
-
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import static java.io.File.pathSeparator;
-import static cbt.Stage0Lib.*;
-
-final class ClassLoaderCache2<T>{
-  ConcurrentHashMap<String,Object> keys;
-  ConcurrentHashMap<Object,T> values;
-
-  public ClassLoaderCache2(
-    ConcurrentHashMap<String,Object> keys,
-    ConcurrentHashMap<Object,T> values
-  ){
-    this.keys = keys;
-    this.values = values;
-  }
-
-  public T get( String key ){
-    return values.get(
-      keys.get( key )
-    );
-  }
-  
-  public Boolean contains( String key ){
-    return keys.containsKey( key );
-  }
-
-  public T put( T value, String key ){
-    LockableKey2 keyObject = new LockableKey2();
-    keys.put( key, keyObject );
-    values.put( keyObject, value );
-    return value;
-  }
-}
-class LockableKey2{}
\ No newline at end of file
diff --git a/nailgun_launcher/EarlyDependencies.java b/nailgun_launcher/EarlyDependencies.java
index 8f1962b..fdb54b5 100644
--- a/nailgun_launcher/EarlyDependencies.java
+++ b/nailgun_launcher/EarlyDependencies.java
@@ -28,7 +28,7 @@ class EarlyDependencies{
   String scalaLibrary_2_10_6_File;
 
   public EarlyDependencies(
-    String mavenCache, String mavenUrl, ClassLoaderCache2<ClassLoader> classLoaderCache, ClassLoader rootClassLoader
+    String mavenCache, String mavenUrl, JavaCache<ClassLoader> classLoaderCache, ClassLoader rootClassLoader
   ) throws Throwable {
     scalaReflect_2_11_8_File = mavenCache + "/org/scala-lang/scala-reflect/2.11.8/scala-reflect-2.11.8.jar";
     scalaCompiler_2_11_8_File = mavenCache + "/org/scala-lang/scala-compiler/2.11.8/scala-compiler-2.11.8.jar";
diff --git a/nailgun_launcher/JavaCache.java b/nailgun_launcher/JavaCache.java
new file mode 100644
index 0000000..56730df
--- /dev/null
+++ b/nailgun_launcher/JavaCache.java
@@ -0,0 +1,41 @@
+package cbt;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import static java.io.File.pathSeparator;
+import static cbt.Stage0Lib.*;
+
+final class JavaCache<T>{
+  ConcurrentHashMap<Object,Object> hashMap;
+
+  public JavaCache(
+    ConcurrentHashMap<Object,Object> hashMap
+  ){
+    this.hashMap = hashMap;
+  }
+
+  public T get( Object key ){
+    @SuppressWarnings("unchecked")
+    T t = (T) hashMap.get(
+      hashMap.get( key )
+    );
+    return t;
+  }
+
+  public Boolean contains( Object key/*, Long timestamp*/ ){
+    return hashMap.containsKey( key );/* && (
+      (Long) hashMap.get( hashMap.get( hashMap.get(key) ) ) >= timestamp
+    );*/
+  }
+
+  public T put( Object value, Object key/*, Long timestamp*/ ){
+    LockableJavaKey keyObject = new LockableJavaKey();
+    hashMap.put( key, keyObject );
+    hashMap.put( keyObject, value );
+    //hashMap.put( value, timestamp );
+    @SuppressWarnings("unchecked")
+    T t = (T) value;
+    return t;
+  }
+}
+class LockableJavaKey{}
diff --git a/nailgun_launcher/NailgunLauncher.java b/nailgun_launcher/NailgunLauncher.java
index 944daf8..0b41888 100644
--- a/nailgun_launcher/NailgunLauncher.java
+++ b/nailgun_launcher/NailgunLauncher.java
@@ -15,9 +15,8 @@ import static java.io.File.pathSeparator;
  */
 public class NailgunLauncher{
   /** Persistent cache for caching classloaders for the JVM life time. */
-  private final static ClassLoaderCache2<ClassLoader> classLoaderCache = new ClassLoaderCache2<ClassLoader>(
-    new ConcurrentHashMap<String,Object>(),
-    new ConcurrentHashMap<Object,ClassLoader>()
+  private final static JavaCache<ClassLoader> classLoaderCache = new JavaCache<ClassLoader>(
+    new ConcurrentHashMap<Object,Object>()
   );
 
   public final static SecurityManager initialSecurityManager
@@ -35,9 +34,8 @@ public class NailgunLauncher{
       ((File) get(context, "cache")).toString() + "/",
       ((File) get(context, "cbtHome")).toString(),
       ((File) get(context, "compatibilityTarget")).toString() + "/",
-      new ClassLoaderCache2<ClassLoader>(
-        (ConcurrentHashMap<String,Object>) get(context, "permanentKeys"),
-        (ConcurrentHashMap<Object,ClassLoader>) get(context, "permanentClassLoaders")
+      new JavaCache<ClassLoader>(
+        (ConcurrentHashMap) get(context, "persistentCache")
       )
     );
     return
@@ -93,12 +91,12 @@ public class NailgunLauncher{
           .getMethod(
             "run",
             String[].class, File.class, File.class, BuildStage1Result.class,
-            Long.class, ConcurrentHashMap.class, ConcurrentHashMap.class
+            Long.class, ConcurrentHashMap.class
           )
           .invoke(
             null,
             (Object) args, new File(cache), new File(CBT_HOME), res,
-            start, classLoaderCache.keys, classLoaderCache.values
+            start, classLoaderCache.hashMap
           )
       );
     } catch (java.lang.reflect.InvocationTargetException e) {
@@ -115,7 +113,7 @@ public class NailgunLauncher{
   }
 
   public static BuildStage1Result buildStage1(
-    Boolean changed, long start, String cache, String cbtHome, String compatibilityTarget, ClassLoaderCache2<ClassLoader> classLoaderCache
+    Boolean changed, long start, String cache, String cbtHome, String compatibilityTarget, JavaCache<ClassLoader> classLoaderCache
   ) throws Throwable {
     _assert(TARGET != null, "environment variable TARGET not defined");
     String nailgunTarget = cbtHome + "/" + NAILGUN + TARGET;