1 package de.fhdw.wtf.walker.tasks;
2
3 import de.fhdw.wtf.common.ast.Model;
4 import de.fhdw.wtf.common.ast.Operation;
5 import de.fhdw.wtf.common.ast.type.AtomicType;
6 import de.fhdw.wtf.common.ast.type.BaseType;
7 import de.fhdw.wtf.common.ast.type.ClassType;
8 import de.fhdw.wtf.common.ast.type.CompositeType;
9 import de.fhdw.wtf.common.ast.type.Type;
10 import de.fhdw.wtf.common.ast.type.TypeProxy;
11 import de.fhdw.wtf.common.ast.visitor.AtomicTypeVisitor;
12 import de.fhdw.wtf.common.ast.visitor.TypeVisitor;
13 import de.fhdw.wtf.common.exception.walker.TaskException;
14 import de.fhdw.wtf.common.task.TaskExecutor;
15 import de.fhdw.wtf.walker.walker.SimpleWalkerTaskForTypes;
16
17 public class FillOverrideOperationWalker extends SimpleWalkerTaskForTypes {
18
19 public FillOverrideOperationWalker(final Model m, final TaskExecutor taskmanager) {
20 super(m, taskmanager);
21
22 }
23
24 @Override
25 public void handleType(final Type c) throws TaskException {
26 final java.util.Iterator<Type> TypeIterator = c.getSuperTypes().iterator();
27 while (TypeIterator.hasNext()) {
28 final Type currentType = TypeIterator.next();
29 currentType.accept(new TypeVisitor() {
30
31 @Override
32 public void handle(final TypeProxy typeProxy) {
33
34
35 }
36
37 @Override
38 public void handle(final CompositeType compositeType) {
39
40
41 }
42
43 @Override
44 public void handle(final AtomicType atomicType) {
45 atomicType.accept(new AtomicTypeVisitor() {
46
47 @Override
48 public void handle(final ClassType clazz) {
49 final java.util.Iterator<Operation> operationIterator = clazz.getOperations().iterator();
50 while (operationIterator.hasNext()) {
51 final Operation currentOperation = operationIterator.next();
52 final java.util.Iterator<Type> currentOperationSuperClassIterator =
53 currentOperation.getContainingType().getSuperTypes().iterator();
54 final Type currentSuperType = currentOperationSuperClassIterator.next();
55
56 currentSuperType.accept(new TypeVisitor() {
57
58 @Override
59 public void handle(final TypeProxy typeProxy) {
60
61
62 }
63
64 @Override
65 public void handle(final CompositeType compositeType) {
66
67
68 }
69
70 @Override
71 public void handle(final AtomicType atomicType1) {
72 atomicType1.accept(new AtomicTypeVisitor() {
73
74 @Override
75 public void handle(final ClassType clazz1) {
76 final java.util.Iterator<Operation> operationsInSuperTypeIterator =
77 clazz1.getOperations().iterator();
78
79 final Operation currentOverrideOperation =
80 operationsInSuperTypeIterator.next();
81
82 if (currentOverrideOperation.getSignature().equals(
83 currentOperation.getSignature())) {
84 currentOperation.getOverridingOperations().add(
85 currentOverrideOperation);
86 }
87
88 }
89
90 @Override
91 public void handle(final BaseType baseType) {
92
93
94 }
95 });
96
97 }
98 });
99 }
100
101 }
102
103 @Override
104 public void handle(final BaseType baseType) {
105
106
107 }
108 });
109
110 }
111 });
112 }
113 }
114
115 @Override
116 public void finalizeTask() throws TaskException {
117
118
119 }
120
121 @Override
122 public void beginTask() throws TaskException {
123
124
125 }
126
127 }