Skip to contentMethod: generateJava(Model, String)
1: package de.fhdw.wtf.facade;
2:
3: import java.io.IOException;
4: import java.util.Collection;
5: import java.util.concurrent.ExecutionException;
6:
7: import de.fhdw.wtf.common.ast.Model;
8: import de.fhdw.wtf.common.exception.editor.GeneralCheckException;
9: import de.fhdw.wtf.common.exception.editor.MultipleCheckExceptions;
10: import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
11: import de.fhdw.wtf.common.exception.walker.CyclicPartDefinitionException;
12: import de.fhdw.wtf.common.task.DependencyTask;
13: import de.fhdw.wtf.common.task.GroupDependencyTask;
14: import de.fhdw.wtf.common.task.TaskExecutorFixed;
15: import de.fhdw.wtf.common.task.result.ExceptionalTaskResult;
16: import de.fhdw.wtf.common.task.result.OKTaskResult;
17: import de.fhdw.wtf.common.task.result.TaskResult;
18: import de.fhdw.wtf.common.task.result.visitor.TaskResultVisitor;
19: import de.fhdw.wtf.generator.database.generation.InitialGenerator;
20: import de.fhdw.wtf.generator.database.tasks.AttributeGenerationTask;
21: import de.fhdw.wtf.generator.database.tasks.SpecializationGenerationTask;
22: import de.fhdw.wtf.generator.database.tasks.TypeGenerationTask;
23: import de.fhdw.wtf.generator.java.generatorModel.GeneratorModel;
24: import de.fhdw.wtf.generator.transformer.clipper.ClipToFileTask;
25: import de.fhdw.wtf.generator.transformer.clipper.ClipperConfiguration;
26: import de.fhdw.wtf.generator.transformer.clipper.LinkToGenClassTask;
27: import de.fhdw.wtf.generator.transformer.transformers.classTransformer.AppStarterTransformer;
28: import de.fhdw.wtf.generator.transformer.transformers.classTransformer.ConstructorCallGenerationTask;
29: import de.fhdw.wtf.generator.transformer.transformers.classTransformer.ConstructorSymmetricAttribute;
30: import de.fhdw.wtf.generator.transformer.transformers.classTransformer.DelegationTransformer;
31: import de.fhdw.wtf.generator.transformer.transformers.classTransformer.FactoryTransformer;
32: import de.fhdw.wtf.generator.transformer.transformers.classTransformer.InheritanceTransformer;
33: import de.fhdw.wtf.generator.transformer.transformers.classTransformer.OperationAttributeTransformer;
34: import de.fhdw.wtf.generator.transformer.transformers.classTransformer.TypeTransformer;
35: import de.fhdw.wtf.generator.transformer.visitorTransformation.VisitorTypeTransformer;
36: import de.fhdw.wtf.generator.writer.tasks.FileWriterTask;
37: import de.fhdw.wtf.persistence.exception.PersistenceException;
38: import de.fhdw.wtf.persistence.facade.OracleDataBasePreparator;
39: import de.fhdw.wtf.persistence.facade.OracleDatabaseManager;
40: import de.fhdw.wtf.persistence.facade.OracleObjectFacadeImplementation;
41: import de.fhdw.wtf.persistence.utils.PropertiesReaderFile;
42: import de.fhdw.wtf.tooling.SyntaxCheckAbstract;
43:
44: /**
45: * This class provides operations for generating Java-sources and generating the needed database for an AST-Model.
46: */
47: public final class ModelManager extends SyntaxCheckAbstract {
48:
49: /**
50: * The one existing instance of ModelManager.
51: */
52: private static ModelManager instance;
53:
54: /**
55: * Provides the one Instance for ModelManager.
56: *
57: * @return ModelManager
58: */
59: public static synchronized ModelManager getInstance() {
60: if (instance == null) {
61: instance = new ModelManager();
62: }
63: return instance;
64: }
65:
66: /**
67: * Constructs a ModelManager.
68: */
69: private ModelManager() {
70:
71: }
72:
73: /**
74: * Generates Java and aspectJ files to the given directory.
75: *
76: * @param referencedModel
77: * model must be referenced successfully before
78: * @param modelRootDirectory
79: * Root directory to generate Java sources in.
80: * @throws MultipleCheckExceptions
81: * An exception that represents many exceptions that occured while generating.
82: * @return The produced GeneratorModel.
83: */
84: public GeneratorModel generateJava(final Model referencedModel, final String modelRootDirectory)
85: throws MultipleCheckExceptions {
86: final ClipperConfiguration configurationClip =
87: new ClipperConfiguration(modelRootDirectory + "clipper/generated/model", modelRootDirectory
88: + "/generated/model");
89: final ClipperConfiguration configurationLink =
90: new ClipperConfiguration(modelRootDirectory + "clipper/", modelRootDirectory);
91: return this.generateJava(referencedModel, modelRootDirectory, configurationClip, configurationLink, true);
92: }
93:
94: /**
95: * Generates Java and aspectJ files to the given directory.
96: *
97: * @param referencedModel
98: * model must be referenced successfully before
99: * @param modelRootDirectory
100: * Root directory to generate Java sources in. If null, the file writer task is not started.
101: * @param configurationClip
102: * The configuration for the ClipToFileTask.
103: * @param configurationLink
104: * The configuration for the LinkToGenClassTask.
105: * @param runVisitorAndFactoryGenerators
106: * If true, the visitor and factory generators are run.
107: * @throws MultipleCheckExceptions
108: * An exception that represents many exceptions that occured while generating.
109: * @return The produced GeneratorModel.
110: */
111: public GeneratorModel generateJava(final Model referencedModel,
112: final String modelRootDirectory,
113: final ClipperConfiguration configurationClip,
114: final ClipperConfiguration configurationLink,
115: final boolean runVisitorAndFactoryGenerators) throws MultipleCheckExceptions {
116: final MultipleCheckExceptions results = new MultipleCheckExceptions();
117: final TaskExecutorFixed exec = TaskExecutorFixed.create();
118: final GeneratorModel javaGeneratorModel = GeneratorModel.create();
119:
120: final GroupDependencyTask transformers = new GroupDependencyTask(exec);
121: /* WalkerTasks and WalkerTasks for types */
122: try {
123: final TypeTransformer typeTransformer = new TypeTransformer(referencedModel, exec, javaGeneratorModel);
124:
125: final OperationAttributeTransformer operationAttributeTransformer =
126: OperationAttributeTransformer.create(referencedModel, exec, javaGeneratorModel, typeTransformer);
127:
128: final ConstructorCallGenerationTask constructorCallGenerationTask =
129: new ConstructorCallGenerationTask(referencedModel, exec, javaGeneratorModel);
130:
131: constructorCallGenerationTask.addDependency(typeTransformer);
132:
133: final InheritanceTransformer inheritanceTransformer =
134: new InheritanceTransformer(referencedModel, exec, javaGeneratorModel, operationAttributeTransformer);
135:
136: inheritanceTransformer.addDependency(constructorCallGenerationTask);
137:
138: final ConstructorSymmetricAttribute constructorSymmetricAttribute =
139: new ConstructorSymmetricAttribute(referencedModel, exec, javaGeneratorModel);
140:
141: constructorSymmetricAttribute.addDependency(constructorCallGenerationTask);
142: constructorSymmetricAttribute.addDependency(operationAttributeTransformer);
143:
144: transformers.addMembers(
145: typeTransformer,
146: operationAttributeTransformer,
147: constructorCallGenerationTask,
148: inheritanceTransformer);
149:
150: if (runVisitorAndFactoryGenerators) {
151: final VisitorTypeTransformer typeVisitor =
152: VisitorTypeTransformer
153: .create(referencedModel, exec, javaGeneratorModel, inheritanceTransformer);
154: final DependencyTask appStarterTransformer =
155: new AppStarterTransformer(exec, javaGeneratorModel, inheritanceTransformer);
156: appStarterTransformer.addDependency(typeVisitor);
157: final DependencyTask factoryTransformer =
158: new FactoryTransformer(exec, javaGeneratorModel, inheritanceTransformer);
159: factoryTransformer.addDependency(appStarterTransformer);
160:
161: // TODO der FinderTransformer muss eventuell eingebunden werden (und
162: // Dependencies hinzugefügt werden)
163: transformers.addMembers(typeVisitor, appStarterTransformer, factoryTransformer);
164: final DelegationTransformer delegationTransformer =
165: new DelegationTransformer(referencedModel, exec, javaGeneratorModel);
166: delegationTransformer.addDependency(transformers);
167: }
168: } catch (final CyclicPartDefinitionException | CyclicDependencyException e) {
169: throw new SystemException(e);
170: }
171:
172: /* Clipper */
173: final GroupDependencyTask clipper = new GroupDependencyTask(exec);
174: final ClipToFileTask clipperImport = new ClipToFileTask(exec, configurationClip);
175: final LinkToGenClassTask methodInsertion =
176: new LinkToGenClassTask(exec, javaGeneratorModel, configurationLink, clipperImport);
177: try {
178: clipper.addMembers(clipperImport, methodInsertion);
179: clipper.addDependency(transformers);
180: } catch (final CyclicPartDefinitionException | CyclicDependencyException e) {
181: throw new SystemException(e);
182: }
183:
184: if (modelRootDirectory != null) {
185: new FileWriterTask(exec, javaGeneratorModel, modelRootDirectory, clipper);
186: }
187:
188: try {
189: exec.startAllKnownTasks();
190: final Collection<TaskResult> resultTasks = exec.getResultsAndShutdown();
191: this.addsExceptionalTasksToMultipleExceptions(results, resultTasks);
192:
193: } catch (final InterruptedException | ExecutionException e) {
194: throw new SystemException(e);
195: }
196:
197: if (!results.isEmpty()) {
198: throw results;
199: }
200:
201: return javaGeneratorModel;
202: }
203:
204: /**
205: * Generates initial persistence and deletes all existing data!
206: *
207: * @param model
208: * The AST-Model to generate persistence for.
209: * @param genModel
210: * The Generator model.
211: * @param dbPropertiesPath
212: * The path to connection-constants for accessing the database.
213: * @throws MultipleCheckExceptions
214: * An exception that represents many exceptions that occured while generating.
215: */
216: public void generatePersistence(final Model model, final GeneratorModel genModel, final String dbPropertiesPath)
217: throws MultipleCheckExceptions {
218: final MultipleCheckExceptions results = new MultipleCheckExceptions();
219: try {
220: this.prepareDatabase(dbPropertiesPath);
221:
222: final InitialGenerator generator = new InitialGenerator();
223: final TaskExecutorFixed taskManager = TaskExecutorFixed.create();
224:
225: final TypeGenerationTask typeGenerationTask =
226: new TypeGenerationTask(model, genModel, taskManager, generator);
227: final AttributeGenerationTask attributeGenerationTask =
228: new AttributeGenerationTask(model, taskManager, generator);
229: final SpecializationGenerationTask specializationGenerationTask =
230: new SpecializationGenerationTask(model, taskManager, generator);
231:
232: attributeGenerationTask.addDependency(typeGenerationTask);
233: specializationGenerationTask.addDependency(typeGenerationTask);
234:
235: taskManager.startAllKnownTasks();
236:
237: final Collection<TaskResult> resultTasks = taskManager.getResultsAndShutdown();
238: this.addsExceptionalTasksToMultipleExceptions(results, resultTasks);
239: } catch (final PersistenceException e) {
240: results.add(new GeneralCheckException(e));
241: } catch (final InterruptedException | ExecutionException | CyclicDependencyException | IOException e) {
242: throw new SystemException(e);
243: }
244: if (!results.isEmpty()) {
245: throw results;
246: }
247:
248: }
249:
250: /**
251: * Inspects TaskResults and adds corresponding CheckExceptions to list.
252: *
253: * @param list
254: * A list of exceptions encapsulated as MultipleCheckException.
255: * @param taskresults
256: * A collection of the results of executed tasks.
257: */
258: private void addsExceptionalTasksToMultipleExceptions(final MultipleCheckExceptions list,
259: final Collection<TaskResult> taskresults) {
260: for (final TaskResult taskResult : taskresults) {
261: taskResult.accept(new TaskResultVisitor() {
262:
263: @Override
264: public void handleOkTaskResult(final OKTaskResult result) {
265: // nothing to do
266: }
267:
268: @Override
269: public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
270: // TODO get Markable Exceptions
271: list.add(new GeneralCheckException(result.getError()));
272: }
273: });
274: }
275: }
276:
277: /**
278: * Trys to prepare the database by generating the meta-structure and procedures.
279: *
280: * @param propertiesPath
281: * Path for a file with connection-constants.
282: * @throws IOException
283: * Thrown when the file with connection-constants could not be accessed.
284: * @throws PersistenceException
285: * Thrown when some error in the persistence layer occured.
286: */
287: private void prepareDatabase(final String propertiesPath) throws IOException, PersistenceException {
288:
289: final OracleDatabaseManager oracleDatabaseManager = OracleDatabaseManager.getInstance();
290: final PropertiesReaderFile prop = new PropertiesReaderFile();
291: prop.initialize(propertiesPath);
292: oracleDatabaseManager.setConnectionConstantsFromFile(prop);
293: oracleDatabaseManager.connect();
294:
295: final OracleDataBasePreparator preparator = new OracleDataBasePreparator();
296: if (!preparator.isTableStructureValid()) {
297: preparator.dropWholeSchema();
298: preparator.createWholeSchema();
299: }
300: if (!preparator.areProceduresCreated()) {
301: preparator.createProcedures();
302: }
303: new OracleObjectFacadeImplementation(oracleDatabaseManager, null).clear();
304: oracleDatabaseManager.getClassFacade().clear();
305: }
306: }
![[Jenkins]](/jenkins/static/5c0124f8/images/svgs/logo.svg){kind=logo}
