Method: handle(GenExternalClassClass)

1: package de.fhdw.wtf.generator.writer.tasks;
2:
3: import java.io.File;
4:
5: import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
6: import de.fhdw.wtf.common.exception.walker.TaskException;
7: import de.fhdw.wtf.common.task.DependencyTask;
8: import de.fhdw.wtf.common.task.TaskExecutor;
9: import de.fhdw.wtf.generator.java.generatorModel.GenAnyType;
10: import de.fhdw.wtf.generator.java.generatorModel.GenAspect;
11: import de.fhdw.wtf.generator.java.generatorModel.GenClassClass;
12: import de.fhdw.wtf.generator.java.generatorModel.GenException;
13: import de.fhdw.wtf.generator.java.generatorModel.GenExternalClassClass;
14: import de.fhdw.wtf.generator.java.generatorModel.GenExternalInterfaceClass;
15: import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceClass;
16: import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceWithClassImplClass;
17: import de.fhdw.wtf.generator.java.generatorModel.GenJavaException;
18: import de.fhdw.wtf.generator.java.generatorModel.GenOperation;
19: import de.fhdw.wtf.generator.java.generatorModel.GenSimpleInterfaceClass;
20: import de.fhdw.wtf.generator.java.generatorModel.GenUserClass;
21: import de.fhdw.wtf.generator.java.generatorModel.GeneratorModel;
22: import de.fhdw.wtf.generator.java.visitor.GenClassClassVisitor;
23: import de.fhdw.wtf.generator.java.visitor.GenInterfaceClassVisitor;
24: import de.fhdw.wtf.generator.java.walker.SimpleGeneratorModelWalkerTask;
25: import de.fhdw.wtf.generator.writer.writer.ExceptionFileWriter;
26: import de.fhdw.wtf.generator.writer.writer.FileHeaderWriter;
27: import de.fhdw.wtf.generator.writer.writer.JavaAspectClassFileWriter;
28: import de.fhdw.wtf.generator.writer.writer.JavaClassFileWriter;
29: import de.fhdw.wtf.generator.writer.writer.JavaInterfaceClassFileWriter;
30:
31: /**
32: *
33: * {@link DependencyTask} for Writing all Java-Files declared in a {@link GeneratorModel} by {@link GenClassClass}s or
34: * {@link GenInterfaceClass} .
35: */
36: public class FileWriterTask extends SimpleGeneratorModelWalkerTask {
37:         
38:         private final JavaInterfaceClassFileWriter interfaceWriter;
39:         private final JavaClassFileWriter classWriter;
40:         private final JavaAspectClassFileWriter aspectWriter;
41:         private final ExceptionFileWriter exceptionWriter;
42:         
43:         private final File rootDir;
44:         
45:         public FileWriterTask(final TaskExecutor taskmanager,
46:                         final GeneratorModel model,
47:                         final String rootDir,
48:                         final DependencyTask clipper) {
49:                 super(taskmanager, model);
50:                 this.interfaceWriter = new JavaInterfaceClassFileWriter(true);
51:                 this.classWriter = new JavaClassFileWriter(true);
52:                 this.aspectWriter = new JavaAspectClassFileWriter(true);
53:                 this.exceptionWriter = new ExceptionFileWriter(true);
54:                 this.rootDir = new File(rootDir);
55:                 
56:                 try {
57:                         this.addDependency(clipper);
58:                 } catch (final CyclicDependencyException e) {
59:                         // should not happen
60:                         e.printStackTrace();
61:                         throw new Error("Dependency tasks are cyclic in FileWriterTask.");
62:                 }
63:         }
64:         
65:         /**
66:          * Writes the given {@link GenClassClass}.
67:          */
68:         @Override
69:         public void handleClassClass(final GenClassClass cc) throws TaskException {
70:                 cc.accept(new GenClassClassVisitor() {
71:                         @Override
72:                         public void handle(final GenAspect aspect) {
73:                                 final FileHeaderWriter writer = new FileHeaderWriter(FileWriterTask.this.aspectWriter);
74:                                 writer.writeGenClass(aspect, FileWriterTask.this.rootDir);
75:                         }
76:                         
77:                         @Override
78:                         public void handle(final GenUserClass userclass) {
79:                                 final FileHeaderWriter writer = new FileHeaderWriter(FileWriterTask.this.classWriter);
80:                                 writer.writeGenClass(userclass, FileWriterTask.this.rootDir);
81:                         }
82:                         
83:                         @Override
84:                         public void handle(final GenJavaException javaE) {
85:                                 // nothing to do
86:                         }
87:                         
88:                         @Override
89:                         public void handle(final GenAnyType anyType) {
90:                                 // nothing to do
91:                         }
92:                         
93:                         @Override
94:                         public void handle(final GenException exceptionClass) {
95:                                 final FileHeaderWriter headerWriter = new FileHeaderWriter(FileWriterTask.this.exceptionWriter);
96:                                 headerWriter.writeGenClass(exceptionClass, FileWriterTask.this.rootDir);
97:                         }
98:                         
99:                         @Override
100:                         public void handle(final GenExternalClassClass externalClass) {
101:                                 // nothing to do
102:                         }
103:                 });
104:         }
105:         
106:         /**
107:          * Writes the given {@link GenInterfaceClass}.
108:          */
109:         @Override
110:         public void handleInterfaceClass(final GenInterfaceClass ic) throws TaskException {
111:                 ic.accept(new GenInterfaceClassVisitor() {
112:                         
113:                         @Override
114:                         public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
115:                                 
116:                                 final FileHeaderWriter writer = new FileHeaderWriter(FileWriterTask.this.interfaceWriter);
117:                                 writer.writeGenClass(interfaceWithImplClass, FileWriterTask.this.rootDir);
118:                                 
119:                                 final FileHeaderWriter classWriter = new FileHeaderWriter(FileWriterTask.this.classWriter);
120:                                 classWriter.writeGenClass(interfaceWithImplClass.getClassRepresentation(), FileWriterTask.this.rootDir);
121:                                 
122:                         }
123:                         
124:                         @Override
125:                         public void handle(final GenSimpleInterfaceClass simpleInterface) {
126:                                 
127:                                 final FileHeaderWriter writer = new FileHeaderWriter(FileWriterTask.this.interfaceWriter);
128:                                 writer.writeGenClass(simpleInterface, FileWriterTask.this.rootDir);
129:                         }
130:                         
131:                         @Override
132:                         public void handle(final GenExternalInterfaceClass iface) {
133:                                 // nothing to do, interface must already exist
134:                         }
135:                 });
136:         }
137:         
138:         @Override
139:         public void finalizeTask() throws TaskException {
140:                 // nothing to do
141:         }
142:         
143:         @Override
144:         public String toString() {
145:                 return "Filewriting";
146:         }
147:         
148:         @Override
149:         public void handleOperation(final GenOperation o) throws TaskException {
150:                 // nothing to do
151:         }
152: }