1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 package org.fosstrak.llrp.commander.util;
23
24 import java.lang.reflect.Method;
25 import java.util.LinkedList;
26 import java.util.List;
27 import java.util.Observable;
28 import org.llrp.ltk.types.*;
29 import org.llrp.ltkGenerator.generated.FieldDefinition;
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44 public class LLRPTreeMaintainer extends Observable {
45
46 private final String EMPTY_STRING = "";
47
48 private LLRPMessage root;
49
50 public LLRPTreeMaintainer(LLRPMessage root){
51 this.root = root;
52 }
53
54
55
56
57
58
59 public void setRoot(LLRPMessage root){
60 this.root = root;
61 }
62
63
64
65
66
67
68 public LLRPMessage getRoot() {
69 return root;
70 }
71
72
73
74
75
76
77
78
79
80 public void setChild(Object messageOrParameter, String childName, LLRPParameter child){
81 String methodName = "set" + childName;
82 Object[] methodArguments = {child};
83
84 for (Method method : messageOrParameter.getClass().getMethods()){
85 if (method.getName().equals(methodName)){
86 try {
87 method.invoke(messageOrParameter, methodArguments);
88 } catch (Exception e) {
89 e.printStackTrace();
90 }
91 break;
92 }
93 }
94 setChanged();
95 notifyObservers();
96 }
97
98
99
100
101
102
103
104 public void addChild(List<LLRPParameter> list, LLRPParameter child){
105 list.add(child);
106 setChanged();
107 notifyObservers();
108 }
109
110
111
112
113
114
115
116 public void removeChild(List<LLRPParameter> list, LLRPParameter child){
117 for (LLRPParameter parameter : list){
118 if (parameter == child){
119 list.remove(parameter);
120 break;
121 }
122 }
123 setChanged();
124 notifyObservers();
125 }
126
127
128
129
130
131
132
133
134 public Object getChild(Object messageOrParameter, String childName){
135 Object child = null;
136 String methodName = "get" + childName;
137 if (LLRP.canOccurMultipleTimes(getDefinition(messageOrParameter), childName)){
138 methodName = methodName + "List";
139 }
140 try {
141 child = messageOrParameter.getClass().getMethod(methodName, new Class[0]).invoke(messageOrParameter, new Object[0]);
142 } catch (Exception e) {
143 e.printStackTrace();
144 }
145 return child;
146 }
147
148
149
150
151
152
153
154
155 public List<Object> getNonNullChildren(Object treeElement){
156 List<Object> children = new LinkedList<Object>();
157 if (treeElement instanceof LLRPMessage || treeElement instanceof LLRPParameter){
158 Object messageOrParameterDefinition = getDefinition(treeElement);
159 List<String> childrenNames = LLRP.getParameterAndChoiceNames(messageOrParameterDefinition);
160 for (String childName : childrenNames){
161 Object o = getChild(treeElement, childName);
162 if (o != null){
163 children.add(o);
164 }
165 }
166 }
167 else if (treeElement instanceof List){
168 children = (List<Object>) treeElement;
169 }
170 return children;
171 }
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187 public Object getParent(Object treeElement){
188 return findParent(root, treeElement);
189 }
190
191 private Object findParent(Object ancestor, Object treeElement){
192 Object parent = null;
193 if (treeElement instanceof LLRPMessage){
194
195 parent = null;
196 }
197 else{
198 List<Object> children = getNonNullChildren(ancestor);
199 if (children.size() == 0){
200 parent = null;
201 }
202 else {
203 for (Object o : children){
204 if (o == treeElement){
205 parent = ancestor;
206 break;
207 }
208 else{
209 parent = findParent(o, treeElement);
210 if (parent != null){
211 break;
212 }
213 }
214 }
215 }
216 }
217 return parent;
218 }
219
220
221
222
223
224
225
226
227 public LLRPType getField(Object messageOrParameter, String fieldName) {
228 String methodName = "get" + fieldName;
229 LLRPType field = null;
230 try {
231 field = (LLRPType) messageOrParameter.getClass().getMethod(methodName, new Class[0]).invoke(messageOrParameter, new Object[0]);
232 } catch (Exception e) {
233 e.printStackTrace();
234 }
235 return field;
236 }
237
238
239
240
241
242
243
244
245 public void setField(Object messageOrParameter, String fieldName, LLRPType fieldValue){
246 String methodName = "set" + fieldName;
247 Object[] methodArguments = {fieldValue};
248
249 for (Method method : messageOrParameter.getClass().getMethods()){
250 if (method.getName().equals(methodName)){
251 try {
252 method.invoke(messageOrParameter, methodArguments);
253 } catch (Exception e) {
254 e.printStackTrace();
255 }
256 break;
257 }
258 }
259 setChanged();
260 notifyObservers();
261 }
262
263
264
265
266
267
268
269 public List<LLRPType> getFields(Object messageOrParameter){
270 LinkedList<LLRPType> fields = new LinkedList<LLRPType>();
271 List<FieldDefinition> fieldDefinitions = LLRP.getFieldDefinitions(getDefinition(messageOrParameter));
272 for (int i = 0; i < fieldDefinitions.size(); i++){
273 FieldDefinition fieldDefinition = fieldDefinitions.get(i);
274 fields.add(getField(messageOrParameter, fieldDefinition.getName()));
275 }
276 return fields;
277 }
278
279
280
281
282
283
284
285
286
287 public boolean isValid(Object treeElement){
288 boolean result = isNonRecursivelyValid(treeElement);
289 List<Object> children = getNonNullChildren(treeElement);
290 for (Object o : children){
291 result = result && isValid(o);
292 }
293 return result;
294 }
295
296
297
298
299
300
301
302
303
304 public boolean isNonRecursivelyValid(Object treeElement){
305 if (treeElement instanceof LLRPMessage || treeElement instanceof LLRPParameter){
306 return areFieldsValid(treeElement) && areMandatoryParametersPresent(treeElement) && areListsNonRecursivelyValid(treeElement);
307 }
308 else if (treeElement instanceof List){
309 return validateEmptiness((List<LLRPParameter>) treeElement).equals(EMPTY_STRING);
310 }
311 return false;
312 }
313
314
315
316
317
318
319
320
321
322 public List<Object> getNonRecursivelyInvalidMessageOrParameterDescendants(Object treeElement){
323 List<Object> result = new LinkedList<Object>();
324 if (!isNonRecursivelyValid(treeElement) && !(treeElement instanceof List)){
325 result.add(treeElement);
326 }
327 for (Object child : getNonNullChildren(treeElement)){
328 result.addAll(getNonRecursivelyInvalidMessageOrParameterDescendants(child));
329 }
330 return result;
331 }
332
333
334
335
336
337
338
339
340 public String validateField(Object messageOrParameter, String fieldName){
341 LLRPType field = getField(messageOrParameter, fieldName);
342 if (field == null){
343 return LLRPConstraints.NULL_FIELD_ERROR_MESSAGE;
344 }
345 else{
346 int fieldValue = 0;
347 if (field instanceof LLRPNumberType){
348 fieldValue = ((LLRPNumberType) field).intValue();
349 }
350 else if (field instanceof TwoBitField){
351 fieldValue = ((TwoBitField) field).intValue();
352 }
353 else {
354 return EMPTY_STRING;
355 }
356 LLRPRangeConstraint[] constraints = LLRPConstraints.rangeConstraints;
357 for (int i = 0; i < constraints.length; i++){
358 if (getName(messageOrParameter).equals(constraints[i].getMessageOrParameterName())
359 && fieldName.equals(constraints[i].getFieldName())){
360 String enumerationName = constraints[i].getPreconditionedEnumerationName();
361 if (enumerationName != null){
362 LLRPEnumeration enumeration = (LLRPEnumeration) getField(messageOrParameter, enumerationName);
363 if (enumeration != null &&
364 enumeration.toString().equals(constraints[i].getPreconditionedEnumerationValue())){
365 if (! constraints[i].isSatisfied(fieldValue)){
366 return constraints[i].getErrorMessage();
367 }
368 }
369 }
370 else {
371 if (! constraints[i].isSatisfied(fieldValue)){
372 return constraints[i].getErrorMessage();
373 }
374 }
375 }
376 }
377 return EMPTY_STRING;
378 }
379 }
380
381
382
383
384
385
386
387
388 public String validateChildPresence(Object messageOrParameter, String childName){
389 if (messageOrParameter instanceof LLRPMessage || messageOrParameter instanceof LLRPParameter){
390 Object messageOrParameterDefinition = getDefinition(messageOrParameter);
391 if (getChild(messageOrParameter, childName) == null){
392 if (LLRP.mustOccurAtLeastOnce(messageOrParameterDefinition, childName)){
393 return LLRPConstraints.MISSING_PARAMETER_ERROR_MESSAGE;
394 }
395 else {
396
397 LLRPPresenceConstraint[] constraints = LLRPConstraints.presenceConstraints;
398 for (int i = 0; i < constraints.length; i++){
399 if (getName(messageOrParameter).equals(constraints[i].getMessageOrParameterName())
400 && childName.equals(constraints[i].getSubparameterName())){
401 String enumerationName = constraints[i].getPreconditionedEnumerationName();
402 if (enumerationName != null){
403 LLRPEnumeration enumeration = (LLRPEnumeration) getField(messageOrParameter, enumerationName);
404 if (enumeration != null &&
405 enumeration.toString().equals(constraints[i].getPreconditionedEnumerationValue())){
406 return constraints[i].getErrorMessage();
407 }
408 }
409 }
410 }
411
412 }
413 }
414 }
415 return EMPTY_STRING;
416 }
417
418
419
420
421
422
423
424 public String validateEmptiness(List<LLRPParameter> list){
425 String errorMessage = EMPTY_STRING;
426 Object parent = getParent(list);
427 Object messageOrParameterDefinition = getDefinition(parent);
428 if (LLRP.mustOccurAtLeastOnce(messageOrParameterDefinition, getName(list)) && list.isEmpty()){
429 errorMessage = LLRPConstraints.EMPTY_LIST_ERROR_MESSAGE;
430 }
431 return errorMessage;
432 }
433
434
435
436
437
438
439
440 private boolean areFieldsValid(Object messageOrParameter) {
441 boolean result = true;
442 List<FieldDefinition> fieldDefinitions = LLRP.getFieldDefinitions(getDefinition(messageOrParameter));
443 for (FieldDefinition fd : fieldDefinitions){
444 if (!validateField(messageOrParameter, fd.getName()).equals(EMPTY_STRING)){
445 result = false;
446 }
447 }
448 return result;
449 }
450
451
452
453
454
455
456
457 private boolean areMandatoryParametersPresent(Object messageOrParameter){
458 boolean result = true;
459 if (messageOrParameter instanceof LLRPMessage || messageOrParameter instanceof LLRPParameter){
460 Object messageOrParameterDefinition = getDefinition(messageOrParameter);
461 List<String> childrenNames = LLRP.getParameterAndChoiceNames(messageOrParameterDefinition);
462 for (String childName : childrenNames){
463 if (!validateChildPresence(messageOrParameter, childName).equals(EMPTY_STRING)){
464 result = false;
465 break;
466 }
467 }
468 }
469 return result;
470 }
471
472
473
474
475
476
477
478
479 private boolean areListsNonRecursivelyValid(Object messageOrParameter){
480 boolean result = true;
481 Object messageOrParameterDefinition = getDefinition(messageOrParameter);
482 List<String> childrenNames = LLRP.getParameterAndChoiceNames(messageOrParameterDefinition);
483 for (String childName : childrenNames){
484 if (LLRP.canOccurMultipleTimes(messageOrParameterDefinition, childName)){
485 if (!validateEmptiness((List<LLRPParameter>) getChild(messageOrParameter, childName)).equals(EMPTY_STRING)){
486 result = false;
487 }
488 }
489 }
490 return result;
491 }
492
493
494
495
496
497
498
499
500 public String getName(Object treeElement) {
501 String name = EMPTY_STRING;
502 if (treeElement instanceof LLRPMessage){
503 name = ((LLRPMessage) treeElement).getName();
504 }
505 else if (treeElement instanceof LLRPParameter){
506 name = ((LLRPParameter) treeElement).getName();
507 }
508 else if (treeElement instanceof List){
509 Object parent = getParent(treeElement);
510 Object messageOrParameterDefinition = getDefinition(parent);
511 List<String> childrenNames = LLRP.getParameterAndChoiceNames(messageOrParameterDefinition);
512 for (String childName : childrenNames){
513 Object child = getChild(parent, childName);
514 if (child == treeElement){
515 name = childName;
516 break;
517 }
518 }
519 }
520 return name;
521 }
522
523
524
525
526
527
528
529 public Object getDefinition(Object messageOrParameter) {
530 Object messageOrParameterDefinition = null;
531 if (messageOrParameter instanceof LLRPMessage){
532 messageOrParameterDefinition = LLRP.getMessageDefinition(getName(messageOrParameter));
533 }
534 else if (messageOrParameter instanceof LLRPParameter){
535 messageOrParameterDefinition = LLRP.getParameterDefinition(getName(messageOrParameter));
536 }
537 return messageOrParameterDefinition;
538 }
539 }