Add support for nested types

peter-lawrey · peter-lawrey · commit 1b365be1068f · 2013-10-08T12:17:33.000+01:00
diff --git a/compiler/pom.xml b/compiler/pom.xml
@@ -22,7 +22,7 @@
 
     <groupId>net.openhft</groupId>
     <artifactId>compiler</artifactId>
-    <version>2.0</version>
+    <version>2.0.1-SNAPSHOT</version>
     <packaging>bundle</packaging>
 
     <name>OpenHFT/Java-Runtime-Compiler</name>
diff --git a/compiler/src/main/java/net/openhft/compiler/CachedCompiler.java b/compiler/src/main/java/net/openhft/compiler/CachedCompiler.java
@@ -22,20 +22,23 @@
 import javax.tools.JavaFileObject;
 import java.io.File;
 import java.io.IOException;
-import java.util.Collections;
-import java.util.Map;
+import java.util.*;
 import java.util.logging.Logger;
 
 import static net.openhft.compiler.CompilerUtils.writeBytes;
 import static net.openhft.compiler.CompilerUtils.writeText;
 
 @SuppressWarnings("StaticNonFinalField")
 public class CachedCompiler {
+    private static final Map<ClassLoader, Map<String, Class>> loadedClassesMap = new WeakHashMap<ClassLoader, Map<String, Class>>();
+
     @Nullable
     private final File sourceDir;
     @Nullable
     private final File classDir;
 
+    private final List<JavaFileObject> javaFileObjects = new ArrayList<JavaFileObject>();
+
     public CachedCompiler(@Nullable File sourceDir, @Nullable File classDir) {
         this.sourceDir = sourceDir;
         this.classDir = classDir;
@@ -62,26 +65,48 @@ Map<String, byte[]> compileFromJava(@NotNull String className, @NotNull String j
             writeText(file, javaCode);
             compilationUnits = CompilerUtils.s_standardJavaFileManager.getJavaFileObjects(file);
         } else {
-            compilationUnits = Collections.singletonList(new JavaSourceFromString(className, javaCode));
+            javaFileObjects.add(new JavaSourceFromString(className, javaCode));
+            compilationUnits = javaFileObjects;
         }
         // reuse the same file manager to allow caching of jar files
         CompilerUtils.s_compiler.getTask(null, CompilerUtils.s_fileManager, null, null, null, compilationUnits).call();
         return CompilerUtils.s_fileManager.getAllBuffers();
     }
 
     public Class loadFromJava(@NotNull ClassLoader classLoader, @NotNull String className, @NotNull String javaCode) throws ClassNotFoundException {
+        Class clazz = null;
+        Map<String, Class> loadedClasses;
+        synchronized (loadedClassesMap) {
+            loadedClasses = loadedClassesMap.get(classLoader);
+            if (loadedClasses == null)
+                loadedClassesMap.put(classLoader, loadedClasses = new LinkedHashMap<String, Class>());
+            else
+                clazz = loadedClasses.get(className);
+        }
+        if (clazz != null)
+            return clazz;
         for (Map.Entry<String, byte[]> entry : compileFromJava(className, javaCode).entrySet()) {
             String className2 = entry.getKey();
+            synchronized (loadedClassesMap) {
+                if (loadedClasses.containsKey(className2))
+                    continue;
+            }
             byte[] bytes = entry.getValue();
             if (classDir != null) {
                 String filename = className2.replaceAll("\\.", '\\' + File.separator) + ".class";
                 boolean changed = writeBytes(new File(classDir, filename), bytes);
                 if (changed)
                     Logger.getLogger(CachedCompiler.class.getName()).info("Updated " + className2 + " in " + classDir);
             }
-            CompilerUtils.defineClass(classLoader, className2, bytes);
+            Class clazz2 = CompilerUtils.defineClass(classLoader, className2, bytes);
+            synchronized (loadedClassesMap) {
+                loadedClasses.put(className2, clazz2);
+            }
+        }
+//        CompilerUtils.s_fileManager.clearBuffers();
+        synchronized (loadedClassesMap) {
+            loadedClasses.put(className, clazz = classLoader.loadClass(className));
         }
-        CompilerUtils.s_fileManager.clearBuffers();
-        return classLoader.loadClass(className);
+        return clazz;
     }
 }
diff --git a/compiler/src/main/java/net/openhft/compiler/CompilerUtils.java b/compiler/src/main/java/net/openhft/compiler/CompilerUtils.java
@@ -137,9 +137,9 @@ public static void defineClass(@NotNull String className, @NotNull byte[] bytes)
      * @param className   expected to load.
      * @param bytes       of the byte code.
      */
-    public static void defineClass(@Nullable ClassLoader classLoader, @NotNull String className, @NotNull byte[] bytes) {
+    public static Class defineClass(@Nullable ClassLoader classLoader, @NotNull String className, @NotNull byte[] bytes) {
         try {
-            DEFINE_CLASS_METHOD.invoke(classLoader, className, bytes, 0, bytes.length);
+            return (Class) DEFINE_CLASS_METHOD.invoke(classLoader, className, bytes, 0, bytes.length);
         } catch (IllegalAccessException e) {
             throw new AssertionError(e);
         } catch (InvocationTargetException e) {
