1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
package org.qedeq.kernel.bo.logic.model; |
17 |
|
|
18 |
|
import java.util.ArrayList; |
19 |
|
import java.util.HashMap; |
20 |
|
import java.util.List; |
21 |
|
import java.util.Map; |
22 |
|
import java.util.Vector; |
23 |
|
|
24 |
|
|
25 |
|
|
26 |
|
|
27 |
|
|
28 |
|
@author |
29 |
|
|
|
|
| 87.3% |
Uncovered Elements: 14 (110) |
Complexity: 34 |
Complexity Density: 0.55 |
|
30 |
|
public abstract class DynamicModel implements Model { |
31 |
|
|
32 |
|
|
33 |
|
public static final Predicate FALSE = new Predicate(0, 99, "F", "always false") { |
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
34 |
88588
|
public boolean calculate(final Entity[] entities) {... |
35 |
88588
|
return false; |
36 |
|
} |
37 |
|
}; |
38 |
|
|
39 |
|
|
40 |
|
public static final Predicate TRUE = new Predicate(0, 99, "T", "always true") { |
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
41 |
99113
|
public boolean calculate(final Entity[] entities) {... |
42 |
99113
|
return true; |
43 |
|
} |
44 |
|
}; |
45 |
|
|
46 |
|
|
47 |
|
public static final Predicate EVEN = new Predicate(0, 99, "| 2", "is even") { |
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 2 |
Complexity Density: 0.5 |
|
48 |
27897
|
public boolean calculate(final Entity[] entities) {... |
49 |
27897
|
boolean result = true; |
50 |
58192
|
for (int i = 0; i < entities.length; i++) { |
51 |
30295
|
result &= entities[i].getValue() % 2 == 0; |
52 |
|
} |
53 |
27897
|
return result; |
54 |
|
} |
55 |
|
}; |
56 |
|
|
57 |
|
|
58 |
|
public static final Predicate LESS = new Predicate(0, 99, "<", "less") { |
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 2 |
Complexity Density: 0.5 |
|
59 |
3448
|
public boolean calculate(final Entity[] entities) {... |
60 |
3448
|
boolean result = true; |
61 |
6896
|
for (int i = 0; i < entities.length - 1; i++) { |
62 |
3448
|
result &= entities[i].getValue() < entities[i + 1].getValue(); |
63 |
|
} |
64 |
3448
|
return result; |
65 |
|
} |
66 |
|
}; |
67 |
|
|
68 |
|
|
69 |
|
public static final Predicate NOT_LESS = Predicate.not(LESS); |
70 |
|
|
71 |
|
|
72 |
|
public static final Predicate EQUAL = new Predicate(0, 99, "=", "equal") { |
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 2 |
Complexity Density: 0.5 |
|
73 |
8960
|
public boolean calculate(final Entity[] entities) {... |
74 |
8960
|
boolean result = true; |
75 |
17920
|
for (int i = 0; i < entities.length - 1; i++) { |
76 |
8960
|
result &= entities[i].getValue() == entities[i + 1].getValue(); |
77 |
|
} |
78 |
8960
|
return result; |
79 |
|
} |
80 |
|
}; |
81 |
|
|
82 |
|
|
83 |
|
public static final Predicate NOT_EQUAL = Predicate.not(EQUAL); |
84 |
|
|
85 |
|
|
86 |
|
private final String name; |
87 |
|
|
88 |
|
|
89 |
|
private final List entities; |
90 |
|
|
91 |
|
|
92 |
|
private final Vector functionPool; |
93 |
|
|
94 |
|
|
95 |
|
private final Vector predicatePool; |
96 |
|
|
97 |
|
|
98 |
|
private final Map predicateConstants; |
99 |
|
|
100 |
|
|
101 |
|
private final Map functionConstants; |
102 |
|
|
103 |
|
|
104 |
|
|
105 |
|
|
106 |
|
@param |
107 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 1 |
Complexity Density: 0.1 |
|
108 |
193
|
public DynamicModel(final String name) {... |
109 |
193
|
this.name = name; |
110 |
193
|
entities = new ArrayList(); |
111 |
193
|
functionPool = new Vector(); |
112 |
193
|
predicatePool = new Vector(); |
113 |
|
|
114 |
193
|
predicateConstants = new HashMap(); |
115 |
193
|
predicateConstants.put(new ModelPredicateConstant("TRUE", 0), TRUE); |
116 |
193
|
predicateConstants.put(new ModelPredicateConstant("FALSE", 0), FALSE); |
117 |
193
|
predicateConstants.put(new ModelPredicateConstant("equal", 2), EQUAL); |
118 |
193
|
predicateConstants.put(new ModelPredicateConstant("notEqual", 2), NOT_EQUAL); |
119 |
193
|
functionConstants = new HashMap(); |
120 |
|
} |
121 |
|
|
122 |
|
|
123 |
|
|
124 |
|
|
125 |
|
@return |
126 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
127 |
0
|
public String getName() {... |
128 |
0
|
return name; |
129 |
|
} |
130 |
|
|
131 |
|
|
132 |
|
|
133 |
|
|
134 |
|
@return |
135 |
|
|
136 |
|
public abstract String getDescription(); |
137 |
|
|
138 |
|
|
139 |
|
|
140 |
|
|
141 |
|
@param |
142 |
|
@param |
143 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
144 |
196
|
public void addPredicateConstant(final ModelPredicateConstant constant, final Predicate predicate) {... |
145 |
196
|
predicateConstants.put(constant, predicate); |
146 |
|
} |
147 |
|
|
148 |
|
|
149 |
|
|
150 |
|
|
151 |
|
@param |
152 |
|
@param |
153 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
154 |
0
|
public void addFunctionConstant(final ModelFunctionConstant constant, final Function function) {... |
155 |
0
|
functionConstants.put(constant, function); |
156 |
|
} |
157 |
|
|
|
|
| 60% |
Uncovered Elements: 2 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
158 |
675
|
protected void addEntity(final Entity entity) {... |
159 |
675
|
if (entities.size() != entity.getValue()) { |
160 |
0
|
throw new RuntimeException("entity value should have been " + entities.size() |
161 |
|
+ " but was " + entity.getValue()); |
162 |
|
} |
163 |
|
|
164 |
675
|
entities.add(entity); |
165 |
|
} |
166 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
167 |
347609
|
public int getEntitiesSize() {... |
168 |
347609
|
return entities.size(); |
169 |
|
} |
170 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
171 |
491419
|
public Entity getEntity(final int number) {... |
172 |
491419
|
return (Entity) entities.get(number); |
173 |
|
} |
174 |
|
|
|
|
| 80% |
Uncovered Elements: 2 (10) |
Complexity: 3 |
Complexity Density: 0.5 |
|
175 |
14020
|
public int getPredicateSize(final int size) {... |
176 |
14020
|
if (predicatePool.size() <= size) { |
177 |
626
|
return 0; |
178 |
|
} |
179 |
13394
|
final List list = (List) predicatePool.get(size); |
180 |
13394
|
if (list == null) { |
181 |
0
|
return 0; |
182 |
|
} |
183 |
13394
|
return list.size(); |
184 |
|
} |
185 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
186 |
367983
|
public Predicate getPredicate(final int size, final int number) {... |
187 |
367983
|
final List predicateForSize = (List) predicatePool.get(size); |
188 |
367983
|
return (Predicate) predicateForSize.get(number); |
189 |
|
} |
190 |
|
|
191 |
|
|
192 |
|
|
193 |
|
|
194 |
|
@param |
195 |
|
@param |
196 |
|
|
|
|
| 91.7% |
Uncovered Elements: 1 (12) |
Complexity: 4 |
Complexity Density: 0.67 |
|
197 |
3000
|
public void addPredicate(final int size, final Predicate predicate) {... |
198 |
3000
|
if (getPredicateSize(size) == 0) { |
199 |
626
|
if (predicatePool.size() <= size) { |
200 |
1252
|
for (int i = predicatePool.size(); i <= size; i++) { |
201 |
626
|
predicatePool.add(new ArrayList()); |
202 |
|
} |
203 |
|
} |
204 |
|
} |
205 |
3000
|
List list = (List) predicatePool.get(size); |
206 |
3000
|
list.add(predicate); |
207 |
|
} |
208 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
209 |
54897
|
public Predicate getPredicateConstant(final ModelPredicateConstant con) {... |
210 |
54897
|
return (Predicate) predicateConstants.get(con); |
211 |
|
} |
212 |
|
|
|
|
| 80% |
Uncovered Elements: 2 (10) |
Complexity: 3 |
Complexity Density: 0.5 |
|
213 |
2034
|
public int getFunctionSize(final int size) {... |
214 |
2034
|
if (functionPool.size() <= size) { |
215 |
438
|
return 0; |
216 |
|
} |
217 |
1596
|
final List list = (List) functionPool.get(size); |
218 |
1596
|
if (list == null) { |
219 |
0
|
return 0; |
220 |
|
} |
221 |
1596
|
return list.size(); |
222 |
|
} |
223 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
224 |
512
|
public Function getFunction(final int size, final int number) {... |
225 |
512
|
final List functionForSize = (List) functionPool.get(size); |
226 |
512
|
return (Function) functionForSize.get(number); |
227 |
|
} |
228 |
|
|
229 |
|
|
230 |
|
|
231 |
|
|
232 |
|
@param |
233 |
|
@param |
234 |
|
|
|
|
| 91.7% |
Uncovered Elements: 1 (12) |
Complexity: 4 |
Complexity Density: 0.67 |
|
235 |
2004
|
public void addFunction(final int size, final Function function) {... |
236 |
2004
|
if (getFunctionSize(size) == 0) { |
237 |
438
|
if (functionPool.size() <= size) { |
238 |
876
|
for (int i = functionPool.size(); i <= size; i++) { |
239 |
438
|
functionPool.add(new ArrayList()); |
240 |
|
} |
241 |
|
} |
242 |
|
} |
243 |
2004
|
final List list = (List) functionPool.get(size); |
244 |
2004
|
list.add(function); |
245 |
|
} |
246 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
247 |
0
|
public Function getFunctionConstant(final ModelFunctionConstant con) {... |
248 |
0
|
return (Function) functionConstants.get(con); |
249 |
|
} |
250 |
|
|
251 |
|
public abstract Entity comprehension(final Entity[] array); |
252 |
|
|
253 |
|
} |