remove shouldTransform(className) from transformer.

Author: LunNova

src/main/java/me/nallar/javatransformer/api/JavaTransformer.java

@@ -202,9 +202,6 @@ public void addTransformer(@NonNull Transformer.TargetedTransformer t) {
 	}
 
 	public void addTransformer(@NonNull String s, @NonNull Transformer t) {
-		if (!t.shouldTransform(s)) {
-			throw new IllegalArgumentException("Transformer " + t + " must transform class of name " + s);
-		}
 		if (classTransformers.get(s).contains(t)) {
 			throw new IllegalArgumentException("Transformer " + t + " has already been added for class " + s);
 		}
@@ -227,64 +224,73 @@ public Supplier<byte[]> transformJava(@NonNull Supplier<byte[]> data, @NonNull S
 		if (!shouldTransform(name))
 			return data;
 
-		CompilationUnit cu;
-		try {
-			cu = JavaParser.parse(new ByteArrayInputStream(data.get()));
-		} catch (ParseException e) {
-			throw new RuntimeException(e);
-		}
-
-		String packageName = cu.getPackage().getName().getName();
-		for (TypeDeclaration typeDeclaration : cu.getTypes()) {
-			if (!(typeDeclaration instanceof ClassOrInterfaceDeclaration)) {
-				continue;
+		CachingSupplier<ClassOrInterfaceDeclaration> supplier = CachingSupplier.of(() -> {
+			CompilationUnit cu;
+			try {
+				cu = JavaParser.parse(new ByteArrayInputStream(data.get()));
+			} catch (ParseException e) {
+				throw new RuntimeException(e);
 			}
-			val classDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;
 
-			String shortClassName = classDeclaration.getName();
-			if ((packageName + '.' + shortClassName).equalsIgnoreCase(name)) {
-				transformJar(new SourceInfo(classDeclaration));
+			String packageName = cu.getPackage().getName().getName();
+			for (TypeDeclaration typeDeclaration : cu.getTypes()) {
+				if (!(typeDeclaration instanceof ClassOrInterfaceDeclaration)) {
+					continue;
+				}
+				ClassOrInterfaceDeclaration classDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;
+
+				String shortClassName = classDeclaration.getName();
+				if ((packageName + '.' + shortClassName).equalsIgnoreCase(name)) {
+					return classDeclaration;
+				}
 			}
-		}
 
-		return () -> cu.toString().getBytes(Charset.forName("UTF-8"));
+			throw new Error("Couldn't find any class or interface declaration matching expected name " + name);
+		});
+
+		transformClassInfo(new SourceInfo(supplier, name));
+
+		return supplier.isCached() ? () -> supplier.get().toString().getBytes(Charset.forName("UTF-8")) : data;
+
 	}
 
 	public Supplier<byte[]> transformClass(@NonNull Supplier<byte[]> data, @NonNull String name) {
+		System.out.println("Transforming " + name);
 		if (!shouldTransform(name))
 			return data;
 
-		ClassNode node = new ClassNode();
-		ClassReader reader = new ClassReader(data.get());
-		reader.accept(node, ClassReader.EXPAND_FRAMES);
+		Holder<ClassReader> readerHolder = new Holder<>();
+		CachingSupplier<ClassNode> supplier = CachingSupplier.of(() -> {
+			ClassNode node = new ClassNode();
+			ClassReader reader = new ClassReader(data.get());
+			reader.accept(node, ClassReader.EXPAND_FRAMES);
 
-		transformJar(new ByteCodeInfo(node));
+			readerHolder.value = reader;
+
+			return node;
+		});
 
-		ClassWriter classWriter = new ClassWriter(reader, 0);
-		node.accept(classWriter);
-		return classWriter::toByteArray;
+		transformClassInfo(new ByteCodeInfo(supplier, name));
+
+		if (!supplier.isCached())
+			return data;
+
+		return () -> {
+			ClassWriter classWriter = new ClassWriter(readerHolder.value, 0);
+			supplier.get().accept(classWriter);
+			return classWriter.toByteArray();
+		};
 	}
 
-	private void transformJar(ClassInfo editor) {
-		val name = editor.getName();
+	private void transformClassInfo(ClassInfo editor) {
 		transformers.forEach((x) -> {
-			if (x.shouldTransform(name)) {
-				x.transform(editor);
-			}
+			x.transform(editor);
 		});
-		classTransformers.get(name).forEach((it) -> it.transform(editor));
+		classTransformers.get(editor.getName()).forEach((it) -> it.transform(editor));
 	}
 
 	private boolean shouldTransform(String className) {
-		if (!classTransformers.get(className).isEmpty())
-			return true;
-
-		for (Transformer transformer : transformers) {
-			if (transformer.shouldTransform(className))
-				return true;
-		}
-
-		return false;
+		return !transformers.isEmpty() || !classTransformers.get(className).isEmpty();
 	}
 
 	private Supplier<byte[]> transformBytes(String relativeName, Supplier<byte[]> dataSupplier) {
@@ -342,4 +348,41 @@ public String toString() {
 			return map.toString();
 		}
 	}
+
+	@Data
+	private static class CachingSupplier<T> implements Supplier<T> {
+		@NonNull
+		private final Supplier<T> wrapped;
+		private transient T value;
+
+		protected CachingSupplier(Supplier<T> wrapped) {
+			this.wrapped = wrapped;
+		}
+
+		public static <T> CachingSupplier<T> of(Supplier<T> wrapped) {
+			return new CachingSupplier<>(wrapped);
+		}
+
+		@Override
+		public T get() {
+			T value = this.value;
+
+			if (value == null) {
+				synchronized (this) {
+					if (this.value == null)
+						this.value = value = Objects.requireNonNull(wrapped.get());
+				}
+			}
+
+			return value;
+		}
+
+		public boolean isCached() {
+			return value != null;
+		}
+	}
+
+	private static class Holder<T> {
+		public T value;
+	}
 }

src/main/java/me/nallar/javatransformer/api/Transformer.java

@@ -3,16 +3,6 @@
 import java.util.*;
 
 public interface Transformer {
-	/**
-	 * Determines whether a class should be transformed
-	 *
-	 * @param className Full class name, eg. java.lang.String
-	 * @return Whether the given class should be transformed
-	 */
-	default boolean shouldTransform(String className) {
-		return true;
-	}
-
 	/**
 	 * @param editor editor instance associated with a class
 	 */
@@ -23,9 +13,5 @@ interface TargetedTransformer extends Transformer {
 		 * @return List of classes which this transformer will run on
 		 */
 		Collection<String> getTargetClasses();
-
-		default boolean shouldTransform(String className) {
-			return getTargetClasses().contains(className);
-		}
 	}
 }

src/main/java/me/nallar/javatransformer/internal/ByteCodeInfo.java

@@ -1,5 +1,6 @@
 package me.nallar.javatransformer.internal;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.Getter;
 import lombok.val;
@@ -11,33 +12,37 @@
 import org.objectweb.asm.tree.MethodNode;
 
 import java.util.*;
+import java.util.function.*;
 import java.util.stream.*;
 
 @Data
+@AllArgsConstructor
 @SuppressWarnings("unchecked")
 public class ByteCodeInfo implements ClassInfoStreams {
-	private final ClassNode node;
+	private final Supplier<ClassNode> node;
 	@Getter(lazy = true)
 	private final List<Annotation> annotations = getAnnotationsInternal();
+	private String className;
 
 	@Override
 	public String getName() {
-		return node.name.replace('/', '.');
+		return className;
 	}
 
 	@Override
 	public void setName(String name) {
-		node.name = name.replace('.', '/');
+		className = name;
+		node.get().name = name.replace('.', '/');
 	}
 
 	@Override
 	public AccessFlags getAccessFlags() {
-		return new AccessFlags(node.access);
+		return new AccessFlags(node.get().access);
 	}
 
 	@Override
 	public void setAccessFlags(AccessFlags accessFlags) {
-		node.access = accessFlags.access;
+		node.get().access = accessFlags.access;
 	}
 
 	public void add(MethodInfo method) {
@@ -66,7 +71,7 @@ public void add(MethodInfo method) {
 			MethodInfo info = new MethodNodeInfo(node);
 			info.setAll(method);
 		}
-		this.node.methods.add(node);
+		this.node.get().methods.add(node);
 	}
 
 	public void add(FieldInfo field) {
@@ -84,7 +89,7 @@ public void add(FieldInfo field) {
 			val nodeInfo = new FieldNodeInfo(node);
 			nodeInfo.setAll(field);
 		}
-		this.node.fields.add(node);
+		this.node.get().fields.add(node);
 	}
 
 	@Override
@@ -94,7 +99,7 @@ public void remove(MethodInfo method) {
 		if (methodNodeInfo == null)
 			throw new RuntimeException("Method " + method + " can not be removed as it is not present");
 
-		node.methods.remove(methodNodeInfo.node);
+		node.get().methods.remove(methodNodeInfo.node);
 	}
 
 	@Override
@@ -104,29 +109,29 @@ public void remove(FieldInfo field) {
 		if (fieldNodeInfo == null)
 			throw new RuntimeException("Field " + field + " can not be removed as it is not present");
 
-		node.fields.remove(fieldNodeInfo.node);
+		node.get().fields.remove(fieldNodeInfo.node);
 	}
 
 	@Override
 	public Type getSuperType() {
-		return new Type("L" + node.superName + ";");
+		return new Type("L" + node.get().superName + ";");
 	}
 
 	@Override
 	public List<Type> getInterfaceTypes() {
-		return node.interfaces.stream().map((it) -> new Type("L" + it + ";")).collect(Collectors.toList());
+		return node.get().interfaces.stream().map((it) -> new Type("L" + it + ";")).collect(Collectors.toList());
 	}
 
 	public Stream<MethodInfo> getMethodStream() {
-		return node.methods.stream().map(MethodNodeInfo::new);
+		return node.get().methods.stream().map(MethodNodeInfo::new);
 	}
 
 	public Stream<FieldInfo> getFieldStream() {
-		return node.fields.stream().map(FieldNodeInfo::new);
+		return node.get().fields.stream().map(FieldNodeInfo::new);
 	}
 
 	private List<Annotation> getAnnotationsInternal() {
-		return CollectionUtil.union(node.invisibleAnnotations, node.visibleAnnotations).map(AnnotationParser::annotationFromAnnotationNode).collect(Collectors.toList());
+		return CollectionUtil.union(node.get().invisibleAnnotations, node.get().visibleAnnotations).map(AnnotationParser::annotationFromAnnotationNode).collect(Collectors.toList());
 	}
 
 	@Override