Skip to contentMethod: createNewMethod(String, String)
1: package de.fhdw.wtf.generator.transformer.clipper;
2:
3: import java.io.File;
4: import java.io.IOException;
5: import java.util.ArrayList;
6: import java.util.Arrays;
7: import java.util.Collection;
8: import java.util.Iterator;
9: import java.util.List;
10:
11: import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
12: import de.fhdw.wtf.common.exception.walker.TaskException;
13: import de.fhdw.wtf.common.task.TaskExecutor;
14: import de.fhdw.wtf.file.FileUtils;
15: import de.fhdw.wtf.generator.java.generatorModel.GenClassClass;
16: import de.fhdw.wtf.generator.java.generatorModel.GenComment;
17: import de.fhdw.wtf.generator.java.generatorModel.GenExternalInterfaceClass;
18: import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceClass;
19: import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceWithClassImplClass;
20: import de.fhdw.wtf.generator.java.generatorModel.GenJavaOperation;
21: import de.fhdw.wtf.generator.java.generatorModel.GenOperation;
22: import de.fhdw.wtf.generator.java.generatorModel.GenOperationSignature;
23: import de.fhdw.wtf.generator.java.generatorModel.GenParameter;
24: import de.fhdw.wtf.generator.java.generatorModel.GenPrimitiveClass;
25: import de.fhdw.wtf.generator.java.generatorModel.GenSimpleInterfaceClass;
26: import de.fhdw.wtf.generator.java.generatorModel.GenSimpleOperationState;
27: import de.fhdw.wtf.generator.java.generatorModel.GenTypeReferenceByName;
28: import de.fhdw.wtf.generator.java.generatorModel.GeneratorModel;
29: import de.fhdw.wtf.generator.java.visitor.GenClassVisitorException;
30: import de.fhdw.wtf.generator.java.visitor.GenInterfaceClassVisitorException;
31: import de.fhdw.wtf.generator.java.walker.SimpleGeneratorModelWalkerTask;
32: import de.fhdw.wtf.generator.transformer.util.Tuple;
33:
34: /**
35: * This task imports all existing methods into all classes in the JavaST It overwrites existing operations.
36: *
37: */
38: public class LinkToGenClassTask extends SimpleGeneratorModelWalkerTask {
39:
40: /**
41: * Constant for "\n".
42: */
43: private static final String BREAK = "\n";
44:
45: private final ClipperConfiguration configuration;
46:
47: /**
48: * @param taskmanager
49: * @param javaGeneratorModel
50: * @param configuration
51: * @param clipperImport
52: */
53: public LinkToGenClassTask(final TaskExecutor taskmanager,
54: final GeneratorModel javaGeneratorModel,
55: final ClipperConfiguration configuration,
56: final ClipToFileTask clipperImport) {
57: super(taskmanager, javaGeneratorModel);
58: this.configuration = configuration;
59:
60: try {
61: this.addDependency(clipperImport);
62: } catch (final CyclicDependencyException e) {
63: // should not happen
64: e.printStackTrace();
65: throw new Error("Dependency tasks are cyclic in ImportAllFromClipperTask.");
66: }
67: }
68:
69: /**
70: * Inserts all methods from clipper into the given type.
71: *
72: * @param t
73: * @throws TaskException
74: */
75: private void handleType(final de.fhdw.wtf.generator.java.generatorModel.GenClass t) throws TaskException {
76: // TODO: Wenn die InnerClasses so wie geplant generiert werden, kann hier die Struktur wieder vereinfacht
77: // werden. ACHTUNG: Auch an die Testfälle denken!
78: final String filename =
79: LinkToGenClassTask.this.configuration.getRepoDirectoryRoot()
80: + t.getFullyQualifiedTypeName().replace(".", "/");
81: final File[] directoryListing = new File(filename).listFiles();
82: if (directoryListing != null) { // is a directory
83: t.accept(new GenClassVisitorException<TaskException>() {
84:
85: @Override
86: public void handle(final GenClassClass classClass) throws TaskException {
87: LinkToGenClassTask.this.readClippedFile(directoryListing, filename, t);
88: }
89:
90: @Override
91: public void handle(final GenInterfaceClass interfaceClass) throws TaskException {
92: interfaceClass.accept(new GenInterfaceClassVisitorException<TaskException>() {
93:
94: @Override
95: public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass)
96: throws TaskException {
97:
98: LinkToGenClassTask.this.readClippedFile(directoryListing, filename, t);
99:
100: LinkToGenClassTask.this.handleType(interfaceWithImplClass.getClassRepresentation());
101: }
102:
103: @Override
104: public void handle(final GenSimpleInterfaceClass simpleInterface) throws TaskException {
105: LinkToGenClassTask.this.readClippedFile(directoryListing, filename, t);
106: }
107:
108: @Override
109: public void handle(final GenExternalInterfaceClass iface) throws TaskException {
110: throw new TaskException("Cannot restore contents of external interface "
111: + iface.getFullyQualifiedTypeName());
112: }
113: });
114:
115: }
116:
117: @Override
118: public void handle(final GenPrimitiveClass primitiveClass) throws TaskException {
119: LinkToGenClassTask.this.readClippedFile(directoryListing, filename, t);
120: }
121: });
122: } else {
123: return;
124: }
125: }
126:
127: /**
128: * Read all files in clipper directory and sets the contents of the files to the GenClasses fields.
129: *
130: * @param directoryListing
131: * files in clipper directory
132: * @param filename
133: * clipper directory path
134: * @param t
135: * GenClass to be generated
136: * @throws TaskException
137: * possible exception
138: */
139: private void readClippedFile(final File[] directoryListing,
140: final String filename,
141: final de.fhdw.wtf.generator.java.generatorModel.GenClass t) throws TaskException {
142: for (final File file : directoryListing) {
143: try {
144: if (file.isDirectory()) {
145: final Iterator<GenClassClass> innerClasses = t.getInnerClasses().iterator();
146: while (innerClasses.hasNext()) {
147: final GenClassClass current = innerClasses.next();
148: if (current.getName().equals(file.getName())) {
149: this.handleType(current);
150: break;
151: }
152: }
153: } else {
154: final String fileString = FileUtils.getFileString(file.getAbsolutePath());
155: final String fileName = file.getName();
156: switch (fileName) {
157: case ClipperUtils.CLASSCOMMENT_FILENAME:
158: t.setComment(GenComment.create(fileString));
159: break;
160: case ClipperUtils.PROTECTED_AREA_FILENAME:
161: t.setNonGeneratedPart(fileString);
162: break;
163: case ClipperUtils.ERRORFILE_FILENAME:
164: break;
165: case ClipperUtils.IMPORTS_FILENAME:
166: t.setImports(BREAK + fileString + BREAK);
167: break;
168: default:
169: if (fileName.startsWith("#attr#")) {
170: // final GenAttribute a =
171: // this.createNewAttribute(fileName, fileString);
172:
173: // TODO Attributes are not yet supported in Java-AST
174: } else if (fileName.startsWith("#constructor")) {
175: // Constructors will be no longer clipped
176: final GenJavaOperation constructor =
177: GenJavaOperation.create(t.getName(), this.parseClipperFileName(fileName, true)
178: .getB(), GenSimpleOperationState.create(fileString));
179: t.accept(new GenClassVisitorException<TaskException>() {
180: @Override
181: public void handle(final GenClassClass classClass) throws TaskException {
182: LinkToGenClassTask.this.deleteConstructorLike(
183: classClass.getConstructors(),
184: constructor);
185: classClass.getConstructors().add(constructor);
186: }
187:
188: @Override
189: public void handle(final GenInterfaceClass interfaceClass) throws TaskException {
190: throw new TaskException("Clipper: Tried to add constructor to interface" + fileName);
191: }
192:
193: @Override
194: public void handle(final GenPrimitiveClass primitiveClass) throws TaskException {
195: // nothing to do
196: }
197: });
198: } else {
199: final GenJavaOperation m = this.createNewMethod(fileName, fileString);
200: if (!t.overrideExistingOperation(m)) {
201: t.tryToOverrideAbstractOperation(m);
202: }
203: }
204: }
205: }
206: } catch (final IOException e) {
207: throw new TaskException("Clipper: Retrieve method failed: " + filename);
208: }
209: }
210: }
211:
212: /**
213: * Creates the new method and deletes possible existing operations.
214: *
215: * @param fileName
216: * - the name of the clipped file (it contains the signature of the operation).
217: * @param fileString
218: * - the clipped filestring.
219: *
220: * @return the clipped {@link GenJavaOperation}
221: */
222: private GenJavaOperation createNewMethod(final String fileName, final String fileString) {
223: final Tuple<String, List<GenParameter>> res = this.parseClipperFileName(fileName, false);
224: final GenJavaOperation newOperation =
225: GenJavaOperation.create(res.getA(), res.getB(), GenSimpleOperationState.create(fileString));
226: return newOperation;
227: }
228:
229: private void deleteConstructorLike(final Collection<GenJavaOperation> collection, final GenJavaOperation constructor) {
230: final Iterator<GenJavaOperation> i = collection.iterator();
231: while (i.hasNext()) {
232: final GenJavaOperation current = i.next();
233: if (GenOperationSignature.equalsParamTypes(current.getParameters(), constructor.getParameters())) {
234: i.remove();
235: }
236: }
237: }
238:
239: private Tuple<String, List<GenParameter>> parseClipperFileName(final String fileName, final boolean constructor) {
240: final List<String> split = new ArrayList<>(Arrays.asList(fileName.split(ClipperUtils.SEPERATOR)));
241: if (constructor) { // Beim Konstruktor-Dateinamen ist der erste Split
242: // leer und wird übersprungen!
243: split.remove(0);
244: }
245: final String name = split.remove(0);
246: final List<GenParameter> result = new ArrayList<>();
247: for (final String current : split) {
248: final GenTypeReferenceByName ref = GenTypeReferenceByName.create(current);
249: final GenParameter para = GenParameter.create("DUMMY-PARA-NAME", ref); // TODO
250: // Name
251: // anpassen
252: result.add(para);
253: }
254: return new Tuple<>(name, result);
255: }
256:
257: @Override
258: public void handleClassClass(final GenClassClass cc) throws TaskException {
259: this.handleType(cc);
260: }
261:
262: @Override
263: public void handleInterfaceClass(final GenInterfaceClass ic) throws TaskException {
264: this.handleType(ic);
265: }
266:
267: @Override
268: public void finalizeTask() throws TaskException {
269: // nothing to do
270: }
271:
272: @Override
273: public void handleOperation(final GenOperation o) throws TaskException {
274: // nothing to do
275: }
276:
277: }
![[Jenkins]](/jenkins/static/5c0124f8/images/svgs/logo.svg){kind=logo}
