Refactor/remove obsolete implementations

src/dev/w1zzrd/asm/Combine.java

@@ -274,6 +274,10 @@ public class Combine {
         return null;
     }
 
+    public String getTargetName() {
+        return target.name;
+    }
+
     /**
      * Prepares a {@link MethodNode} for grafting on to a given method and into the targeted  {@link ClassNode}
      * @param node Node to adapt

src/dev/w1zzrd/asm/Injector.java

@@ -1,6 +1,10 @@
 package dev.w1zzrd.asm;
 
+import dev.w1zzrd.asm.analysis.AsmAnnotation;
+import jdk.internal.org.objectweb.asm.Type;
+import jdk.internal.org.objectweb.asm.tree.AnnotationNode;
 import jdk.internal.org.objectweb.asm.tree.ClassNode;
+import jdk.internal.org.objectweb.asm.tree.MethodNode;
 
 import java.io.File;
 import java.io.IOException;
@@ -13,6 +17,7 @@ import java.util.Objects;
  * Simple class for automatically performing transformations
  */
 public class Injector {
+    private static final String injectAnnotDesc = "L"+InjectClass.class.getName().replace('.', '/')+";";
 
     /**
      * Attempt to inject all valid classes into the given merger from the given loader
@@ -20,14 +25,14 @@ public class Injector {
      * @param merger Merger to inject resources into
      * @throws IOException If any resource could not be loaded properly
      */
-    public static void injectAll(ClassLoader loader, Merger merger) throws IOException {
+    public static void injectAll(ClassLoader loader, Combine merger) throws IOException {
         Enumeration<URL> resources = loader.getResources("");
         while (resources.hasMoreElements())
             injectDirectory(new File(resources.nextElement().getPath()), merger);
     }
 
     // Inject all files in a given directory into the merger
-    private static void injectDirectory(File file, Merger merger) throws IOException {
+    private static void injectDirectory(File file, Combine merger) throws IOException {
         if (file.isDirectory())
             for (File child : Objects.requireNonNull(file.listFiles()))
                 injectDirectory(child, merger);
@@ -35,7 +40,7 @@ public class Injector {
     }
 
     // Inject file into a given merger (if declared as such)
-    private static void injectFile(File file, Merger merger) throws IOException {
+    private static void injectFile(File file, Combine merger) throws IOException {
         URL url = null;
         try {
             url = file.toURI().toURL();
@@ -45,7 +50,21 @@ public class Injector {
         ClassNode cNode;
 
         assert url != null;
-        if(url.getPath().endsWith(".class") && merger.shouldInject(cNode = Merger.getClassNode(url)))
+        if(url.getPath().endsWith(".class") && shouldInject(merger, cNode = Loader.getClassNode(url))) {
-            merger.inject(cNode);
+            GraftSource source = new GraftSource(cNode);
+            for (MethodNode mNode : source.getInjectMethods())
+                merger.inject(mNode, source);
+        }
+    }
+
+    private static boolean shouldInject(Combine combine, ClassNode node) {
+        for (AnnotationNode annotNode : node.visibleAnnotations)
+            if (annotNode.desc.equals(injectAnnotDesc) &&
+                    ((Type)(AsmAnnotation.getAnnotation(annotNode).getEntry("value")))
+                            .getClassName()
+                            .equals(combine.getTargetName()))
+                return true;
+
+        return false;
     }
 }

src/dev/w1zzrd/asm/Loader.java

@@ -0,0 +1,92 @@
+package dev.w1zzrd.asm;
+
+import jdk.internal.org.objectweb.asm.ClassReader;
+import jdk.internal.org.objectweb.asm.tree.ClassNode;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Objects;
+
+public class Loader {
+
+    /**
+     * Get a glass node from a given resource
+     * @param url Resource to load class node from
+     * @return Class node loaded from the resource
+     * @throws IOException If the resource cannot be loaded
+     */
+    public static ClassNode getClassNode(URL url) throws IOException {
+        return readClass(getClassBytes(url));
+    }
+
+    /**
+     * Read class data to a class node
+     * @param data Bytecode to read
+     * @return Class node read
+     */
+    public static ClassNode readClass(byte[] data) {
+        ClassNode node = new ClassNode();
+        new ClassReader(data).accept(node, 0);
+        return node;
+    }
+
+    /**
+     * Read a class node from a given class
+     * @param name Name of the class to get the class node from
+     * @return Loaded class node
+     * @throws IOException If the class data resource cannot be loaded
+     */
+    public static ClassNode getClassNode(String name) throws IOException {
+        return readClass(getClassBytes(name));
+    }
+
+    /**
+     * Read a class node from a given class
+     * @param name Name of the class to get the class node from
+     * @param loader Loader to use when loading the class resource
+     * @return Loaded class node
+     * @throws IOException If the class data resource cannot be loaded
+     */
+    public static ClassNode getClassNode(String name, ClassLoader loader) throws IOException {
+        return readClass(getClassBytes(name, loader));
+    }
+
+    /**
+     * Get class bytecode for a given class
+     * @param name Name of the class to get data for
+     * @return Bytecode for the requested class
+     * @throws IOException If the class data resource cannot be loaded
+     */
+    public static byte[] getClassBytes(String name) throws IOException {
+        return getClassBytes(name, ClassLoader.getSystemClassLoader());
+    }
+
+    /**
+     * Get class bytecode for a given class
+     * @param name Name of the class to get data for
+     * @param loader Loader to use when loading the class resource
+     * @return Bytecode for the requested class
+     * @throws IOException If the class data resource cannot be loaded
+     */
+    public static byte[] getClassBytes(String name, ClassLoader loader) throws IOException {
+        return getClassBytes(Objects.requireNonNull(loader.getResource(name.replace('.', '/') + ".class")));
+    }
+
+    /**
+     * Get class bytecode for a given class
+     * @param url Resource to load class data from
+     * @return Bytecode for the requested class resource
+     * @throws IOException If the class data resource cannot be loaded
+     */
+    public static byte[] getClassBytes(URL url) throws IOException {
+        InputStream stream = url.openStream();
+        byte[] classData = new byte[stream.available()];
+
+        int total = 0;
+        do total += stream.read(classData, total, classData.length - total);
+        while (total < classData.length);
+
+        return classData;
+    }
+}

src/dev/w1zzrd/asm/reflect/ReflectCompat.java

@@ -1,4 +1,4 @@
-package dev.w1zzrd.asm;
+package dev.w1zzrd.asm.reflect;
 
 import dev.w1zzrd.asm.reflect.BruteForceDummy;
 import sun.misc.Unsafe;