Skip to contentMethod: handleInterfaceClass(GenInterfaceClass)
1: package de.fhdw.wtf.generator.transformer.transformers.classTransformer;
2:
3: import java.util.Vector;
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.facade.PackageConstants;
10: import de.fhdw.wtf.generator.java.generatorModel.GenClass;
11: import de.fhdw.wtf.generator.java.generatorModel.GenClassClass;
12: import de.fhdw.wtf.generator.java.generatorModel.GenClassModifier;
13: import de.fhdw.wtf.generator.java.generatorModel.GenComment;
14: import de.fhdw.wtf.generator.java.generatorModel.GenException;
15: import de.fhdw.wtf.generator.java.generatorModel.GenExternalInterfaceClass;
16: import de.fhdw.wtf.generator.java.generatorModel.GenImportType;
17: import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceClass;
18: import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceWithClassImplClass;
19: import de.fhdw.wtf.generator.java.generatorModel.GenJavaAttribute;
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.GenOperationModifier;
23: import de.fhdw.wtf.generator.java.generatorModel.GenPackage;
24: import de.fhdw.wtf.generator.java.generatorModel.GenParameter;
25: import de.fhdw.wtf.generator.java.generatorModel.GenSimpleInterfaceClass;
26: import de.fhdw.wtf.generator.java.generatorModel.GenUnqualifiedPackage;
27: import de.fhdw.wtf.generator.java.generatorModel.GenUserClass;
28: import de.fhdw.wtf.generator.java.generatorModel.GenVisibility;
29: import de.fhdw.wtf.generator.java.generatorModel.GenVoidType;
30: import de.fhdw.wtf.generator.java.generatorModel.GeneratorModel;
31: import de.fhdw.wtf.generator.java.visitor.GenInterfaceClassVisitorException;
32: import de.fhdw.wtf.generator.java.walker.SimpleGeneratorModelWalkerTask;
33:
34: /**
35: * Generates the ApplicationStarter class into the {@link GeneratorModel} that is used to initialize all Factory classes
36: * for all userdefined Types.<br>
37: * The generates class contains the following operations where ... is variable <br>
38: *
39: * <pre>
40: * <code>
41: * protected String getModelPrefix() {
42: * ...
43: * }
44: * protected String getApplicationConfigFileName() {
45: * ...
46: * }
47: * protected String getDatabaseConfigFileName() {
48: * ...
49: * }
50: * protected String getResourcesPath() {
51: * ...
52: * }
53: * protected void registerTypeFactories(de.fhdw.wtf.context.core.ObjectFactoryProvider objectFactoryProvider, de.fhdw.wtf.persistence.facade.TypeManager typeManager) {
54: * try {
55: * objectFactoryProvider.registerTypeFactory(typeManager, ... , new ...Factory());
56: * ... For any Usertype ...
57: * }catch (de.fhdw.wtf.persistence.exception.TypeOrAssociationNotFoundException e) {e.printStackTrace();}
58: * }</code>
59: * </pre>
60: *
61: */
62: public class AppStarterTransformer extends SimpleGeneratorModelWalkerTask {
63:
64: private static final String NEW_LINE = "\n";
65: private final StringBuilder method;
66:
67: public AppStarterTransformer(final TaskExecutor taskmanager,
68: final GeneratorModel javaGeneratorModel,
69: final DependencyTask inheritanceTransformer) {
70: super(taskmanager, javaGeneratorModel);
71: this.method = new StringBuilder();
72: this.method.append("try {");
73: this.method.append(NEW_LINE);
74:
75: try {
76: this.addDependency(inheritanceTransformer);
77: } catch (final CyclicDependencyException e) {
78: // should not happen
79: e.printStackTrace();
80: throw new Error("Dependency tasks are cyclic in AppStarterTransformer.");
81: }
82: }
83:
84: @Override
85: public void handleClassClass(final GenClassClass cc) throws TaskException {
86: if (!cc.getModifieres().contains(GenClassModifier.ABSTRACT)
87: && (cc.getFullyQualifiedTypeName().startsWith("generated.model.") || cc.getFullyQualifiedTypeName()
88: .startsWith("generated.products."))) {
89: AppStarterTransformer.this.generateFactoryRegistrationCall(cc, cc);
90: }
91: }
92:
93: /**
94: * Adds the line that initialize the Factory of the current cc at the methodbody of operation.
95: */
96: @Override
97: public void handleInterfaceClass(final GenInterfaceClass ic) throws TaskException {
98: ic.accept(new GenInterfaceClassVisitorException<TaskException>() {
99:
100: @Override
101: public void handle(final GenSimpleInterfaceClass simpleInterface) throws TaskException {
102: // nothing to do
103: }
104:
105: @Override
106: public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) throws TaskException {
107: final GenClassClass cc = interfaceWithImplClass.getClassRepresentation();
108: if (!cc.getModifieres().contains(GenClassModifier.ABSTRACT)) {
109: AppStarterTransformer.this.generateFactoryRegistrationCall(interfaceWithImplClass, cc);
110: }
111: }
112:
113: @Override
114: public void handle(final GenExternalInterfaceClass iface) {
115: // nothing to do
116: }
117: });
118: }
119:
120: /**
121: * Adds a call to register a factory for objects of some class.
122: *
123: * @param iface
124: * The interface class.
125: * @param impl
126: * The implementation class. May be equal to {@link iface}.
127: */
128: private void generateFactoryRegistrationCall(final GenClass iface, final GenClass impl) {
129: this.method.append("\t\t\tobjectFactoryProvider.registerTypeFactory(typeManager, \""
130: + impl.getFullyQualifiedTypeName() + "\", new generated.factories." + iface.getName() + "Factory());");
131: this.method.append(NEW_LINE);
132: }
133:
134: /**
135: * Creates the GeneratedApplicationStartera and adds it to the {@link GeneratorModel}.
136: */
137: @Override
138: public void finalizeTask() throws TaskException {
139: this.method
140: .append("\t\t}catch (de.fhdw.wtf.persistence.exception.TypeOrAssociationNotFoundException e) {e.printStackTrace();}");
141: GenPackage packag = GenUnqualifiedPackage.create("de");
142: packag = packag.addName("fhdw");
143: packag = packag.addName("wtf");
144: packag = packag.addName("context");
145: packag = packag.addName("core");
146: final GenUserClass superC =
147: GenUserClass.create(
148: "ApplicationStarter",
149: new Vector<GenJavaOperation>(),
150: new Vector<GenInterfaceClass>(),
151: new Vector<GenJavaAttribute>(),
152: new Vector<GenClassModifier>(),
153: new Vector<GenJavaOperation>(),
154: null,
155: packag,
156: GenComment.createFromPlainText("", false),
157: "");
158: final GenUserClass appStarter =
159: GenUserClass.create(
160: "GeneratedApplicationStarter",
161: new Vector<GenJavaOperation>(),
162: new Vector<GenInterfaceClass>(),
163: new Vector<GenJavaAttribute>(),
164: new Vector<GenClassModifier>(),
165: new Vector<GenJavaOperation>(),
166: superC,
167: PackageConstants.APPLICATION_PACKAGE,
168: GenComment.createFromPlainText("Kommi", false),
169: "");
170: final GenJavaOperation registerTypeFactories =
171: GenJavaOperation.create(
172: "registerTypeFactories",
173: GenVisibility.PROTECTED,
174: new Vector<GenParameter>(),
175: new Vector<GenException>(),
176: this.method.toString(),
177: GenVoidType.getInstance(),
178: new Vector<GenOperationModifier>(),
179: GenComment.create("@Override"));
180: registerTypeFactories.getParameters().add(
181: GenParameter.create(
182: "objectFactoryProvider",
183: GenImportType.create("de.fhdw.wtf.context.core.ObjectFactoryProvider")));
184: registerTypeFactories.getParameters().add(
185: GenParameter.create("typeManager", GenImportType.create("de.fhdw.wtf.persistence.facade.TypeManager")));
186: final GenJavaOperation getResourcesPathJava =
187: GenJavaOperation.create(
188: "getResourcesPathJava",
189: GenVisibility.PROTECTED,
190: new Vector<GenParameter>(),
191: new Vector<GenException>(),
192: "return \"src/main/resources\";",
193: GenImportType.create("String"),
194: new Vector<GenOperationModifier>(),
195: GenComment.create("@Override"));
196: final GenJavaOperation getResourcesPathServer =
197: GenJavaOperation.create(
198: "getResourcesPathServer",
199: GenVisibility.PROTECTED,
200: new Vector<GenParameter>(),
201: new Vector<GenException>(),
202: "return \"WEB-INF\";",
203: GenImportType.create("String"),
204: new Vector<GenOperationModifier>(),
205: GenComment.create("@Override"));
206: final GenJavaOperation getApplicationConfigFileName =
207: GenJavaOperation.create(
208: "getApplicationConfigFileName",
209: GenVisibility.PROTECTED,
210: new Vector<GenParameter>(),
211: new Vector<GenException>(),
212: "return \"config/application.properties\";",
213: GenImportType.create("String"),
214: new Vector<GenOperationModifier>(),
215: GenComment.create("@Override"));
216: final GenJavaOperation getDatabaseConfigFileName =
217: GenJavaOperation.create(
218: "getDatabaseConfigFileName",
219: GenVisibility.PROTECTED,
220: new Vector<GenParameter>(),
221: new Vector<GenException>(),
222: "return \"config/oracledb.properties\";",
223: GenImportType.create("String"),
224: new Vector<GenOperationModifier>(),
225: GenComment.create("@Override"));
226: final GenJavaOperation getModelPrefix =
227: GenJavaOperation.create(
228: "getModelPrefix",
229: GenVisibility.PROTECTED,
230: new Vector<GenParameter>(),
231: new Vector<GenException>(),
232: "return \"generated.model\";",
233: GenImportType.create("String"),
234: new Vector<GenOperationModifier>(),
235: GenComment.create("@Override"));
236: final GenJavaOperation registerActivities =
237: GenJavaOperation.create(
238: "registerActivities",
239: GenVisibility.PROTECTED,
240: new Vector<GenParameter>(),
241: new Vector<GenException>(),
242: "",
243: GenImportType.create("void"),
244: new Vector<GenOperationModifier>(),
245: GenComment.create("@Override"));
246: appStarter.addOperation(getModelPrefix);
247: appStarter.addOperation(getApplicationConfigFileName);
248: appStarter.addOperation(getDatabaseConfigFileName);
249: appStarter.addOperation(getResourcesPathJava);
250: appStarter.addOperation(registerTypeFactories);
251: appStarter.addOperation(getResourcesPathServer);
252: appStarter.addOperation(registerActivities);
253: this.getGeneratorModel().addNonAstClass(appStarter);
254: }
255:
256: @Override
257: public String toString() {
258: return "ApplicationStarter generation";
259: }
260:
261: @Override
262: public void handleOperation(final GenOperation o) throws TaskException {
263: // nothing to do
264: }
265: }
![[Jenkins]](/jenkins/static/5c0124f8/images/svgs/logo.svg){kind=logo}
