Source code
package org.springframework.cglib.transform;
import org.springframework.asm.ClassVisitor;
import org.springframework.asm.MethodVisitor;
import org.springframework.cglib.core.ClassTransformer;
public class ClassTransformerChain extends AbstractClassTransformer {
private ClassTransformer[] chain;
public ClassTransformerChain(ClassTransformer[] chain) {
this.chain = chain.clone();
}
@Override
public void setTarget(ClassVisitor v) {
super.setTarget(chain[0]);
ClassVisitor next = v;
for (int i = chain.length - 1; i >= 0; i--) {
chain[i].setTarget(next);
next = chain[i];
}
}
@Override
public MethodVisitor visitMethod(int access,
String name,
String desc,
String signature,
String[] exceptions) {
return cv.visitMethod(access, name, desc, signature, exceptions);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("ClassTransformerChain{");
for (int i = 0; i < chain.length; i++) {
if (i > 0) {
sb.append(", ");
}
sb.append(chain[i].toString());
}
sb.append("}");
return sb.toString();
}
}
Run 1
The code has a clear purpose but suffers from inconsistent indentation and mixing of tabs/spaces, which hurts readability. The class structure is logical and methods are short, with reasonable action granularity. However, the setTarget logic (reverse-order chain wiring) is non-obvious and lacks a comment explaining why the loop runs backwards. Nesting is shallow, and naming is mostly clear, though 'cv' and 'v' are somewhat terse. The toString method is straightforward but could be simplified with streams or String.join. Overall, the code is understandable to an experienced developer but would benefit from formatting cleanup and a brief explanatory comment on the transformer chaining mechanism.
Run 2
The code is relatively readable but suffers from inconsistent indentation and unclear intent in the setTarget method. The chain initialization logic is concise but the loop reversing through the array is slightly confusing without explanation. The visitMethod override simply delegates, which is clear but unnecessary if cv is already set. The toString method is straightforward with reasonable formatting. Naming is good, and the class structure is logical. However, the mixed indentation (tabs vs spaces) disrupts reading flow, and the lack of comments explaining the chain setup reduces clarity. The action granularity is generally acceptable.
Run 3
The code is generally clear and logically organized, with a straightforward class structure and concise methods. It avoids deep nesting and maintains one action per line in most cases. The purpose of chaining class transformers is evident from the class name and method logic. However, minor readability issues exist: inconsistent indentation (e.g., @Override annotations and method bodies), mixed tabs/spaces, and a slightly confusing loop in setTarget where chain[0] is pre-set before the reverse iteration. The visitMethod override is redundant but not harmful. Overall, the code is readable but would benefit from formatting consistency and minor refactoring for clarity.
Run 1
Code Structure: Methods are logically separated into construction, chain configuration, method delegation, and string representation. Nesting: Minimal, with simple loops and only one nested conditional. Clarity of intent: Class and method names communicate their purposes, although reverse chain wiring requires some thought and names such as v, cv, and sb are less descriptive. Code length: Compact and mostly necessary; string formatting is slightly verbose but straightforward. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: The method order is natural and control flow is easy to follow, but inconsistent tab/space indentation and parameter alignment reduce visual consistency.
Run 2
Code Structure: Logically organized into construction, target wiring, method delegation, and string representation. Nesting: Shallow overall, with only a loop and conditional in toString. Clarity of intent: Class and method names communicate purpose; reverse chain wiring requires some thought, and names like v, cv, and sb are less descriptive. Code length: Compact, with little unnecessary code, though string formatting is somewhat verbose. Action granularity: Each statement performs a single clear action. Reading flow: Methods follow a natural sequence, but inconsistent tabs, spaces, and parameter alignment interrupt visual consistency. The nonempty-chain assumption is implicit rather than documented.
Run 3
Code Structure: Well-organized class with separate methods for construction, chain wiring, method delegation, and string representation. Nesting: Shallow overall; only toString has a conditional inside a loop. Clarity of intent: Class and method names communicate purpose, although reverse-order chain wiring requires some thought and names like v and cv provide limited context. Code length: Compact, with little unnecessary code; string formatting is slightly verbose but straightforward. Action granularity: Each statement performs one clear action, making execution easy to follow. Reading flow: Methods follow a natural sequence, but inconsistent tab/space indentation and parameter alignment disrupt visual consistency. Overall, the code is highly readable with minor naming and formatting weaknesses.