1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
package com.github.javaparser.generator.core.node;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Node;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.stmt.BlockStmt;
import com.github.javaparser.generator.NodeGenerator;
import com.github.javaparser.metamodel.BaseNodeMetaModel;
import com.github.javaparser.metamodel.PropertyMetaModel;
import com.github.javaparser.utils.SourceRoot;
import static com.github.javaparser.JavaParser.parseBodyDeclaration;
import static com.github.javaparser.utils.CodeGenerationUtils.f;
import static com.github.javaparser.utils.Utils.capitalize;
public class ReplaceMethodGenerator extends NodeGenerator {
public ReplaceMethodGenerator(SourceRoot sourceRoot) {
super(sourceRoot);
}
@Override
protected void generateNode(BaseNodeMetaModel nodeMetaModel, CompilationUnit nodeCu, ClassOrInterfaceDeclaration nodeCoid) {
MethodDeclaration replaceNodeMethod = (MethodDeclaration) parseBodyDeclaration("public boolean replace(Node node, Node replacementNode) {}");
nodeCu.addImport(Node.class);
nodeMetaModel.getSuperNodeMetaModel().ifPresent(s -> annotateOverridden(replaceNodeMethod));
final BlockStmt body = replaceNodeMethod.getBody().get();
body.addStatement("if (node == null) return false;");
for (PropertyMetaModel property : nodeMetaModel.getDeclaredPropertyMetaModels()) {
if (!property.isNode()) {
continue;
}
String check;
if (property.isNodeList()) {
check = nodeListCheck(property);
} else {
if (property.isRequired()) {
continue;
}
String replaceAttributeMethodName = generateReplaceMethodForAttribute(nodeCoid, nodeMetaModel, property);
check = attributeCheck(property, replaceAttributeMethodName);
}
if (property.isOptional()) {
check = f("if (%s != null) { %s }", property.getName(), check);
}
body.addStatement(check);
}
if (nodeMetaModel.getSuperNodeMetaModel().isPresent()) {
body.addStatement("return super.replace(node, replacementNode);");
} else {
body.addStatement("return false;");
}
addOrReplaceWhenSameSignature(nodeCoid, replaceNodeMethod);
annotateGenerated(replaceNodeMethod);
}
private String attributeCheck(PropertyMetaModel property, String replaceAttributeMethodName) {
return f("if (node == %s) {" +
" %s((%s) replacementNode);" +
" return true;\n" +
"}", property.getName(), replaceAttributeMethodName, property.getTypeName());
}
private String nodeListCheck(PropertyMetaModel property) {
return f("for (int i = 0; i < %s.size(); i++) {" +
" if (%s.get(i) == node) {" +
" %s.set(i, (%s) replacementNode);" +
" return true;" +
" }" +
"}", property.getName(), property.getName(), property.getName(), property.getTypeName());
}
private String generateReplaceMethodForAttribute(ClassOrInterfaceDeclaration nodeCoid, BaseNodeMetaModel nodeMetaModel, PropertyMetaModel property) {
final String methodName = "replace" + capitalize(property.getName());
final MethodDeclaration replaceMethod = (MethodDeclaration) parseBodyDeclaration(f("public %s %s(%s replacement) {}", nodeMetaModel.getTypeName(), methodName, property.getTypeName()));
final BlockStmt block = replaceMethod.getBody().get();
block.addStatement(f("return %s((%s) replacement);", property.getSetterMethodName(), property.getTypeNameForSetter()));
addOrReplaceWhenSameSignature(nodeCoid, replaceMethod);
annotateGenerated(replaceMethod);
return methodName;
}
}
|
