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