Method: finalizeTask()

1: package de.fhdw.wtf.walker.tasks;
2:
3: import de.fhdw.wtf.common.ast.Attribute;
4: import de.fhdw.wtf.common.ast.ConstructorOrOperation;
5: import de.fhdw.wtf.common.ast.Group;
6: import de.fhdw.wtf.common.ast.Model;
7: import de.fhdw.wtf.common.ast.Operation;
8: import de.fhdw.wtf.common.ast.OperationModifierAbstract;
9: import de.fhdw.wtf.common.ast.type.ClassModifierAbstract;
10: import de.fhdw.wtf.common.ast.type.ClassType;
11: import de.fhdw.wtf.common.exception.walker.AbstractOperationsException;
12: import de.fhdw.wtf.common.exception.walker.TaskException;
13: import de.fhdw.wtf.common.task.TaskExecutor;
14: import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
15:
16: /**
17: * This Task check that only abstract classes has abstract oparations!
18: *
19: */
20: public final class AbstractOperationsCheck extends SimpleWalkerTask {
21:         
22:         /**
23:          * Constructor of {@link AbstractOperationsCheck}.
24:          *
25:          * @param m
26:          * model
27:          * @param taskmanager
28:          * taskmanager
29:          */
30:         private AbstractOperationsCheck(final Model m, final TaskExecutor taskmanager) {
31:                 super(m, taskmanager);
32:         }
33:         
34:         /**
35:          * Creates a {@link AbstractOperationsCheck}-Object.
36:          *
37:          * @param m
38:          * model
39:          * @param taskmanager
40:          * taskmanager
41:          * @return The {@link AbstractOperationsCheck}-Object.
42:          */
43:         public static AbstractOperationsCheck create(final Model m, final TaskExecutor taskmanager) {
44:                 return new AbstractOperationsCheck(m, taskmanager);
45:         }
46:         
47:         @Override
48:         public void handleGroup(final Group g) throws TaskException {
49:                 // Nothing to do here
50:         }
51:         
52:         @Override
53:         public void handleClass(final ClassType c) throws TaskException {
54:                 final boolean isAbstractClass = c.getModifiers().contains(ClassModifierAbstract.create(null));
55:                 if (!isAbstractClass) {
56:                         final OperationModifierAbstract operationModifierAbstract = OperationModifierAbstract.create(null);
57:                         for (final Operation op : c.getOperations()) {
58:                                 if (op.getModifiers().contains(operationModifierAbstract)) {
59:                                         throw AbstractOperationsException.create(op.getFirstToken(), op.getLastToken());
60:                                 }
61:                         }
62:                 }
63:         }
64:         
65:         @Override
66:         public void handleAttribute(final Attribute a, final ClassType owner) throws TaskException {
67:                 // Nothing to do here
68:         }
69:         
70:         @Override
71:         public void finalizeTask() throws TaskException {
72:                 // Nothing to do here
73:         }
74:         
75:         @Override
76:         public void beginTask() throws TaskException {
77:                 // Nothing to do here
78:         }
79:         
80:         @Override
81:         public void handleConstructorOrOperation(final ConstructorOrOperation coo, final ClassType owner)
82:                         throws TaskException {
83:                 // Nothing to do here.
84:                 
85:         }
86: }