1#[allow(unused_imports)]
8use crate::eval::format_validators::*;
9use crate::eval::{ConditionEvaluator, ConditionResult, EvaluationContext};
10
11pub struct UtilmdStromConditionEvaluatorFV2504 {
13 external_conditions: std::collections::HashSet<u32>,
15}
16
17impl Default for UtilmdStromConditionEvaluatorFV2504 {
18 fn default() -> Self {
19 let mut external_conditions = std::collections::HashSet::new();
20 external_conditions.insert(1);
21 external_conditions.insert(4);
22 external_conditions.insert(5);
23 external_conditions.insert(6);
24 external_conditions.insert(8);
25 external_conditions.insert(9);
26 external_conditions.insert(14);
27 external_conditions.insert(31);
28 external_conditions.insert(33);
29 external_conditions.insert(36);
30 external_conditions.insert(38);
31 external_conditions.insert(39);
32 external_conditions.insert(40);
33 external_conditions.insert(75);
34 external_conditions.insert(98);
35 external_conditions.insert(99);
36 external_conditions.insert(151);
37 external_conditions.insert(233);
38 external_conditions.insert(241);
39 external_conditions.insert(251);
40 external_conditions.insert(292);
41 external_conditions.insert(314);
42 external_conditions.insert(315);
43 external_conditions.insert(323);
44 external_conditions.insert(412);
45 external_conditions.insert(425);
46 external_conditions.insert(426);
47 external_conditions.insert(427);
48 external_conditions.insert(428);
49 external_conditions.insert(429);
50 external_conditions.insert(433);
51 external_conditions.insert(435);
52 external_conditions.insert(453);
53 external_conditions.insert(459);
54 external_conditions.insert(460);
55 external_conditions.insert(706);
56 external_conditions.insert(717);
57 external_conditions.insert(2011);
58 Self {
59 external_conditions,
60 }
61 }
62}
63
64impl ConditionEvaluator for UtilmdStromConditionEvaluatorFV2504 {
65 fn message_type(&self) -> &str {
66 "UTILMD_Strom"
67 }
68
69 fn format_version(&self) -> &str {
70 "FV2504"
71 }
72
73 fn evaluate(&self, condition: u32, ctx: &EvaluationContext) -> ConditionResult {
74 match condition {
75 1 => self.evaluate_1(ctx),
76 4 => self.evaluate_4(ctx),
77 5 => self.evaluate_5(ctx),
78 6 => self.evaluate_6(ctx),
79 7 => self.evaluate_7(ctx),
80 8 => self.evaluate_8(ctx),
81 9 => self.evaluate_9(ctx),
82 10 => self.evaluate_10(ctx),
83 11 => self.evaluate_11(ctx),
84 12 => self.evaluate_12(ctx),
85 13 => self.evaluate_13(ctx),
86 14 => self.evaluate_14(ctx),
87 15 => self.evaluate_15(ctx),
88 16 => self.evaluate_16(ctx),
89 17 => self.evaluate_17(ctx),
90 18 => self.evaluate_18(ctx),
91 19 => self.evaluate_19(ctx),
92 20 => self.evaluate_20(ctx),
93 21 => self.evaluate_21(ctx),
94 22 => self.evaluate_22(ctx),
95 23 => self.evaluate_23(ctx),
96 24 => self.evaluate_24(ctx),
97 25 => self.evaluate_25(ctx),
98 27 => self.evaluate_27(ctx),
99 30 => self.evaluate_30(ctx),
100 31 => self.evaluate_31(ctx),
101 32 => self.evaluate_32(ctx),
102 33 => self.evaluate_33(ctx),
103 34 => self.evaluate_34(ctx),
104 35 => self.evaluate_35(ctx),
105 36 => self.evaluate_36(ctx),
106 37 => self.evaluate_37(ctx),
107 38 => self.evaluate_38(ctx),
108 39 => self.evaluate_39(ctx),
109 40 => self.evaluate_40(ctx),
110 41 => self.evaluate_41(ctx),
111 42 => self.evaluate_42(ctx),
112 43 => self.evaluate_43(ctx),
113 44 => self.evaluate_44(ctx),
114 45 => self.evaluate_45(ctx),
115 46 => self.evaluate_46(ctx),
116 47 => self.evaluate_47(ctx),
117 48 => self.evaluate_48(ctx),
118 49 => self.evaluate_49(ctx),
119 50 => self.evaluate_50(ctx),
120 51 => self.evaluate_51(ctx),
121 52 => self.evaluate_52(ctx),
122 53 => self.evaluate_53(ctx),
123 54 => self.evaluate_54(ctx),
124 55 => self.evaluate_55(ctx),
125 56 => self.evaluate_56(ctx),
126 57 => self.evaluate_57(ctx),
127 58 => self.evaluate_58(ctx),
128 60 => self.evaluate_60(ctx),
129 61 => self.evaluate_61(ctx),
130 62 => self.evaluate_62(ctx),
131 63 => self.evaluate_63(ctx),
132 64 => self.evaluate_64(ctx),
133 65 => self.evaluate_65(ctx),
134 66 => self.evaluate_66(ctx),
135 67 => self.evaluate_67(ctx),
136 68 => self.evaluate_68(ctx),
137 69 => self.evaluate_69(ctx),
138 70 => self.evaluate_70(ctx),
139 71 => self.evaluate_71(ctx),
140 72 => self.evaluate_72(ctx),
141 73 => self.evaluate_73(ctx),
142 74 => self.evaluate_74(ctx),
143 75 => self.evaluate_75(ctx),
144 76 => self.evaluate_76(ctx),
145 77 => self.evaluate_77(ctx),
146 78 => self.evaluate_78(ctx),
147 83 => self.evaluate_83(ctx),
148 84 => self.evaluate_84(ctx),
149 85 => self.evaluate_85(ctx),
150 86 => self.evaluate_86(ctx),
151 87 => self.evaluate_87(ctx),
152 88 => self.evaluate_88(ctx),
153 89 => self.evaluate_89(ctx),
154 90 => self.evaluate_90(ctx),
155 91 => self.evaluate_91(ctx),
156 92 => self.evaluate_92(ctx),
157 93 => self.evaluate_93(ctx),
158 94 => self.evaluate_94(ctx),
159 95 => self.evaluate_95(ctx),
160 96 => self.evaluate_96(ctx),
161 97 => self.evaluate_97(ctx),
162 98 => self.evaluate_98(ctx),
163 99 => self.evaluate_99(ctx),
164 100 => self.evaluate_100(ctx),
165 101 => self.evaluate_101(ctx),
166 102 => self.evaluate_102(ctx),
167 103 => self.evaluate_103(ctx),
168 104 => self.evaluate_104(ctx),
169 105 => self.evaluate_105(ctx),
170 106 => self.evaluate_106(ctx),
171 107 => self.evaluate_107(ctx),
172 108 => self.evaluate_108(ctx),
173 110 => self.evaluate_110(ctx),
174 111 => self.evaluate_111(ctx),
175 112 => self.evaluate_112(ctx),
176 113 => self.evaluate_113(ctx),
177 114 => self.evaluate_114(ctx),
178 115 => self.evaluate_115(ctx),
179 116 => self.evaluate_116(ctx),
180 117 => self.evaluate_117(ctx),
181 118 => self.evaluate_118(ctx),
182 119 => self.evaluate_119(ctx),
183 120 => self.evaluate_120(ctx),
184 121 => self.evaluate_121(ctx),
185 122 => self.evaluate_122(ctx),
186 123 => self.evaluate_123(ctx),
187 124 => self.evaluate_124(ctx),
188 125 => self.evaluate_125(ctx),
189 126 => self.evaluate_126(ctx),
190 127 => self.evaluate_127(ctx),
191 128 => self.evaluate_128(ctx),
192 129 => self.evaluate_129(ctx),
193 130 => self.evaluate_130(ctx),
194 131 => self.evaluate_131(ctx),
195 132 => self.evaluate_132(ctx),
196 133 => self.evaluate_133(ctx),
197 134 => self.evaluate_134(ctx),
198 135 => self.evaluate_135(ctx),
199 136 => self.evaluate_136(ctx),
200 137 => self.evaluate_137(ctx),
201 138 => self.evaluate_138(ctx),
202 139 => self.evaluate_139(ctx),
203 140 => self.evaluate_140(ctx),
204 141 => self.evaluate_141(ctx),
205 142 => self.evaluate_142(ctx),
206 143 => self.evaluate_143(ctx),
207 144 => self.evaluate_144(ctx),
208 145 => self.evaluate_145(ctx),
209 146 => self.evaluate_146(ctx),
210 147 => self.evaluate_147(ctx),
211 148 => self.evaluate_148(ctx),
212 149 => self.evaluate_149(ctx),
213 150 => self.evaluate_150(ctx),
214 151 => self.evaluate_151(ctx),
215 152 => self.evaluate_152(ctx),
216 153 => self.evaluate_153(ctx),
217 156 => self.evaluate_156(ctx),
218 161 => self.evaluate_161(ctx),
219 162 => self.evaluate_162(ctx),
220 163 => self.evaluate_163(ctx),
221 164 => self.evaluate_164(ctx),
222 165 => self.evaluate_165(ctx),
223 166 => self.evaluate_166(ctx),
224 167 => self.evaluate_167(ctx),
225 170 => self.evaluate_170(ctx),
226 172 => self.evaluate_172(ctx),
227 173 => self.evaluate_173(ctx),
228 174 => self.evaluate_174(ctx),
229 175 => self.evaluate_175(ctx),
230 176 => self.evaluate_176(ctx),
231 177 => self.evaluate_177(ctx),
232 178 => self.evaluate_178(ctx),
233 179 => self.evaluate_179(ctx),
234 180 => self.evaluate_180(ctx),
235 184 => self.evaluate_184(ctx),
236 190 => self.evaluate_190(ctx),
237 191 => self.evaluate_191(ctx),
238 192 => self.evaluate_192(ctx),
239 193 => self.evaluate_193(ctx),
240 194 => self.evaluate_194(ctx),
241 195 => self.evaluate_195(ctx),
242 196 => self.evaluate_196(ctx),
243 197 => self.evaluate_197(ctx),
244 198 => self.evaluate_198(ctx),
245 199 => self.evaluate_199(ctx),
246 201 => self.evaluate_201(ctx),
247 202 => self.evaluate_202(ctx),
248 203 => self.evaluate_203(ctx),
249 204 => self.evaluate_204(ctx),
250 205 => self.evaluate_205(ctx),
251 206 => self.evaluate_206(ctx),
252 209 => self.evaluate_209(ctx),
253 210 => self.evaluate_210(ctx),
254 212 => self.evaluate_212(ctx),
255 213 => self.evaluate_213(ctx),
256 215 => self.evaluate_215(ctx),
257 216 => self.evaluate_216(ctx),
258 217 => self.evaluate_217(ctx),
259 219 => self.evaluate_219(ctx),
260 220 => self.evaluate_220(ctx),
261 221 => self.evaluate_221(ctx),
262 223 => self.evaluate_223(ctx),
263 224 => self.evaluate_224(ctx),
264 227 => self.evaluate_227(ctx),
265 229 => self.evaluate_229(ctx),
266 232 => self.evaluate_232(ctx),
267 233 => self.evaluate_233(ctx),
268 234 => self.evaluate_234(ctx),
269 237 => self.evaluate_237(ctx),
270 238 => self.evaluate_238(ctx),
271 239 => self.evaluate_239(ctx),
272 240 => self.evaluate_240(ctx),
273 241 => self.evaluate_241(ctx),
274 243 => self.evaluate_243(ctx),
275 244 => self.evaluate_244(ctx),
276 248 => self.evaluate_248(ctx),
277 249 => self.evaluate_249(ctx),
278 251 => self.evaluate_251(ctx),
279 252 => self.evaluate_252(ctx),
280 254 => self.evaluate_254(ctx),
281 255 => self.evaluate_255(ctx),
282 256 => self.evaluate_256(ctx),
283 257 => self.evaluate_257(ctx),
284 259 => self.evaluate_259(ctx),
285 261 => self.evaluate_261(ctx),
286 262 => self.evaluate_262(ctx),
287 265 => self.evaluate_265(ctx),
288 266 => self.evaluate_266(ctx),
289 267 => self.evaluate_267(ctx),
290 268 => self.evaluate_268(ctx),
291 269 => self.evaluate_269(ctx),
292 270 => self.evaluate_270(ctx),
293 273 => self.evaluate_273(ctx),
294 279 => self.evaluate_279(ctx),
295 280 => self.evaluate_280(ctx),
296 282 => self.evaluate_282(ctx),
297 284 => self.evaluate_284(ctx),
298 285 => self.evaluate_285(ctx),
299 286 => self.evaluate_286(ctx),
300 287 => self.evaluate_287(ctx),
301 288 => self.evaluate_288(ctx),
302 291 => self.evaluate_291(ctx),
303 292 => self.evaluate_292(ctx),
304 293 => self.evaluate_293(ctx),
305 294 => self.evaluate_294(ctx),
306 295 => self.evaluate_295(ctx),
307 296 => self.evaluate_296(ctx),
308 297 => self.evaluate_297(ctx),
309 298 => self.evaluate_298(ctx),
310 299 => self.evaluate_299(ctx),
311 300 => self.evaluate_300(ctx),
312 301 => self.evaluate_301(ctx),
313 302 => self.evaluate_302(ctx),
314 303 => self.evaluate_303(ctx),
315 304 => self.evaluate_304(ctx),
316 305 => self.evaluate_305(ctx),
317 306 => self.evaluate_306(ctx),
318 307 => self.evaluate_307(ctx),
319 309 => self.evaluate_309(ctx),
320 314 => self.evaluate_314(ctx),
321 315 => self.evaluate_315(ctx),
322 316 => self.evaluate_316(ctx),
323 317 => self.evaluate_317(ctx),
324 318 => self.evaluate_318(ctx),
325 321 => self.evaluate_321(ctx),
326 322 => self.evaluate_322(ctx),
327 323 => self.evaluate_323(ctx),
328 327 => self.evaluate_327(ctx),
329 329 => self.evaluate_329(ctx),
330 331 => self.evaluate_331(ctx),
331 332 => self.evaluate_332(ctx),
332 333 => self.evaluate_333(ctx),
333 334 => self.evaluate_334(ctx),
334 335 => self.evaluate_335(ctx),
335 336 => self.evaluate_336(ctx),
336 337 => self.evaluate_337(ctx),
337 338 => self.evaluate_338(ctx),
338 339 => self.evaluate_339(ctx),
339 340 => self.evaluate_340(ctx),
340 341 => self.evaluate_341(ctx),
341 342 => self.evaluate_342(ctx),
342 344 => self.evaluate_344(ctx),
343 345 => self.evaluate_345(ctx),
344 346 => self.evaluate_346(ctx),
345 347 => self.evaluate_347(ctx),
346 348 => self.evaluate_348(ctx),
347 349 => self.evaluate_349(ctx),
348 350 => self.evaluate_350(ctx),
349 351 => self.evaluate_351(ctx),
350 352 => self.evaluate_352(ctx),
351 355 => self.evaluate_355(ctx),
352 356 => self.evaluate_356(ctx),
353 357 => self.evaluate_357(ctx),
354 358 => self.evaluate_358(ctx),
355 359 => self.evaluate_359(ctx),
356 360 => self.evaluate_360(ctx),
357 363 => self.evaluate_363(ctx),
358 365 => self.evaluate_365(ctx),
359 366 => self.evaluate_366(ctx),
360 367 => self.evaluate_367(ctx),
361 368 => self.evaluate_368(ctx),
362 370 => self.evaluate_370(ctx),
363 371 => self.evaluate_371(ctx),
364 372 => self.evaluate_372(ctx),
365 373 => self.evaluate_373(ctx),
366 375 => self.evaluate_375(ctx),
367 376 => self.evaluate_376(ctx),
368 377 => self.evaluate_377(ctx),
369 378 => self.evaluate_378(ctx),
370 379 => self.evaluate_379(ctx),
371 380 => self.evaluate_380(ctx),
372 384 => self.evaluate_384(ctx),
373 386 => self.evaluate_386(ctx),
374 387 => self.evaluate_387(ctx),
375 388 => self.evaluate_388(ctx),
376 391 => self.evaluate_391(ctx),
377 392 => self.evaluate_392(ctx),
378 393 => self.evaluate_393(ctx),
379 394 => self.evaluate_394(ctx),
380 395 => self.evaluate_395(ctx),
381 396 => self.evaluate_396(ctx),
382 397 => self.evaluate_397(ctx),
383 398 => self.evaluate_398(ctx),
384 399 => self.evaluate_399(ctx),
385 401 => self.evaluate_401(ctx),
386 402 => self.evaluate_402(ctx),
387 403 => self.evaluate_403(ctx),
388 404 => self.evaluate_404(ctx),
389 405 => self.evaluate_405(ctx),
390 406 => self.evaluate_406(ctx),
391 407 => self.evaluate_407(ctx),
392 408 => self.evaluate_408(ctx),
393 409 => self.evaluate_409(ctx),
394 410 => self.evaluate_410(ctx),
395 411 => self.evaluate_411(ctx),
396 412 => self.evaluate_412(ctx),
397 413 => self.evaluate_413(ctx),
398 414 => self.evaluate_414(ctx),
399 415 => self.evaluate_415(ctx),
400 416 => self.evaluate_416(ctx),
401 417 => self.evaluate_417(ctx),
402 419 => self.evaluate_419(ctx),
403 420 => self.evaluate_420(ctx),
404 421 => self.evaluate_421(ctx),
405 425 => self.evaluate_425(ctx),
406 426 => self.evaluate_426(ctx),
407 427 => self.evaluate_427(ctx),
408 428 => self.evaluate_428(ctx),
409 429 => self.evaluate_429(ctx),
410 430 => self.evaluate_430(ctx),
411 431 => self.evaluate_431(ctx),
412 432 => self.evaluate_432(ctx),
413 433 => self.evaluate_433(ctx),
414 435 => self.evaluate_435(ctx),
415 436 => self.evaluate_436(ctx),
416 437 => self.evaluate_437(ctx),
417 438 => self.evaluate_438(ctx),
418 440 => self.evaluate_440(ctx),
419 441 => self.evaluate_441(ctx),
420 442 => self.evaluate_442(ctx),
421 444 => self.evaluate_444(ctx),
422 445 => self.evaluate_445(ctx),
423 446 => self.evaluate_446(ctx),
424 447 => self.evaluate_447(ctx),
425 448 => self.evaluate_448(ctx),
426 449 => self.evaluate_449(ctx),
427 450 => self.evaluate_450(ctx),
428 451 => self.evaluate_451(ctx),
429 452 => self.evaluate_452(ctx),
430 453 => self.evaluate_453(ctx),
431 454 => self.evaluate_454(ctx),
432 455 => self.evaluate_455(ctx),
433 456 => self.evaluate_456(ctx),
434 457 => self.evaluate_457(ctx),
435 458 => self.evaluate_458(ctx),
436 459 => self.evaluate_459(ctx),
437 460 => self.evaluate_460(ctx),
438 461 => self.evaluate_461(ctx),
439 462 => self.evaluate_462(ctx),
440 463 => self.evaluate_463(ctx),
441 465 => self.evaluate_465(ctx),
442 466 => self.evaluate_466(ctx),
443 467 => self.evaluate_467(ctx),
444 468 => self.evaluate_468(ctx),
445 469 => self.evaluate_469(ctx),
446 470 => self.evaluate_470(ctx),
447 471 => self.evaluate_471(ctx),
448 472 => self.evaluate_472(ctx),
449 473 => self.evaluate_473(ctx),
450 474 => self.evaluate_474(ctx),
451 475 => self.evaluate_475(ctx),
452 476 => self.evaluate_476(ctx),
453 477 => self.evaluate_477(ctx),
454 478 => self.evaluate_478(ctx),
455 479 => self.evaluate_479(ctx),
456 480 => self.evaluate_480(ctx),
457 481 => self.evaluate_481(ctx),
458 483 => self.evaluate_483(ctx),
459 484 => self.evaluate_484(ctx),
460 487 => self.evaluate_487(ctx),
461 489 => self.evaluate_489(ctx),
462 490 => self.evaluate_490(ctx),
463 491 => self.evaluate_491(ctx),
464 494 => self.evaluate_494(ctx),
465 500 => self.evaluate_500(ctx),
466 501 => self.evaluate_501(ctx),
467 502 => self.evaluate_502(ctx),
468 503 => self.evaluate_503(ctx),
469 504 => self.evaluate_504(ctx),
470 505 => self.evaluate_505(ctx),
471 506 => self.evaluate_506(ctx),
472 507 => self.evaluate_507(ctx),
473 508 => self.evaluate_508(ctx),
474 509 => self.evaluate_509(ctx),
475 510 => self.evaluate_510(ctx),
476 511 => self.evaluate_511(ctx),
477 512 => self.evaluate_512(ctx),
478 513 => self.evaluate_513(ctx),
479 514 => self.evaluate_514(ctx),
480 515 => self.evaluate_515(ctx),
481 516 => self.evaluate_516(ctx),
482 517 => self.evaluate_517(ctx),
483 518 => self.evaluate_518(ctx),
484 519 => self.evaluate_519(ctx),
485 520 => self.evaluate_520(ctx),
486 521 => self.evaluate_521(ctx),
487 522 => self.evaluate_522(ctx),
488 523 => self.evaluate_523(ctx),
489 524 => self.evaluate_524(ctx),
490 525 => self.evaluate_525(ctx),
491 526 => self.evaluate_526(ctx),
492 527 => self.evaluate_527(ctx),
493 528 => self.evaluate_528(ctx),
494 529 => self.evaluate_529(ctx),
495 530 => self.evaluate_530(ctx),
496 531 => self.evaluate_531(ctx),
497 532 => self.evaluate_532(ctx),
498 533 => self.evaluate_533(ctx),
499 555 => self.evaluate_555(ctx),
500 556 => self.evaluate_556(ctx),
501 558 => self.evaluate_558(ctx),
502 559 => self.evaluate_559(ctx),
503 563 => self.evaluate_563(ctx),
504 566 => self.evaluate_566(ctx),
505 567 => self.evaluate_567(ctx),
506 568 => self.evaluate_568(ctx),
507 569 => self.evaluate_569(ctx),
508 570 => self.evaluate_570(ctx),
509 572 => self.evaluate_572(ctx),
510 576 => self.evaluate_576(ctx),
511 577 => self.evaluate_577(ctx),
512 579 => self.evaluate_579(ctx),
513 580 => self.evaluate_580(ctx),
514 581 => self.evaluate_581(ctx),
515 586 => self.evaluate_586(ctx),
516 590 => self.evaluate_590(ctx),
517 594 => self.evaluate_594(ctx),
518 599 => self.evaluate_599(ctx),
519 601 => self.evaluate_601(ctx),
520 606 => self.evaluate_606(ctx),
521 609 => self.evaluate_609(ctx),
522 611 => self.evaluate_611(ctx),
523 614 => self.evaluate_614(ctx),
524 617 => self.evaluate_617(ctx),
525 618 => self.evaluate_618(ctx),
526 619 => self.evaluate_619(ctx),
527 621 => self.evaluate_621(ctx),
528 622 => self.evaluate_622(ctx),
529 623 => self.evaluate_623(ctx),
530 630 => self.evaluate_630(ctx),
531 631 => self.evaluate_631(ctx),
532 632 => self.evaluate_632(ctx),
533 637 => self.evaluate_637(ctx),
534 638 => self.evaluate_638(ctx),
535 639 => self.evaluate_639(ctx),
536 640 => self.evaluate_640(ctx),
537 641 => self.evaluate_641(ctx),
538 642 => self.evaluate_642(ctx),
539 643 => self.evaluate_643(ctx),
540 645 => self.evaluate_645(ctx),
541 646 => self.evaluate_646(ctx),
542 647 => self.evaluate_647(ctx),
543 648 => self.evaluate_648(ctx),
544 651 => self.evaluate_651(ctx),
545 653 => self.evaluate_653(ctx),
546 655 => self.evaluate_655(ctx),
547 659 => self.evaluate_659(ctx),
548 660 => self.evaluate_660(ctx),
549 662 => self.evaluate_662(ctx),
550 663 => self.evaluate_663(ctx),
551 664 => self.evaluate_664(ctx),
552 665 => self.evaluate_665(ctx),
553 667 => self.evaluate_667(ctx),
554 668 => self.evaluate_668(ctx),
555 670 => self.evaluate_670(ctx),
556 671 => self.evaluate_671(ctx),
557 672 => self.evaluate_672(ctx),
558 673 => self.evaluate_673(ctx),
559 674 => self.evaluate_674(ctx),
560 675 => self.evaluate_675(ctx),
561 677 => self.evaluate_677(ctx),
562 678 => self.evaluate_678(ctx),
563 679 => self.evaluate_679(ctx),
564 680 => self.evaluate_680(ctx),
565 682 => self.evaluate_682(ctx),
566 683 => self.evaluate_683(ctx),
567 684 => self.evaluate_684(ctx),
568 685 => self.evaluate_685(ctx),
569 687 => self.evaluate_687(ctx),
570 688 => self.evaluate_688(ctx),
571 689 => self.evaluate_689(ctx),
572 690 => self.evaluate_690(ctx),
573 693 => self.evaluate_693(ctx),
574 694 => self.evaluate_694(ctx),
575 695 => self.evaluate_695(ctx),
576 696 => self.evaluate_696(ctx),
577 698 => self.evaluate_698(ctx),
578 699 => self.evaluate_699(ctx),
579 700 => self.evaluate_700(ctx),
580 704 => self.evaluate_704(ctx),
581 705 => self.evaluate_705(ctx),
582 706 => self.evaluate_706(ctx),
583 707 => self.evaluate_707(ctx),
584 708 => self.evaluate_708(ctx),
585 709 => self.evaluate_709(ctx),
586 710 => self.evaluate_710(ctx),
587 711 => self.evaluate_711(ctx),
588 712 => self.evaluate_712(ctx),
589 713 => self.evaluate_713(ctx),
590 714 => self.evaluate_714(ctx),
591 715 => self.evaluate_715(ctx),
592 716 => self.evaluate_716(ctx),
593 717 => self.evaluate_717(ctx),
594 718 => self.evaluate_718(ctx),
595 719 => self.evaluate_719(ctx),
596 902 => self.evaluate_902(ctx),
597 910 => self.evaluate_910(ctx),
598 914 => self.evaluate_914(ctx),
599 922 => self.evaluate_922(ctx),
600 926 => self.evaluate_926(ctx),
601 930 => self.evaluate_930(ctx),
602 931 => self.evaluate_931(ctx),
603 932 => self.evaluate_932(ctx),
604 933 => self.evaluate_933(ctx),
605 937 => self.evaluate_937(ctx),
606 938 => self.evaluate_938(ctx),
607 939 => self.evaluate_939(ctx),
608 940 => self.evaluate_940(ctx),
609 942 => self.evaluate_942(ctx),
610 943 => self.evaluate_943(ctx),
611 946 => self.evaluate_946(ctx),
612 948 => self.evaluate_948(ctx),
613 950 => self.evaluate_950(ctx),
614 951 => self.evaluate_951(ctx),
615 952 => self.evaluate_952(ctx),
616 955 => self.evaluate_955(ctx),
617 957 => self.evaluate_957(ctx),
618 960 => self.evaluate_960(ctx),
619 961 => self.evaluate_961(ctx),
620 967 => self.evaluate_967(ctx),
621 2001 => self.evaluate_2001(ctx),
622 2002 => self.evaluate_2002(ctx),
623 2003 => self.evaluate_2003(ctx),
624 2004 => self.evaluate_2004(ctx),
625 2005 => self.evaluate_2005(ctx),
626 2006 => self.evaluate_2006(ctx),
627 2007 => self.evaluate_2007(ctx),
628 2008 => self.evaluate_2008(ctx),
629 2009 => self.evaluate_2009(ctx),
630 2010 => self.evaluate_2010(ctx),
631 2011 => self.evaluate_2011(ctx),
632 2012 => self.evaluate_2012(ctx),
633 2013 => self.evaluate_2013(ctx),
634 2014 => self.evaluate_2014(ctx),
635 2015 => self.evaluate_2015(ctx),
636 2016 => self.evaluate_2016(ctx),
637 2017 => self.evaluate_2017(ctx),
638 2018 => self.evaluate_2018(ctx),
639 2060 => self.evaluate_2060(ctx),
640 2061 => self.evaluate_2061(ctx),
641 2071 => self.evaluate_2071(ctx),
642 2073 => self.evaluate_2073(ctx),
643 2075 => self.evaluate_2075(ctx),
644 2080 => self.evaluate_2080(ctx),
645 2095 => self.evaluate_2095(ctx),
646 2096 => self.evaluate_2096(ctx),
647 2119 => self.evaluate_2119(ctx),
648 2140 => self.evaluate_2140(ctx),
649 2182 => self.evaluate_2182(ctx),
650 2183 => self.evaluate_2183(ctx),
651 2207 => self.evaluate_2207(ctx),
652 2225 => self.evaluate_2225(ctx),
653 2236 => self.evaluate_2236(ctx),
654 2252 => self.evaluate_2252(ctx),
655 2261 => self.evaluate_2261(ctx),
656 2284 => self.evaluate_2284(ctx),
657 2286 => self.evaluate_2286(ctx),
658 2287 => self.evaluate_2287(ctx),
659 2288 => self.evaluate_2288(ctx),
660 2307 => self.evaluate_2307(ctx),
661 2308 => self.evaluate_2308(ctx),
662 2309 => self.evaluate_2309(ctx),
663 2310 => self.evaluate_2310(ctx),
664 2311 => self.evaluate_2311(ctx),
665 2312 => self.evaluate_2312(ctx),
666 2313 => self.evaluate_2313(ctx),
667 2317 => self.evaluate_2317(ctx),
668 2318 => self.evaluate_2318(ctx),
669 2344 => self.evaluate_2344(ctx),
670 2350 => self.evaluate_2350(ctx),
671 2351 => self.evaluate_2351(ctx),
672 2352 => self.evaluate_2352(ctx),
673 2356 => self.evaluate_2356(ctx),
674 2357 => self.evaluate_2357(ctx),
675 2358 => self.evaluate_2358(ctx),
676 2359 => self.evaluate_2359(ctx),
677 2360 => self.evaluate_2360(ctx),
678 2361 => self.evaluate_2361(ctx),
679 _ => ConditionResult::Unknown,
680 }
681 }
682
683 fn is_external(&self, condition: u32) -> bool {
684 self.external_conditions.contains(&condition)
685 }
686 fn is_known(&self, condition: u32) -> bool {
687 matches!(
688 condition,
689 1 | 4
690 | 5
691 | 6
692 | 7
693 | 8
694 | 9
695 | 10
696 | 11
697 | 12
698 | 13
699 | 14
700 | 15
701 | 16
702 | 17
703 | 18
704 | 19
705 | 20
706 | 21
707 | 22
708 | 23
709 | 24
710 | 25
711 | 27
712 | 30
713 | 31
714 | 32
715 | 33
716 | 34
717 | 35
718 | 36
719 | 37
720 | 38
721 | 39
722 | 40
723 | 41
724 | 42
725 | 43
726 | 44
727 | 45
728 | 46
729 | 47
730 | 48
731 | 49
732 | 50
733 | 51
734 | 52
735 | 53
736 | 54
737 | 55
738 | 56
739 | 57
740 | 58
741 | 60
742 | 61
743 | 62
744 | 63
745 | 64
746 | 65
747 | 66
748 | 67
749 | 68
750 | 69
751 | 70
752 | 71
753 | 72
754 | 73
755 | 74
756 | 75
757 | 76
758 | 77
759 | 78
760 | 83
761 | 84
762 | 85
763 | 86
764 | 87
765 | 88
766 | 89
767 | 90
768 | 91
769 | 92
770 | 93
771 | 94
772 | 95
773 | 96
774 | 97
775 | 98
776 | 99
777 | 100
778 | 101
779 | 102
780 | 103
781 | 104
782 | 105
783 | 106
784 | 107
785 | 108
786 | 110
787 | 111
788 | 112
789 | 113
790 | 114
791 | 115
792 | 116
793 | 117
794 | 118
795 | 119
796 | 120
797 | 121
798 | 122
799 | 123
800 | 124
801 | 125
802 | 126
803 | 127
804 | 128
805 | 129
806 | 130
807 | 131
808 | 132
809 | 133
810 | 134
811 | 135
812 | 136
813 | 137
814 | 138
815 | 139
816 | 140
817 | 141
818 | 142
819 | 143
820 | 144
821 | 145
822 | 146
823 | 147
824 | 148
825 | 149
826 | 150
827 | 151
828 | 152
829 | 153
830 | 156
831 | 161
832 | 162
833 | 163
834 | 164
835 | 165
836 | 166
837 | 167
838 | 170
839 | 172
840 | 173
841 | 174
842 | 175
843 | 176
844 | 177
845 | 178
846 | 179
847 | 180
848 | 184
849 | 190
850 | 191
851 | 192
852 | 193
853 | 194
854 | 195
855 | 196
856 | 197
857 | 198
858 | 199
859 | 201
860 | 202
861 | 203
862 | 204
863 | 205
864 | 206
865 | 209
866 | 210
867 | 212
868 | 213
869 | 215
870 | 216
871 | 217
872 | 219
873 | 220
874 | 221
875 | 223
876 | 224
877 | 227
878 | 229
879 | 232
880 | 233
881 | 234
882 | 237
883 | 238
884 | 239
885 | 240
886 | 241
887 | 243
888 | 244
889 | 248
890 | 249
891 | 251
892 | 252
893 | 254
894 | 255
895 | 256
896 | 257
897 | 259
898 | 261
899 | 262
900 | 265
901 | 266
902 | 267
903 | 268
904 | 269
905 | 270
906 | 273
907 | 279
908 | 280
909 | 282
910 | 284
911 | 285
912 | 286
913 | 287
914 | 288
915 | 291
916 | 292
917 | 293
918 | 294
919 | 295
920 | 296
921 | 297
922 | 298
923 | 299
924 | 300
925 | 301
926 | 302
927 | 303
928 | 304
929 | 305
930 | 306
931 | 307
932 | 309
933 | 314
934 | 315
935 | 316
936 | 317
937 | 318
938 | 321
939 | 322
940 | 323
941 | 327
942 | 329
943 | 331
944 | 332
945 | 333
946 | 334
947 | 335
948 | 336
949 | 337
950 | 338
951 | 339
952 | 340
953 | 341
954 | 342
955 | 344
956 | 345
957 | 346
958 | 347
959 | 348
960 | 349
961 | 350
962 | 351
963 | 352
964 | 355
965 | 356
966 | 357
967 | 358
968 | 359
969 | 360
970 | 363
971 | 365
972 | 366
973 | 367
974 | 368
975 | 370
976 | 371
977 | 372
978 | 373
979 | 375
980 | 376
981 | 377
982 | 378
983 | 379
984 | 380
985 | 384
986 | 386
987 | 387
988 | 388
989 | 391
990 | 392
991 | 393
992 | 394
993 | 395
994 | 396
995 | 397
996 | 398
997 | 399
998 | 401
999 | 402
1000 | 403
1001 | 404
1002 | 405
1003 | 406
1004 | 407
1005 | 408
1006 | 409
1007 | 410
1008 | 411
1009 | 412
1010 | 413
1011 | 414
1012 | 415
1013 | 416
1014 | 417
1015 | 419
1016 | 420
1017 | 421
1018 | 425
1019 | 426
1020 | 427
1021 | 428
1022 | 429
1023 | 430
1024 | 431
1025 | 432
1026 | 433
1027 | 435
1028 | 436
1029 | 437
1030 | 438
1031 | 440
1032 | 441
1033 | 442
1034 | 444
1035 | 445
1036 | 446
1037 | 447
1038 | 448
1039 | 449
1040 | 450
1041 | 451
1042 | 452
1043 | 453
1044 | 454
1045 | 455
1046 | 456
1047 | 457
1048 | 458
1049 | 459
1050 | 460
1051 | 461
1052 | 462
1053 | 463
1054 | 465
1055 | 466
1056 | 467
1057 | 468
1058 | 469
1059 | 470
1060 | 471
1061 | 472
1062 | 473
1063 | 474
1064 | 475
1065 | 476
1066 | 477
1067 | 478
1068 | 479
1069 | 480
1070 | 481
1071 | 483
1072 | 484
1073 | 487
1074 | 489
1075 | 490
1076 | 491
1077 | 494
1078 | 500
1079 | 501
1080 | 502
1081 | 503
1082 | 504
1083 | 505
1084 | 506
1085 | 507
1086 | 508
1087 | 509
1088 | 510
1089 | 511
1090 | 512
1091 | 513
1092 | 514
1093 | 515
1094 | 516
1095 | 517
1096 | 518
1097 | 519
1098 | 520
1099 | 521
1100 | 522
1101 | 523
1102 | 524
1103 | 525
1104 | 526
1105 | 527
1106 | 528
1107 | 529
1108 | 530
1109 | 531
1110 | 532
1111 | 533
1112 | 555
1113 | 556
1114 | 558
1115 | 559
1116 | 563
1117 | 566
1118 | 567
1119 | 568
1120 | 569
1121 | 570
1122 | 572
1123 | 576
1124 | 577
1125 | 579
1126 | 580
1127 | 581
1128 | 586
1129 | 590
1130 | 594
1131 | 599
1132 | 601
1133 | 606
1134 | 609
1135 | 611
1136 | 614
1137 | 617
1138 | 618
1139 | 619
1140 | 621
1141 | 622
1142 | 623
1143 | 630
1144 | 631
1145 | 632
1146 | 637
1147 | 638
1148 | 639
1149 | 640
1150 | 641
1151 | 642
1152 | 643
1153 | 645
1154 | 646
1155 | 647
1156 | 648
1157 | 651
1158 | 653
1159 | 655
1160 | 659
1161 | 660
1162 | 662
1163 | 663
1164 | 664
1165 | 665
1166 | 667
1167 | 668
1168 | 670
1169 | 671
1170 | 672
1171 | 673
1172 | 674
1173 | 675
1174 | 677
1175 | 678
1176 | 679
1177 | 680
1178 | 682
1179 | 683
1180 | 684
1181 | 685
1182 | 687
1183 | 688
1184 | 689
1185 | 690
1186 | 693
1187 | 694
1188 | 695
1189 | 696
1190 | 698
1191 | 699
1192 | 700
1193 | 704
1194 | 705
1195 | 706
1196 | 707
1197 | 708
1198 | 709
1199 | 710
1200 | 711
1201 | 712
1202 | 713
1203 | 714
1204 | 715
1205 | 716
1206 | 717
1207 | 718
1208 | 719
1209 | 902
1210 | 910
1211 | 914
1212 | 922
1213 | 926
1214 | 930
1215 | 931
1216 | 932
1217 | 933
1218 | 937
1219 | 938
1220 | 939
1221 | 940
1222 | 942
1223 | 943
1224 | 946
1225 | 948
1226 | 950
1227 | 951
1228 | 952
1229 | 955
1230 | 957
1231 | 960
1232 | 961
1233 | 967
1234 | 2001
1235 | 2002
1236 | 2003
1237 | 2004
1238 | 2005
1239 | 2006
1240 | 2007
1241 | 2008
1242 | 2009
1243 | 2010
1244 | 2011
1245 | 2012
1246 | 2013
1247 | 2014
1248 | 2015
1249 | 2016
1250 | 2017
1251 | 2018
1252 | 2060
1253 | 2061
1254 | 2071
1255 | 2073
1256 | 2075
1257 | 2080
1258 | 2095
1259 | 2096
1260 | 2119
1261 | 2140
1262 | 2182
1263 | 2183
1264 | 2207
1265 | 2225
1266 | 2236
1267 | 2252
1268 | 2261
1269 | 2284
1270 | 2286
1271 | 2287
1272 | 2288
1273 | 2307
1274 | 2308
1275 | 2309
1276 | 2310
1277 | 2311
1278 | 2312
1279 | 2313
1280 | 2317
1281 | 2318
1282 | 2344
1283 | 2350
1284 | 2351
1285 | 2352
1286 | 2356
1287 | 2357
1288 | 2358
1289 | 2359
1290 | 2360
1291 | 2361
1292 )
1293 }
1294}
1295
1296impl UtilmdStromConditionEvaluatorFV2504 {
1297 fn evaluate_2006(&self, ctx: &EvaluationContext) -> ConditionResult {
1300 let nav = match ctx.navigator() {
1301 Some(n) => n,
1302 None => return ConditionResult::Unknown,
1303 };
1304 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1305 let mut qualifying_zeitraum_ids: Vec<String> = Vec::new();
1306 for i in 0..sg8_count {
1307 let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1308 let is_z01 = seq_segs.iter().any(|s| {
1309 s.elements
1310 .first()
1311 .and_then(|e| e.first())
1312 .is_some_and(|v| v == "Z01")
1313 });
1314 if is_z01 && matches!(self.evaluate(199, ctx), ConditionResult::True) {
1315 for seq in &seq_segs {
1316 if seq
1317 .elements
1318 .first()
1319 .and_then(|e| e.first())
1320 .is_some_and(|v| v == "Z01")
1321 {
1322 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1323 if !zid.is_empty() {
1324 qualifying_zeitraum_ids.push(zid.clone());
1325 }
1326 }
1327 }
1328 }
1329 }
1330 }
1331 if qualifying_zeitraum_ids.is_empty() {
1332 return ConditionResult::Unknown;
1333 }
1334 ConditionResult::True
1335 }
1336
1337 fn evaluate_2007(&self, ctx: &EvaluationContext) -> ConditionResult {
1340 let nav = match ctx.navigator() {
1341 Some(n) => n,
1342 None => return ConditionResult::Unknown,
1343 };
1344 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1345 let mut qualifying_zeitraum_ids: Vec<String> = Vec::new();
1346 for i in 0..sg8_count {
1347 let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1348 let is_z01 = seq_segs.iter().any(|s| {
1349 s.elements
1350 .first()
1351 .and_then(|e| e.first())
1352 .is_some_and(|v| v == "Z01")
1353 });
1354 if is_z01 && matches!(self.evaluate(199, ctx), ConditionResult::True) {
1355 for seq in &seq_segs {
1356 if seq
1357 .elements
1358 .first()
1359 .and_then(|e| e.first())
1360 .is_some_and(|v| v == "Z01")
1361 {
1362 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1363 if !zid.is_empty() {
1364 qualifying_zeitraum_ids.push(zid.clone());
1365 }
1366 }
1367 }
1368 }
1369 }
1370 }
1371 if qualifying_zeitraum_ids.is_empty() {
1372 return ConditionResult::Unknown;
1373 }
1374 ConditionResult::True
1375 }
1376
1377 fn evaluate_2008(&self, ctx: &EvaluationContext) -> ConditionResult {
1380 let nav = match ctx.navigator() {
1381 Some(n) => n,
1382 None => return ConditionResult::Unknown,
1383 };
1384 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1385 let mut qualifying_zeitraum_ids: Vec<String> = Vec::new();
1386 for i in 0..sg8_count {
1387 let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1388 let is_z01 = seq_segs.iter().any(|s| {
1389 s.elements
1390 .first()
1391 .and_then(|e| e.first())
1392 .is_some_and(|v| v == "Z01")
1393 });
1394 if is_z01 && matches!(self.evaluate(89, ctx), ConditionResult::True) {
1395 for seq in &seq_segs {
1396 if seq
1397 .elements
1398 .first()
1399 .and_then(|e| e.first())
1400 .is_some_and(|v| v == "Z01")
1401 {
1402 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1403 if !zid.is_empty() {
1404 qualifying_zeitraum_ids.push(zid.clone());
1405 }
1406 }
1407 }
1408 }
1409 }
1410 }
1411 if qualifying_zeitraum_ids.is_empty() {
1412 return ConditionResult::Unknown;
1413 }
1414 ConditionResult::True
1415 }
1416
1417 fn evaluate_2009(&self, ctx: &EvaluationContext) -> ConditionResult {
1420 let nav = match ctx.navigator() {
1421 Some(n) => n,
1422 None => return ConditionResult::Unknown,
1423 };
1424 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1425 let mut qualifying_zeitraum_ids: Vec<String> = Vec::new();
1426 for i in 0..sg8_count {
1427 let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1428 let is_z01 = seq_segs.iter().any(|s| {
1429 s.elements
1430 .first()
1431 .and_then(|e| e.first())
1432 .is_some_and(|v| v == "Z01")
1433 });
1434 if is_z01 && matches!(self.evaluate(89, ctx), ConditionResult::True) {
1435 for seq in &seq_segs {
1436 if seq
1437 .elements
1438 .first()
1439 .and_then(|e| e.first())
1440 .is_some_and(|v| v == "Z01")
1441 {
1442 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1443 if !zid.is_empty() {
1444 qualifying_zeitraum_ids.push(zid.clone());
1445 }
1446 }
1447 }
1448 }
1449 }
1450 }
1451 if qualifying_zeitraum_ids.is_empty() {
1452 return ConditionResult::Unknown;
1453 }
1454 ConditionResult::True
1455 }
1456
1457 fn evaluate_1(&self, ctx: &EvaluationContext) -> ConditionResult {
1459 ctx.external.evaluate("message_splitting")
1460 }
1461
1462 fn evaluate_4(&self, ctx: &EvaluationContext) -> ConditionResult {
1464 ctx.external.evaluate("recipient_is_lf")
1465 }
1466
1467 fn evaluate_5(&self, ctx: &EvaluationContext) -> ConditionResult {
1469 ctx.external.evaluate("sender_is_lf")
1470 }
1471
1472 fn evaluate_6(&self, ctx: &EvaluationContext) -> ConditionResult {
1474 ctx.external.evaluate("recipient_role_check")
1475 }
1476
1477 fn evaluate_7(&self, ctx: &EvaluationContext) -> ConditionResult {
1479 let sts_segs = ctx.find_segments("STS");
1480 let found = sts_segs.iter().any(|s| {
1481 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
1482 && s.elements.get(2).and_then(|e| e.first())
1483 .is_some_and(|v| ["ZG9", "ZH1", "ZH2"].contains(&v.as_str()))
1484 });
1485 ConditionResult::from(found)
1486 }
1487
1488 fn evaluate_8(&self, ctx: &EvaluationContext) -> ConditionResult {
1490 ctx.external.evaluate("data_clearing_required")
1491 }
1492
1493 fn evaluate_9(&self, ctx: &EvaluationContext) -> ConditionResult {
1495 ctx.external.evaluate("sender_role_check")
1496 }
1497
1498 fn evaluate_10(&self, ctx: &EvaluationContext) -> ConditionResult {
1500 ctx.has_qualified_value("STS", 0, "7", 4, 0, &["E01", "E03"])
1502 }
1503
1504 fn evaluate_11(&self, ctx: &EvaluationContext) -> ConditionResult {
1506 let sts_segs = ctx.find_segments("STS");
1507 let found = sts_segs.iter().any(|s| {
1508 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
1509 && s.elements.get(2).and_then(|e| e.first())
1510 .is_some_and(|v| ["ZG9", "ZH1", "ZH2"].contains(&v.as_str()))
1511 });
1512 ConditionResult::from(!found)
1513 }
1514
1515 fn evaluate_12(&self, ctx: &EvaluationContext) -> ConditionResult {
1517 let dtm_segs = ctx.find_segments("DTM");
1518 let found = dtm_segs.iter().any(|s| {
1519 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "471")
1520 });
1521 ConditionResult::from(!found)
1522 }
1523
1524 fn evaluate_13(&self, ctx: &EvaluationContext) -> ConditionResult {
1526 let sts_segs = ctx.find_segments("STS");
1527 let found = sts_segs.iter().any(|s| {
1528 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
1529 && s.elements.get(2).and_then(|e| e.first())
1530 .is_some_and(|v| ["Z01"].contains(&v.as_str()))
1531 });
1532 ConditionResult::from(!found)
1533 }
1534
1535 fn evaluate_14(&self, ctx: &EvaluationContext) -> ConditionResult {
1537 ctx.external.evaluate("date_known")
1538 }
1539
1540 fn evaluate_15(&self, ctx: &EvaluationContext) -> ConditionResult {
1542 let seq_segs = ctx.find_segments("SEQ");
1543 let found = seq_segs.iter().any(|s| {
1544 s.elements.first().and_then(|e| e.first())
1545 .is_some_and(|v| ["Z98"].contains(&v.as_str()))
1546 });
1547 ConditionResult::from(found)
1548 }
1549
1550 fn evaluate_16(&self, ctx: &EvaluationContext) -> ConditionResult {
1552 let sts_segs = ctx.find_segments("STS");
1553 let found = sts_segs.iter().any(|s| {
1554 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
1555 && s.elements.get(2).and_then(|e| e.first())
1556 .is_some_and(|v| ["Z12"].contains(&v.as_str()))
1557 });
1558 ConditionResult::from(found)
1559 }
1560
1561 fn evaluate_17(&self, ctx: &EvaluationContext) -> ConditionResult {
1563 let seq_segs = ctx.find_segments("SEQ");
1564 let found = seq_segs.iter().any(|s| {
1565 s.elements.first().and_then(|e| e.first())
1566 .is_some_and(|v| ["Z01", "Z80", "Z81"].contains(&v.as_str()))
1567 });
1568 ConditionResult::from(found)
1569 }
1570
1571 fn evaluate_18(&self, ctx: &EvaluationContext) -> ConditionResult {
1573 let dtm_segs = ctx.find_segments("DTM");
1574 let found = dtm_segs.iter().any(|s| {
1575 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "93")
1576 });
1577 ConditionResult::from(!found)
1578 }
1579
1580 fn evaluate_19(&self, ctx: &EvaluationContext) -> ConditionResult {
1582 let seq_segs = ctx.find_segments("SEQ");
1583 let found = seq_segs.iter().any(|s| {
1584 s.elements.first().and_then(|e| e.first())
1585 .is_some_and(|v| ["Z01", "Z98"].contains(&v.as_str()))
1586 });
1587 ConditionResult::from(found)
1588 }
1589
1590 fn evaluate_20(&self, ctx: &EvaluationContext) -> ConditionResult {
1592 let seq_segs = ctx.find_segments("SEQ");
1593 let found = seq_segs.iter().any(|s| {
1594 s.elements.first().and_then(|e| e.first())
1595 .is_some_and(|v| ["Z01"].contains(&v.as_str()))
1596 });
1597 ConditionResult::from(found)
1598 }
1599
1600 fn evaluate_21(&self, ctx: &EvaluationContext) -> ConditionResult {
1602 let cci_segs = ctx.find_segments("CCI");
1603 let found = cci_segs.iter().any(|s| {
1604 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA6")
1605 });
1606 ConditionResult::from(found)
1607 }
1608
1609 fn evaluate_22(&self, ctx: &EvaluationContext) -> ConditionResult {
1612 for qual in &["Z47", "Z48", "Z49"] {
1613 if matches!(
1614 ctx.groups_share_qualified_value(
1615 "RFF",
1616 0,
1617 qual,
1618 0,
1619 2,
1620 &["SG4", "SG6"],
1621 "SEQ",
1622 1,
1623 0,
1624 &["SG4", "SG8"],
1625 ),
1626 ConditionResult::True
1627 ) {
1628 return ConditionResult::True;
1629 }
1630 }
1631 ConditionResult::False
1632 }
1633
1634 fn evaluate_23(&self, ctx: &EvaluationContext) -> ConditionResult {
1636 let sts_segs = ctx.find_segments("STS");
1637 let found = sts_segs.iter().any(|s| {
1638 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
1639 && s.elements.get(2).and_then(|e| e.first())
1640 .is_some_and(|v| ["A05", "A99"].contains(&v.as_str()))
1641 });
1642 ConditionResult::from(found)
1643 }
1644
1645 fn evaluate_24(&self, ctx: &EvaluationContext) -> ConditionResult {
1647 let sts_segs = ctx.find_segments("STS");
1648 let found = sts_segs.iter().any(|s| {
1649 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
1650 && s.elements.get(2).and_then(|e| e.first())
1651 .is_some_and(|v| ["A25", "A99"].contains(&v.as_str()))
1652 });
1653 ConditionResult::from(found)
1654 }
1655
1656 fn evaluate_25(&self, _ctx: &EvaluationContext) -> ConditionResult {
1658 ConditionResult::Unknown
1660 }
1661
1662 fn evaluate_27(&self, ctx: &EvaluationContext) -> ConditionResult {
1664 let dtm_segs = ctx.find_segments("DTM");
1665 let found = dtm_segs.iter().any(|s| {
1666 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z01")
1667 && s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| {
1668 v.chars().nth(3).is_some_and(|c| ['T', 'R'].contains(&c))
1669 })
1670 });
1671 ConditionResult::from(found)
1672 }
1673
1674 fn evaluate_30(&self, ctx: &EvaluationContext) -> ConditionResult {
1676 ctx.external.evaluate("activation_response")
1678 }
1679
1680 fn evaluate_31(&self, ctx: &EvaluationContext) -> ConditionResult {
1682 ctx.external.evaluate("correction_in_progress")
1683 }
1684
1685 fn evaluate_32(&self, ctx: &EvaluationContext) -> ConditionResult {
1687 let seq_segs = ctx.find_segments("SEQ");
1688 ConditionResult::from(seq_segs.len() > 1)
1689 }
1690
1691 fn evaluate_33(&self, ctx: &EvaluationContext) -> ConditionResult {
1693 ctx.external.evaluate("code_list_membership_check")
1694 }
1695
1696 fn evaluate_34(&self, ctx: &EvaluationContext) -> ConditionResult {
1698 ctx.external.evaluate("deactivation_response")
1700 }
1701
1702 fn evaluate_35(&self, ctx: &EvaluationContext) -> ConditionResult {
1704 let dtm_segs = ctx.find_segments("DTM");
1705 let found = dtm_segs.iter().any(|s| {
1706 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z01")
1707 && s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| {
1708 v.chars().nth(3).is_some_and(|c| c == 'T')
1709 })
1710 });
1711 ConditionResult::from(found)
1712 }
1713
1714 fn evaluate_36(&self, ctx: &EvaluationContext) -> ConditionResult {
1716 ctx.external.evaluate("code_list_membership_check")
1717 }
1718
1719 fn evaluate_37(&self, ctx: &EvaluationContext) -> ConditionResult {
1721 ctx.has_qualified_value("STS", 0, "7", 4, 0, &["E01", "E03"])
1723 }
1724
1725 fn evaluate_38(&self, ctx: &EvaluationContext) -> ConditionResult {
1727 ctx.external.evaluate("code_list_membership_check")
1728 }
1729
1730 fn evaluate_39(&self, ctx: &EvaluationContext) -> ConditionResult {
1732 ctx.external.evaluate("code_list_membership_check")
1733 }
1734
1735 fn evaluate_40(&self, ctx: &EvaluationContext) -> ConditionResult {
1737 ctx.external.evaluate("code_list_membership_check")
1738 }
1739
1740 fn evaluate_41(&self, ctx: &EvaluationContext) -> ConditionResult {
1742 let seq_z79 = ctx.find_segments_with_qualifier("SEQ", 0, "Z79");
1744 if seq_z79.is_empty() {
1745 return ConditionResult::Unknown;
1746 }
1747 let found = seq_z79.iter().any(|s| {
1749 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| !v.is_empty())
1750 });
1751 ConditionResult::from(found)
1752 }
1753
1754 fn evaluate_42(&self, ctx: &EvaluationContext) -> ConditionResult {
1756 let seq_segs = ctx.find_segments("SEQ");
1757 let zh0_count = seq_segs.iter().filter(|s| {
1758 s.elements.first()
1759 .and_then(|e| e.first())
1760 .is_some_and(|v| v == "ZH0")
1761 }).count();
1762 ConditionResult::from(zh0_count > 1)
1763 }
1764
1765 fn evaluate_43(&self, ctx: &EvaluationContext) -> ConditionResult {
1767 let sts_segs = ctx.find_segments("STS");
1768 let found = sts_segs.iter().any(|s| {
1769 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
1770 && s.elements.get(2).and_then(|e| e.first())
1771 .is_some_and(|v| ["A12", "A13"].contains(&v.as_str()))
1772 });
1773 ConditionResult::from(found)
1774 }
1775
1776 fn evaluate_44(&self, _ctx: &EvaluationContext) -> ConditionResult {
1778 ConditionResult::True
1780 }
1781
1782 fn evaluate_45(&self, ctx: &EvaluationContext) -> ConditionResult {
1784 let cci_segs = ctx.find_segments("CCI");
1785 let found = cci_segs.iter().any(|s| {
1786 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z01")
1787 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "Z82")
1788 });
1789 ConditionResult::from(found)
1790 }
1791
1792 fn evaluate_46(&self, _ctx: &EvaluationContext) -> ConditionResult {
1794 ConditionResult::Unknown
1796 }
1797
1798 fn evaluate_47(&self, ctx: &EvaluationContext) -> ConditionResult {
1801 const CODES: &[&str] = &[
1802 "DBA", "VZR", "EGS", "LGS", "SLS", "SES", "TLS", "TES", "BIL", "BIP", "BIT", "GAL",
1803 "GAP", "GAT", "GEL", "GEP", "GET", "SOL", "SOP", "SOT", "WFL", "WFP", "WFT", "WNL",
1804 "WNP", "WNT",
1805 ];
1806 let nav = match ctx.navigator {
1807 Some(n) => n,
1808 None => return ConditionResult::Unknown,
1809 };
1810 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1811 for i in 0..sg8_count {
1812 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
1813 for j in 0..sg10_count {
1814 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
1815 let has_cci_15_z21 = ccis.iter().any(|s| {
1816 s.elements
1817 .first()
1818 .and_then(|e: &Vec<String>| e.first())
1819 .is_some_and(|v: &String| v == "15")
1820 && s.elements
1821 .get(2)
1822 .and_then(|e: &Vec<String>| e.first())
1823 .is_some_and(|v: &String| v == "Z21")
1824 });
1825 if has_cci_15_z21 {
1826 let cavs =
1827 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
1828 if cavs.iter().any(|s| {
1829 s.elements
1830 .first()
1831 .and_then(|e: &Vec<String>| e.first())
1832 .is_some_and(|v: &String| CODES.contains(&v.as_str()))
1833 }) {
1834 return ConditionResult::True;
1835 }
1836 }
1837 }
1838 }
1839 ConditionResult::False
1840 }
1841
1842 fn evaluate_48(&self, ctx: &EvaluationContext) -> ConditionResult {
1844 let sts_segs = ctx.find_segments("STS");
1845 let found = sts_segs.iter().any(|s| {
1846 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
1847 && s.elements.get(2).and_then(|e| e.first())
1848 .is_some_and(|v| ["A99"].contains(&v.as_str()))
1849 });
1850 ConditionResult::from(found)
1851 }
1852
1853 fn evaluate_49(&self, ctx: &EvaluationContext) -> ConditionResult {
1855 let sts_segs = ctx.find_segments("STS");
1856 let found = sts_segs.iter().any(|s| {
1857 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
1858 && s.elements.get(2).and_then(|e| e.first())
1859 .is_some_and(|v| ["E14"].contains(&v.as_str()))
1860 });
1861 ConditionResult::from(found)
1862 }
1863
1864 fn evaluate_50(&self, ctx: &EvaluationContext) -> ConditionResult {
1867 use std::collections::HashMap;
1868
1869 let seq_quals = ctx.collect_group_values("SEQ", 0, 0, &["SG4", "SG8"]);
1870 let seq_zeitraum = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
1871 let rff_quals = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG8"]);
1872 let rff_ids = ctx.collect_group_values("RFF", 0, 1, &["SG4", "SG8"]);
1873
1874 let mut rff_by_instance: HashMap<usize, Vec<(String, String)>> = HashMap::new();
1876 for ((idx, q), (_, id)) in rff_quals.iter().zip(rff_ids.iter()) {
1877 rff_by_instance
1878 .entry(*idx)
1879 .or_default()
1880 .push((q.clone(), id.clone()));
1881 }
1882
1883 let mut seq_zeitraum_map: HashMap<usize, String> = HashMap::new();
1885 for (idx, z) in &seq_zeitraum {
1886 seq_zeitraum_map.insert(*idx, z.clone());
1887 }
1888
1889 let z98_data: Vec<(String, String)> = seq_quals
1890 .iter()
1891 .filter(|(_, q)| q == "Z98")
1892 .map(|(idx, _)| {
1893 let zeitraum = seq_zeitraum_map.get(idx).cloned().unwrap_or_default();
1894 let marktlok = rff_by_instance
1895 .get(idx)
1896 .and_then(|rffs| rffs.iter().find(|(q, _)| q == "Z18"))
1897 .map(|(_, id)| id.clone())
1898 .unwrap_or_default();
1899 (zeitraum, marktlok)
1900 })
1901 .collect();
1902
1903 if z98_data.is_empty() {
1904 return ConditionResult::Unknown;
1905 }
1906
1907 let ze7_data: Vec<(String, String)> = seq_quals
1908 .iter()
1909 .filter(|(_, q)| q == "ZE7")
1910 .map(|(idx, _)| {
1911 let zeitraum = seq_zeitraum_map.get(idx).cloned().unwrap_or_default();
1912 let marktlok = rff_by_instance
1913 .get(idx)
1914 .and_then(|rffs| rffs.iter().find(|(q, _)| q == "Z18"))
1915 .map(|(_, id)| id.clone())
1916 .unwrap_or_default();
1917 (zeitraum, marktlok)
1918 })
1919 .collect();
1920
1921 ConditionResult::from(z98_data.iter().any(|(z98_zeit, z98_lok)| {
1922 !ze7_data
1923 .iter()
1924 .any(|(ze7_zeit, ze7_lok)| ze7_zeit == z98_zeit && ze7_lok == z98_lok)
1925 }))
1926 }
1927
1928 fn evaluate_51(&self, ctx: &EvaluationContext) -> ConditionResult {
1931 let nav = match ctx.navigator() {
1932 Some(n) => n,
1933 None => return ConditionResult::Unknown,
1934 };
1935 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1936 let pauschal_id = "9992000000018";
1937 let mut pauschal_zeitraum_ids: Vec<String> = Vec::new();
1939 for i in 0..sg8_count {
1940 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1941 let has_z78 = seqs.iter().any(|s| {
1942 s.elements
1943 .first()
1944 .and_then(|e| e.first())
1945 .is_some_and(|v| v == "Z78")
1946 });
1947 if !has_z78 {
1948 continue;
1949 }
1950 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
1951 let has_pauschal = rffs.iter().any(|s| {
1952 s.elements
1953 .first()
1954 .and_then(|e| e.first())
1955 .is_some_and(|v| v == "Z31")
1956 && s.elements
1957 .first()
1958 .and_then(|e| e.get(1))
1959 .is_some_and(|v| v.replace(' ', "") == pauschal_id)
1960 });
1961 if has_pauschal {
1962 for seq in &seqs {
1963 if seq
1964 .elements
1965 .first()
1966 .and_then(|e| e.first())
1967 .is_some_and(|v| v == "Z78")
1968 {
1969 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1970 if !zid.is_empty() {
1971 pauschal_zeitraum_ids.push(zid.clone());
1972 }
1973 }
1974 }
1975 }
1976 }
1977 }
1978 for i in 0..sg8_count {
1980 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1981 for seq in &seqs {
1982 if seq
1983 .elements
1984 .first()
1985 .and_then(|e| e.first())
1986 .is_some_and(|v| v == "Z98")
1987 {
1988 let zid = seq
1989 .elements
1990 .get(1)
1991 .and_then(|e| e.first())
1992 .map(|s| s.as_str())
1993 .unwrap_or("");
1994 if !zid.is_empty() && pauschal_zeitraum_ids.iter().any(|z| z == zid) {
1995 return ConditionResult::False;
1997 }
1998 }
1999 }
2000 }
2001 ConditionResult::True
2003 }
2004
2005 fn evaluate_52(&self, ctx: &EvaluationContext) -> ConditionResult {
2007 let cci_segs = ctx.find_segments("CCI");
2008 let found = cci_segs.iter().any(|s| {
2009 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z07")
2010 && s.elements.get(2).and_then(|e| e.first())
2011 .is_some_and(|v| ["Z55", "Z56"].contains(&v.as_str()))
2012 });
2013 ConditionResult::from(found)
2014 }
2015
2016 fn evaluate_53(&self, _ctx: &EvaluationContext) -> ConditionResult {
2018 ConditionResult::Unknown
2020 }
2021
2022 fn evaluate_54(&self, ctx: &EvaluationContext) -> ConditionResult {
2024 let seq_segs = ctx.find_segments("SEQ");
2025 let found = seq_segs.iter().any(|s| {
2026 s.elements.first().and_then(|e| e.first())
2027 .is_some_and(|v| ["Z01"].contains(&v.as_str()))
2028 });
2029 ConditionResult::from(found)
2030 }
2031
2032 fn evaluate_55(&self, ctx: &EvaluationContext) -> ConditionResult {
2034 let sts_segs = ctx.find_segments("STS");
2035 let found = sts_segs.iter().any(|s| {
2036 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
2037 && s.elements.get(2).and_then(|e| e.first())
2038 .is_some_and(|v| ["A06", "A99"].contains(&v.as_str()))
2039 });
2040 ConditionResult::from(found)
2041 }
2042
2043 fn evaluate_56(&self, ctx: &EvaluationContext) -> ConditionResult {
2045 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
2048 let found = sts_segs.iter().any(|s| {
2049 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| {
2050 ["A01", "A02", "A03", "A04", "A05", "A06", "A07", "A08", "A09", "A10",
2051 "A11", "A12", "A13", "A14", "A15", "A16", "A17", "A25"].contains(&v.as_str())
2052 })
2053 });
2054 ConditionResult::from(found)
2055 }
2056
2057 fn evaluate_57(&self, ctx: &EvaluationContext) -> ConditionResult {
2059 let cci_segs = ctx.find_segments("CCI");
2060 let found = cci_segs.iter().any(|s| {
2061 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z45")
2062 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZD9")
2063 });
2064 ConditionResult::from(found)
2065 }
2066
2067 fn evaluate_58(&self, ctx: &EvaluationContext) -> ConditionResult {
2069 let cci_segs = ctx.find_segments("CCI");
2070 let found = cci_segs.iter().any(|s| {
2071 s.elements.iter().any(|e| e.iter().any(|v| v == "293"))
2072 });
2073 ConditionResult::from(found)
2074 }
2075
2076 fn evaluate_60(&self, ctx: &EvaluationContext) -> ConditionResult {
2078 let bgm_segs = ctx.find_segments("BGM");
2079 let found = bgm_segs.iter().any(|s| {
2080 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z90")
2081 });
2082 ConditionResult::from(found)
2083 }
2084
2085 fn evaluate_61(&self, ctx: &EvaluationContext) -> ConditionResult {
2087 let bgm_segs = ctx.find_segments("BGM");
2088 let found = bgm_segs.iter().any(|s| {
2089 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z89")
2090 });
2091 ConditionResult::from(found)
2092 }
2093
2094 fn evaluate_62(&self, ctx: &EvaluationContext) -> ConditionResult {
2097 let nav = match ctx.navigator {
2098 Some(n) => n,
2099 None => return ConditionResult::Unknown,
2100 };
2101 use std::collections::HashMap;
2102 let mut count_by_zid: HashMap<String, u32> = HashMap::new();
2103 let sg4_count = nav.group_instance_count(&["SG4"]);
2104 for sg4_idx in 0..sg4_count {
2105 let sg8_count = nav.child_group_instance_count(&["SG4"], sg4_idx, "SG8");
2106 for sg8_idx in 0..sg8_count {
2107 let seqs =
2108 nav.find_segments_in_child_group("SEQ", &["SG4"], sg4_idx, "SG8", sg8_idx);
2109 let zeitraum_opt = seqs
2110 .iter()
2111 .filter(|s| {
2112 s.elements
2113 .first()
2114 .and_then(|e: &Vec<String>| e.first())
2115 .is_some_and(|v: &String| v == "Z45")
2116 })
2117 .filter_map(|s| {
2118 s.elements
2119 .get(1)
2120 .and_then(|e: &Vec<String>| e.first())
2121 .filter(|v| !v.is_empty())
2122 .cloned()
2123 })
2124 .next();
2125 let Some(zid) = zeitraum_opt else { continue };
2126 let pias =
2127 nav.find_segments_in_child_group("PIA", &["SG4"], sg4_idx, "SG8", sg8_idx);
2128 let has_qualifying_pia = pias.iter().any(|s| {
2129 s.elements
2130 .first()
2131 .and_then(|e: &Vec<String>| e.first())
2132 .is_some_and(|v: &String| v == "Z02")
2133 && s.elements
2134 .get(1)
2135 .and_then(|e: &Vec<String>| e.first())
2136 .map(|code| {
2137 code.starts_with("1-08-1")
2138 || code.starts_with("1-08-2")
2139 || code.starts_with("1-08-3")
2140 || code.starts_with("1-08-4")
2141 || code.starts_with("1-08-5")
2142 })
2143 .unwrap_or(false)
2144 });
2145 if has_qualifying_pia {
2146 *count_by_zid.entry(zid).or_insert(0) += 1;
2147 }
2148 }
2149 }
2150 ConditionResult::from(count_by_zid.values().any(|&c| c > 1))
2151 }
2152
2153 fn evaluate_63(&self, ctx: &EvaluationContext) -> ConditionResult {
2155 let sts_segs = ctx.find_segments("STS");
2156 let found = sts_segs.iter().any(|s| {
2157 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
2158 && s.elements.get(2).and_then(|e| e.first())
2159 .is_some_and(|v| ["A15", "A99"].contains(&v.as_str()))
2160 });
2161 ConditionResult::from(found)
2162 }
2163
2164 fn evaluate_64(&self, ctx: &EvaluationContext) -> ConditionResult {
2166 let pia_segs = ctx.find_segments("PIA");
2168 let count = pia_segs.iter().filter(|s| {
2169 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z02")
2170 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
2171 ["1-08-1", "1-08-2", "1-08-3", "1-08-4", "1-08-5"].iter().any(|p| v.starts_with(p))
2172 })
2173 }).count();
2174 ConditionResult::from(count > 1)
2175 }
2176
2177 fn evaluate_65(&self, ctx: &EvaluationContext) -> ConditionResult {
2179 let pia_segs = ctx.find_segments("PIA");
2181 let found = pia_segs.iter().any(|s| {
2182 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z02")
2183 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
2184 ["1-08-1", "1-08-2", "1-08-3", "1-08-4", "1-08-5"].iter().any(|p| v.starts_with(p))
2185 })
2186 });
2187 ConditionResult::from(found)
2188 }
2189
2190 fn evaluate_66(&self, ctx: &EvaluationContext) -> ConditionResult {
2192 let seq_segs = ctx.find_segments("SEQ");
2193 let count = seq_segs.iter().filter(|s| {
2194 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH0")
2195 }).count();
2196 ConditionResult::from(count > 1)
2197 }
2198
2199 fn evaluate_67(&self, ctx: &EvaluationContext) -> ConditionResult {
2201 let cav_segs = ctx.find_segments("CAV");
2203 let found = cav_segs.iter().any(|s| {
2204 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH9")
2205 && s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| v == "9991000002933")
2206 });
2207 ConditionResult::from(!found)
2208 }
2209
2210 fn evaluate_68(&self, ctx: &EvaluationContext) -> ConditionResult {
2212 let seq_segs = ctx.find_segments("SEQ");
2213 let count = seq_segs.iter().filter(|s| {
2214 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH0")
2215 }).count();
2216 ConditionResult::from(count > 2)
2217 }
2218
2219 fn evaluate_69(&self, ctx: &EvaluationContext) -> ConditionResult {
2221 let seq_segs = ctx.find_segments("SEQ");
2222 let count = seq_segs.iter().filter(|s| {
2223 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH0")
2224 }).count();
2225 ConditionResult::from(count > 3)
2226 }
2227
2228 fn evaluate_70(&self, ctx: &EvaluationContext) -> ConditionResult {
2230 let seq_segs = ctx.find_segments("SEQ");
2231 let count = seq_segs.iter().filter(|s| {
2232 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH0")
2233 }).count();
2234 ConditionResult::from(count == 5)
2235 }
2236
2237 fn evaluate_71(&self, ctx: &EvaluationContext) -> ConditionResult {
2239 ctx.external.evaluate("assignment_response")
2241 }
2242
2243 fn evaluate_72(&self, ctx: &EvaluationContext) -> ConditionResult {
2245 ctx.external.evaluate("assignment_end_response")
2247 }
2248
2249 fn evaluate_73(&self, ctx: &EvaluationContext) -> ConditionResult {
2251 let pia_segs = ctx.find_segments("PIA");
2254 let found = pia_segs.iter().any(|s| {
2255 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z02")
2256 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| !v.is_empty())
2257 });
2258 if found { ConditionResult::True } else { ConditionResult::Unknown }
2259 }
2260
2261 fn evaluate_74(&self, ctx: &EvaluationContext) -> ConditionResult {
2263 let seq_segs = ctx.find_segments("SEQ");
2264 let has_seq = seq_segs.iter().any(|s| {
2265 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z59")
2266 });
2267 let pia_segs = ctx.find_segments("PIA");
2268 let has_pia = pia_segs.iter().any(|s| {
2269 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
2270 });
2271 ConditionResult::from(has_seq && has_pia)
2272 }
2273
2274 fn evaluate_75(&self, ctx: &EvaluationContext) -> ConditionResult {
2276 ctx.external.evaluate("code_list_membership_check")
2277 }
2278
2279 fn evaluate_76(&self, ctx: &EvaluationContext) -> ConditionResult {
2282 ctx.has_qualifier("SEQ", 0, "Z49")
2283 }
2284
2285 fn evaluate_77(&self, ctx: &EvaluationContext) -> ConditionResult {
2287 let seq_segs = ctx.find_segments("SEQ");
2288 let found = seq_segs.iter().any(|s| {
2289 s.elements.first().and_then(|e| e.first())
2290 .is_some_and(|v| ["Z03"].contains(&v.as_str()))
2291 });
2292 ConditionResult::from(!found)
2293 }
2294
2295 fn evaluate_78(&self, ctx: &EvaluationContext) -> ConditionResult {
2297 let sts_segs = ctx.find_segments("STS");
2298 let found = sts_segs.iter().any(|s| {
2299 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
2300 && s.elements.get(2).and_then(|e| e.first())
2301 .is_some_and(|v| ["E02"].contains(&v.as_str()))
2302 });
2303 ConditionResult::from(!found)
2304 }
2305
2306 fn evaluate_83(&self, ctx: &EvaluationContext) -> ConditionResult {
2308 let sts_segs = ctx.find_segments("STS");
2309 let found = sts_segs.iter().any(|s| {
2310 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
2311 && s.elements.get(2).and_then(|e| e.first())
2312 .is_some_and(|v| ["A08", "A16", "A99"].contains(&v.as_str()))
2313 });
2314 ConditionResult::from(found)
2315 }
2316
2317 fn evaluate_84(&self, ctx: &EvaluationContext) -> ConditionResult {
2319 let sts_segs = ctx.find_segments("STS");
2320 let found = sts_segs.iter().any(|s| {
2321 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
2322 && s.elements.get(2).and_then(|e| e.first())
2323 .is_some_and(|v| ["A57"].contains(&v.as_str()))
2324 });
2325 ConditionResult::from(found)
2326 }
2327
2328 fn evaluate_85(&self, ctx: &EvaluationContext) -> ConditionResult {
2330 let dtm_segs = ctx.find_segments("DTM");
2331 let found = dtm_segs.iter().any(|s| {
2332 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z01")
2333 && s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| {
2334 v.chars().nth(3).is_some_and(|c| ['M', 'Q', 'H', 'J'].contains(&c))
2335 })
2336 });
2337 ConditionResult::from(found)
2338 }
2339
2340 fn evaluate_86(&self, ctx: &EvaluationContext) -> ConditionResult {
2342 ctx.groups_share_qualified_value(
2344 "RFF", 0, "Z50", 0, 2, &["SG4", "SG6"],
2345 "RFF", 0, 2, &["SG4", "SG8"],
2346 )
2347 }
2348
2349 fn evaluate_87(&self, ctx: &EvaluationContext) -> ConditionResult {
2351 let dtm_segs = ctx.find_segments("DTM");
2353 let found = dtm_segs.iter().any(|s| {
2354 s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| {
2355 v.len() >= 12
2356 && &v[6..8] == "01" && &v[8..12] == "0000" })
2359 });
2360 if !found {
2361 if dtm_segs.is_empty() {
2363 return ConditionResult::Unknown;
2364 }
2365 }
2366 ConditionResult::from(found)
2367 }
2368
2369 fn evaluate_88(&self, ctx: &EvaluationContext) -> ConditionResult {
2371 let dtm157 = ctx.find_segments_with_qualifier("DTM", 0, "157");
2373 if dtm157.is_empty() {
2374 return ConditionResult::Unknown;
2375 }
2376 ConditionResult::True
2378 }
2379
2380 fn evaluate_89(&self, ctx: &EvaluationContext) -> ConditionResult {
2383 let nav = match ctx.navigator {
2384 Some(n) => n,
2385 None => {
2386 return ctx.filtered_parent_child_has_qualifier(
2387 &["SG4", "SG8"],
2388 "SEQ",
2389 0,
2390 "Z01",
2391 "SG10",
2392 "CCI",
2393 2,
2394 "ZA6",
2395 )
2396 }
2397 };
2398 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
2399 for i in 0..sg8_count {
2400 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
2401 for j in 0..sg10_count {
2402 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
2403 let has_cci_za6 = ccis.iter().any(|s| {
2404 s.elements
2405 .get(2)
2406 .and_then(|e: &Vec<String>| e.first())
2407 .is_some_and(|v: &String| v == "ZA6")
2408 });
2409 if !has_cci_za6 {
2410 continue;
2411 }
2412 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
2413 if cavs.iter().any(|s| {
2414 s.elements
2415 .first()
2416 .and_then(|e: &Vec<String>| e.first())
2417 .is_some_and(|v: &String| v == "E14")
2418 }) {
2419 return ConditionResult::True;
2420 }
2421 }
2422 }
2423 ConditionResult::False
2424 }
2425
2426 fn evaluate_90(&self, ctx: &EvaluationContext) -> ConditionResult {
2429 let nav = match ctx.navigator {
2430 Some(n) => n,
2431 None => return ConditionResult::Unknown,
2432 };
2433 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
2434 for i in 0..sg8_count {
2435 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
2436 let mut has_za6_e14 = false;
2437 let mut has_za6_e02 = false;
2438 for j in 0..sg10_count {
2439 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
2440 let has_cci_za6 = ccis.iter().any(|s| {
2441 s.elements
2442 .get(2)
2443 .and_then(|e: &Vec<String>| e.first())
2444 .is_some_and(|v: &String| v == "ZA6")
2445 });
2446 if !has_cci_za6 {
2447 continue;
2448 }
2449 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
2450 for cav in &cavs {
2451 if let Some(code) = cav.elements.first().and_then(|e: &Vec<String>| e.first()) {
2452 if code == "E14" {
2453 has_za6_e14 = true;
2454 }
2455 if code == "E02" {
2456 has_za6_e02 = true;
2457 }
2458 }
2459 }
2460 }
2461 if has_za6_e14 && has_za6_e02 {
2462 return ConditionResult::True;
2463 }
2464 }
2465 ConditionResult::False
2466 }
2467
2468 fn evaluate_91(&self, ctx: &EvaluationContext) -> ConditionResult {
2471 match self.evaluate_90(ctx) {
2472 ConditionResult::True => ConditionResult::False,
2473 ConditionResult::False => ConditionResult::True,
2474 ConditionResult::Unknown => ConditionResult::Unknown,
2475 }
2476 }
2477
2478 fn evaluate_92(&self, _ctx: &EvaluationContext) -> ConditionResult {
2480 ConditionResult::Unknown
2482 }
2483
2484 fn evaluate_93(&self, _ctx: &EvaluationContext) -> ConditionResult {
2486 ConditionResult::Unknown
2488 }
2489
2490 fn evaluate_94(&self, _ctx: &EvaluationContext) -> ConditionResult {
2492 ConditionResult::True
2494 }
2495
2496 fn evaluate_95(&self, ctx: &EvaluationContext) -> ConditionResult {
2498 let cci_segs = ctx.find_segments("CCI");
2499 let has_cci = cci_segs.iter().any(|s| {
2500 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z17")
2501 });
2502 let cav_segs = ctx.find_segments("CAV");
2503 let has_cav = cav_segs.iter().any(|s| {
2504 s.elements.first().and_then(|e| e.first())
2505 .is_some_and(|v| ["ZE5"].contains(&v.as_str()))
2506 });
2507 ConditionResult::from(has_cci && has_cav)
2508 }
2509
2510 fn evaluate_96(&self, ctx: &EvaluationContext) -> ConditionResult {
2512 let sts_segs = ctx.find_segments("STS");
2513 let found = sts_segs.iter().any(|s| {
2514 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
2515 && s.elements.get(3).and_then(|e| e.first())
2516 .is_some_and(|v| ["ZAP"].contains(&v.as_str()))
2517 });
2518 ConditionResult::from(found)
2519 }
2520
2521 fn evaluate_97(&self, ctx: &EvaluationContext) -> ConditionResult {
2523 let cav_segs = ctx.find_segments("CAV");
2525 let found = cav_segs.iter().any(|s| {
2526 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH9")
2527 && s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| v == "9991000002420")
2528 });
2529 ConditionResult::from(found)
2530 }
2531
2532 fn evaluate_98(&self, ctx: &EvaluationContext) -> ConditionResult {
2534 ctx.external.evaluate("sender_role_check")
2535 }
2536
2537 fn evaluate_99(&self, ctx: &EvaluationContext) -> ConditionResult {
2539 ctx.external.evaluate("sender_role_check")
2540 }
2541
2542 fn evaluate_100(&self, ctx: &EvaluationContext) -> ConditionResult {
2544 let cav_segs = ctx.find_segments("CAV");
2545 let found = cav_segs.iter().any(|s| {
2546 s.elements.first().and_then(|e| e.first())
2547 .is_some_and(|v| ["TLS", "TES", "BIT", "GET", "GAT", "SOT", "WNT", "WFT", "WAT"].contains(&v.as_str()))
2548 });
2549 ConditionResult::from(found)
2550 }
2551
2552 fn evaluate_101(&self, ctx: &EvaluationContext) -> ConditionResult {
2554 let cci_segs = ctx.find_segments("CCI");
2555 let found = cci_segs.iter().any(|s| {
2556 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA6")
2557 });
2558 ConditionResult::from(found)
2559 }
2560
2561 fn evaluate_102(&self, ctx: &EvaluationContext) -> ConditionResult {
2563 let cci_segs = ctx.find_segments("CCI");
2564 let found = cci_segs.iter().any(|s| {
2565 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA6")
2566 });
2567 ConditionResult::from(found)
2568 }
2569
2570 fn evaluate_103(&self, ctx: &EvaluationContext) -> ConditionResult {
2572 let qty_segs = ctx.find_segments("QTY");
2573 let found = qty_segs.iter().any(|s| {
2574 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "265")
2575 });
2576 ConditionResult::from(found)
2577 }
2578
2579 fn evaluate_104(&self, ctx: &EvaluationContext) -> ConditionResult {
2581 let qty_segs = ctx.find_segments("QTY");
2582 let found = qty_segs.iter().any(|s| {
2583 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z08")
2584 });
2585 ConditionResult::from(found)
2586 }
2587
2588 fn evaluate_105(&self, ctx: &EvaluationContext) -> ConditionResult {
2590 let qty_segs = ctx.find_segments("QTY");
2591 let found = qty_segs.iter().any(|s| {
2592 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z10")
2593 });
2594 ConditionResult::from(found)
2595 }
2596
2597 fn evaluate_106(&self, ctx: &EvaluationContext) -> ConditionResult {
2599 ctx.filtered_parent_child_has_qualifier(
2601 &["SG4", "SG8"], "SEQ", 0, "Z01",
2602 "SG10", "CAV", 0, "E02",
2603 )
2604 }
2605
2606 fn evaluate_107(&self, ctx: &EvaluationContext) -> ConditionResult {
2608 let cav_segs = ctx.find_segments("CAV");
2609 let found = cav_segs.iter().any(|s| {
2610 s.elements.first().and_then(|e| e.first())
2611 .is_some_and(|v| ["SLS", "SES", "BIP", "GEP", "GAP", "SOP", "WNP", "WFP", "WAP"].contains(&v.as_str()))
2612 });
2613 ConditionResult::from(found)
2614 }
2615
2616 fn evaluate_108(&self, ctx: &EvaluationContext) -> ConditionResult {
2618 let pia_segs = ctx.find_segments("PIA");
2620 let found = pia_segs.iter().any(|s| {
2621 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z02")
2622 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
2623 ["1-08-1", "1-08-2", "1-08-3", "1-08-4", "1-08-5"].iter().any(|p| v.starts_with(p))
2624 })
2625 });
2626 ConditionResult::from(found)
2627 }
2628
2629 fn evaluate_110(&self, ctx: &EvaluationContext) -> ConditionResult {
2631 let cav_segs = ctx.find_segments("CAV");
2632 let found = cav_segs.iter().any(|s| {
2633 s.elements.first().and_then(|e| e.first())
2634 .is_some_and(|v| ["LGS", "EGS", "BIL", "GEL", "GAL", "SOL", "WNL", "WFL", "WAL"].contains(&v.as_str()))
2635 });
2636 ConditionResult::from(found)
2637 }
2638
2639 fn evaluate_111(&self, ctx: &EvaluationContext) -> ConditionResult {
2641 ctx.any_group_has_qualifier_without("SEQ", 0, "Z59", "PIA", 0, "5", &["SG4", "SG8"])
2642 }
2643
2644 fn evaluate_112(&self, ctx: &EvaluationContext) -> ConditionResult {
2646 let result = ctx.filtered_parent_child_has_qualifier(
2647 &["SG4", "SG8"],
2648 "SEQ",
2649 0,
2650 "Z59",
2651 "SG10",
2652 "CCI",
2653 0,
2654 "11",
2655 );
2656 match result {
2657 ConditionResult::True => ConditionResult::False,
2658 ConditionResult::False => ConditionResult::True,
2659 ConditionResult::Unknown => ConditionResult::Unknown,
2660 }
2661 }
2662
2663 fn evaluate_113(&self, ctx: &EvaluationContext) -> ConditionResult {
2665 ctx.external.evaluate("counting_time_order_response")
2667 }
2668
2669 fn evaluate_114(&self, ctx: &EvaluationContext) -> ConditionResult {
2672 let nav = match ctx.navigator {
2673 Some(n) => n,
2674 None => {
2675 return match (
2676 ctx.has_qualifier("CCI", 0, "E03"),
2677 ctx.has_qualifier("CAV", 0, "E06"),
2678 ) {
2679 (ConditionResult::True, ConditionResult::True) => ConditionResult::True,
2680 (ConditionResult::False, _) | (_, ConditionResult::False) => {
2681 ConditionResult::False
2682 }
2683 _ => ConditionResult::Unknown,
2684 };
2685 }
2686 };
2687 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
2688 for i in 0..sg8_count {
2689 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
2690 for j in 0..sg10_count {
2691 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
2692 let has_cci_e03 = ccis.iter().any(|s| {
2693 s.elements
2694 .first()
2695 .and_then(|e: &Vec<String>| e.first())
2696 .is_some_and(|v: &String| v == "E03")
2697 });
2698 if has_cci_e03 {
2699 let cavs =
2700 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
2701 if cavs.iter().any(|s| {
2702 s.elements
2703 .first()
2704 .and_then(|e: &Vec<String>| e.first())
2705 .is_some_and(|v: &String| v == "E06")
2706 }) {
2707 return ConditionResult::True;
2708 }
2709 }
2710 }
2711 }
2712 ConditionResult::False
2713 }
2714
2715 fn evaluate_115(&self, ctx: &EvaluationContext) -> ConditionResult {
2717 let cci_segs = ctx.find_segments("CCI");
2718 let has_cci = cci_segs.iter().any(|s| {
2719 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E03")
2720 });
2721 let cav_segs = ctx.find_segments("CAV");
2722 let has_cav = cav_segs.iter().any(|s| {
2723 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E05")
2724 });
2725 ConditionResult::from(has_cci && has_cav)
2726 }
2727
2728 fn evaluate_116(&self, ctx: &EvaluationContext) -> ConditionResult {
2730 let cci_segs = ctx.find_segments("CCI");
2731 let has_cci = cci_segs.iter().any(|s| {
2732 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E03")
2733 });
2734 let cav_segs = ctx.find_segments("CAV");
2735 let has_cav = cav_segs.iter().any(|s| {
2736 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E04")
2737 });
2738 ConditionResult::from(has_cci && has_cav)
2739 }
2740
2741 fn evaluate_117(&self, ctx: &EvaluationContext) -> ConditionResult {
2744 let nav = match ctx.navigator {
2745 Some(n) => n,
2746 None => return ConditionResult::Unknown,
2747 };
2748 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
2749 for i in 0..sg8_count {
2750 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
2751 for j in 0..sg10_count {
2752 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
2753 let has_cci_za6 = ccis.iter().any(|s| {
2754 s.elements
2755 .get(2)
2756 .and_then(|e: &Vec<String>| e.first())
2757 .is_some_and(|v: &String| v == "ZA6")
2758 });
2759 if has_cci_za6 {
2760 let cavs =
2761 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
2762 if cavs.iter().any(|s| {
2763 s.elements
2764 .first()
2765 .and_then(|e: &Vec<String>| e.first())
2766 .is_some_and(|v: &String| v == "E14")
2767 }) {
2768 return ConditionResult::True;
2769 }
2770 }
2771 }
2772 }
2773 ConditionResult::False
2774 }
2775
2776 fn evaluate_118(&self, ctx: &EvaluationContext) -> ConditionResult {
2778 let has_cci = ctx.filtered_parent_child_has_qualifier(
2779 &["SG4", "SG8"],
2780 "SEQ",
2781 0,
2782 "Z98",
2783 "SG10",
2784 "CCI",
2785 2,
2786 "ZA6",
2787 );
2788 if has_cci != ConditionResult::True {
2789 return has_cci;
2790 }
2791 ctx.filtered_parent_child_has_qualifier(
2792 &["SG4", "SG8"],
2793 "SEQ",
2794 0,
2795 "Z98",
2796 "SG10",
2797 "CAV",
2798 0,
2799 "E02",
2800 )
2801 }
2802
2803 fn evaluate_119(&self, ctx: &EvaluationContext) -> ConditionResult {
2805 let r1 = ctx.filtered_parent_child_has_qualifier(
2807 &["SG4", "SG8"], "SEQ", 0, "Z01",
2808 "SG10", "CAV", 0, "E02",
2809 );
2810 if r1 == ConditionResult::True { return ConditionResult::True; }
2811 ctx.filtered_parent_child_has_qualifier(
2812 &["SG4", "SG8"], "SEQ", 0, "Z98",
2813 "SG10", "CAV", 0, "E02",
2814 )
2815 }
2816
2817 fn evaluate_120(&self, _ctx: &EvaluationContext) -> ConditionResult {
2819 ConditionResult::Unknown
2821 }
2822
2823 fn evaluate_121(&self, ctx: &EvaluationContext) -> ConditionResult {
2825 let z03 =
2826 ctx.any_group_has_qualifier_without("SEQ", 0, "Z03", "RFF", 0, "Z14", &["SG4", "SG8"]);
2827 if z03 == ConditionResult::True {
2828 return ConditionResult::True;
2829 }
2830 ctx.any_group_has_qualifier_without("SEQ", 0, "ZF5", "RFF", 0, "Z14", &["SG4", "SG8"])
2831 }
2832
2833 fn evaluate_122(&self, ctx: &EvaluationContext) -> ConditionResult {
2836 let has_cci_e03 = ctx.filtered_parent_child_has_qualifier(
2838 &["SG4", "SG8"],
2839 "SEQ",
2840 0,
2841 "Z98",
2842 "SG10",
2843 "CCI",
2844 2,
2845 "E03",
2846 );
2847 if has_cci_e03 != ConditionResult::True {
2848 return has_cci_e03;
2849 }
2850 ctx.any_group_has_qualifier("CAV", 0, "E06", &["SG4", "SG8"])
2852 }
2853
2854 fn evaluate_123(&self, ctx: &EvaluationContext) -> ConditionResult {
2857 struct Sg8Z20Entry {
2858 mg_id: Option<String>,
2859 }
2860 let mut entries: Vec<Sg8Z20Entry> = Vec::new();
2861 let mut current: Option<Sg8Z20Entry> = None;
2862 for seg in ctx.segments {
2863 match seg.id.as_str() {
2864 "SEQ" => {
2865 if let Some(entry) = current.take() {
2866 entries.push(entry);
2867 }
2868 if seg
2869 .elements
2870 .first()
2871 .and_then(|e: &Vec<String>| e.first())
2872 .is_some_and(|v: &String| v == "Z20")
2873 {
2874 current = Some(Sg8Z20Entry { mg_id: None });
2875 }
2876 }
2877 "RFF" if current.is_some() => {
2878 if seg
2879 .elements
2880 .first()
2881 .and_then(|e: &Vec<String>| e.first())
2882 .is_some_and(|v: &String| v == "MG")
2883 {
2884 if let Some(ref mut entry) = current {
2885 if entry.mg_id.is_none() {
2886 entry.mg_id = seg.elements.first().and_then(|e| e.get(1)).cloned();
2887 }
2888 }
2889 }
2890 }
2891 _ => {}
2892 }
2893 }
2894 if let Some(entry) = current {
2895 entries.push(entry);
2896 }
2897 let ids: Vec<&str> = entries
2898 .iter()
2899 .filter_map(|e| e.mg_id.as_deref().filter(|s| !s.is_empty()))
2900 .collect();
2901 for i in 0..ids.len() {
2902 for j in (i + 1)..ids.len() {
2903 if ids[i] == ids[j] {
2904 return ConditionResult::True;
2905 }
2906 }
2907 }
2908 ConditionResult::False
2909 }
2910
2911 fn evaluate_124(&self, ctx: &EvaluationContext) -> ConditionResult {
2914 struct Sg8Z20Entry {
2915 zeitraum_id: String,
2916 mg_id: Option<String>,
2917 }
2918 let mut entries: Vec<Sg8Z20Entry> = Vec::new();
2919 let mut current: Option<Sg8Z20Entry> = None;
2920 for seg in ctx.segments {
2921 match seg.id.as_str() {
2922 "SEQ" => {
2923 if let Some(entry) = current.take() {
2924 entries.push(entry);
2925 }
2926 if seg
2927 .elements
2928 .first()
2929 .and_then(|e: &Vec<String>| e.first())
2930 .is_some_and(|v: &String| v == "Z20")
2931 {
2932 let zeitraum_id = seg
2933 .elements
2934 .get(1)
2935 .and_then(|e: &Vec<String>| e.first())
2936 .cloned()
2937 .unwrap_or_default();
2938 current = Some(Sg8Z20Entry {
2939 zeitraum_id,
2940 mg_id: None,
2941 });
2942 }
2943 }
2944 "RFF" if current.is_some() => {
2945 if seg
2946 .elements
2947 .first()
2948 .and_then(|e: &Vec<String>| e.first())
2949 .is_some_and(|v: &String| v == "MG")
2950 {
2951 if let Some(ref mut entry) = current {
2952 if entry.mg_id.is_none() {
2953 entry.mg_id = seg.elements.first().and_then(|e| e.get(1)).cloned();
2954 }
2955 }
2956 }
2957 }
2958 _ => {}
2959 }
2960 }
2961 if let Some(entry) = current {
2962 entries.push(entry);
2963 }
2964 for i in 0..entries.len() {
2965 for j in (i + 1)..entries.len() {
2966 let ei = &entries[i];
2967 let ej = &entries[j];
2968 if !ei.zeitraum_id.is_empty()
2969 && ei.zeitraum_id == ej.zeitraum_id
2970 && ei.mg_id.is_some()
2971 && !ei.mg_id.as_deref().unwrap_or("").is_empty()
2972 && ei.mg_id == ej.mg_id
2973 {
2974 return ConditionResult::True;
2975 }
2976 }
2977 }
2978 ConditionResult::False
2979 }
2980
2981 fn evaluate_125(&self, ctx: &EvaluationContext) -> ConditionResult {
2983 let seq_segs = ctx.find_segments("SEQ");
2984 let found = seq_segs.iter().any(|s| {
2985 s.elements.first().and_then(|e| e.first())
2986 .is_some_and(|v| ["Z76", "ZC5", "ZC6"].contains(&v.as_str()))
2987 });
2988 ConditionResult::from(found)
2989 }
2990
2991 fn evaluate_126(&self, ctx: &EvaluationContext) -> ConditionResult {
2993 let count = ctx.find_segments_with_qualifier("RFF", 0, "Z49").len()
2996 + ctx.find_segments_with_qualifier("RFF", 0, "Z53").len();
2997 ConditionResult::from(count > 0)
2998 }
2999
3000 fn evaluate_127(&self, ctx: &EvaluationContext) -> ConditionResult {
3002 let count = ctx.find_segments_with_qualifier("RFF", 0, "Z48").len()
3004 + ctx.find_segments_with_qualifier("RFF", 0, "Z55").len();
3005 ConditionResult::from(count > 0)
3006 }
3007
3008 fn evaluate_128(&self, ctx: &EvaluationContext) -> ConditionResult {
3010 let count = ctx.find_segments_with_qualifier("RFF", 0, "Z47").len()
3012 + ctx.find_segments_with_qualifier("RFF", 0, "Z54").len();
3013 ConditionResult::from(count > 0)
3014 }
3015
3016 fn evaluate_129(&self, ctx: &EvaluationContext) -> ConditionResult {
3018 let loc_segs = ctx.find_segments_with_qualifier("LOC", 0, "Z16");
3020 if loc_segs.len() <= 1 {
3021 return ConditionResult::True;
3022 }
3023 let first_val = loc_segs[0].elements.get(1).and_then(|e| e.first());
3024 let all_same = loc_segs.iter().all(|s| {
3025 s.elements.get(1).and_then(|e| e.first()) == first_val
3026 });
3027 ConditionResult::from(all_same)
3028 }
3029
3030 fn evaluate_130(&self, _ctx: &EvaluationContext) -> ConditionResult {
3032 ConditionResult::Unknown
3034 }
3035
3036 fn evaluate_131(&self, ctx: &EvaluationContext) -> ConditionResult {
3038 let has_zeitraum_id_1 = ctx.find_segments("RFF").iter().any(|s| {
3040 s.elements.first().and_then(|e| e.get(2)).is_some_and(|v| v == "1")
3041 });
3042 ConditionResult::from(has_zeitraum_id_1)
3043 }
3044
3045 fn evaluate_132(&self, ctx: &EvaluationContext) -> ConditionResult {
3048 let has_zeitraum_id_1 = ctx.find_segments("RFF").iter().any(|s| {
3050 s.elements
3051 .first()
3052 .and_then(|e| e.get(2))
3053 .is_some_and(|v: &String| v == "1")
3054 });
3055 if !has_zeitraum_id_1 {
3056 return ConditionResult::False;
3057 }
3058 let msg_date_str = match ctx
3060 .find_segments_with_qualifier("DTM", 0, "137")
3061 .into_iter()
3062 .next()
3063 {
3064 Some(seg) => match seg.elements.first().and_then(|e| e.get(1)) {
3065 Some(v) if v.len() >= 8 => v.clone(),
3066 _ => return ConditionResult::Unknown,
3067 },
3068 None => return ConditionResult::Unknown,
3069 };
3070 let usage_date_str = match ctx
3072 .find_segments_with_qualifier("DTM", 0, "Z25")
3073 .into_iter()
3074 .next()
3075 {
3076 Some(seg) => match seg.elements.first().and_then(|e| e.get(1)) {
3077 Some(v) if v.len() >= 12 => v.clone(),
3078 _ => return ConditionResult::Unknown,
3079 },
3080 None => return ConditionResult::Unknown,
3081 };
3082 let year: u32 = match msg_date_str[..4].parse() {
3084 Ok(v) => v,
3085 Err(_) => return ConditionResult::Unknown,
3086 };
3087 let month: u32 = match msg_date_str[4..6].parse() {
3088 Ok(v) => v,
3089 Err(_) => return ConditionResult::Unknown,
3090 };
3091 let day: u32 = match msg_date_str[6..8].parse() {
3092 Ok(v) => v,
3093 Err(_) => return ConditionResult::Unknown,
3094 };
3095 let days_in_month: u32 = match month {
3096 1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
3097 4 | 6 | 9 | 11 => 30,
3098 2 => {
3099 if year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) {
3100 29
3101 } else {
3102 28
3103 }
3104 }
3105 _ => return ConditionResult::Unknown,
3106 };
3107 let (next_year, next_month, next_day): (u32, u32, u32) = if day >= days_in_month {
3108 if month == 12 {
3109 (year + 1, 1, 1)
3110 } else {
3111 (year, month + 1, 1)
3112 }
3113 } else {
3114 (year, month, day + 1)
3115 };
3116 let expected_prefix = format!("{:04}{:02}{:02}0000", next_year, next_month, next_day);
3118 let actual_len = usage_date_str.len().min(12);
3119 let actual_prefix = &usage_date_str[..actual_len];
3120 ConditionResult::from(actual_prefix == expected_prefix.as_str())
3121 }
3122
3123 fn evaluate_133(&self, _ctx: &EvaluationContext) -> ConditionResult {
3125 ConditionResult::Unknown
3127 }
3128
3129 fn evaluate_134(&self, ctx: &EvaluationContext) -> ConditionResult {
3132 let nav = match ctx.navigator() {
3133 Some(n) => n,
3134 None => return ConditionResult::Unknown,
3135 };
3136 let sg6_count = nav.group_instance_count(&["SG4", "SG6"]);
3137 let mut slices: Vec<(u32, Option<String>, Option<String>)> = Vec::new();
3139 for i in 0..sg6_count {
3140 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG6"], i);
3141 let maybe_zid = rffs.iter().find_map(|s| {
3143 let qual = s
3144 .elements
3145 .first()
3146 .and_then(|e| e.first())
3147 .map(|v| v.as_str())?;
3148 if qual == "Z48" || qual == "Z55" {
3149 s.elements
3150 .first()
3151 .and_then(|e| e.get(2))
3152 .and_then(|v| v.parse::<u32>().ok())
3153 } else {
3154 None
3155 }
3156 });
3157 if let Some(zid) = maybe_zid {
3158 let dtms = nav.find_segments_in_group("DTM", &["SG4", "SG6"], i);
3159 let z25 = dtms.iter().find_map(|s| {
3160 if s.elements
3161 .first()
3162 .and_then(|e| e.first())
3163 .map(|v| v.as_str())
3164 == Some("Z25")
3165 {
3166 s.elements.first().and_then(|e| e.get(1)).cloned()
3167 } else {
3168 None
3169 }
3170 });
3171 let z26 = dtms.iter().find_map(|s| {
3172 if s.elements
3173 .first()
3174 .and_then(|e| e.first())
3175 .map(|v| v.as_str())
3176 == Some("Z26")
3177 {
3178 s.elements.first().and_then(|e| e.get(1)).cloned()
3179 } else {
3180 None
3181 }
3182 });
3183 slices.push((zid, z25, z26));
3184 }
3185 }
3186 if slices.is_empty() {
3187 return ConditionResult::Unknown;
3188 }
3189 for i in 0..slices.len() {
3191 let (zid, ref z25, _) = slices[i];
3192 if zid <= 1 {
3193 continue;
3194 }
3195 let prev_id = zid - 1;
3196 match slices.iter().find(|(id, _, _)| *id == prev_id) {
3197 Some((_, _, prev_z26)) => match (z25, prev_z26) {
3198 (Some(curr), Some(prev_end)) => {
3199 if curr != prev_end {
3200 return ConditionResult::False;
3201 }
3202 }
3203 _ => return ConditionResult::Unknown,
3204 },
3205 None => return ConditionResult::Unknown,
3206 }
3207 }
3208 ConditionResult::True
3209 }
3210
3211 fn evaluate_135(&self, ctx: &EvaluationContext) -> ConditionResult {
3214 let nav = match ctx.navigator() {
3215 Some(n) => n,
3216 None => return ConditionResult::Unknown,
3217 };
3218 let sg6_count = nav.group_instance_count(&["SG4", "SG6"]);
3219 let mut slices: Vec<(u32, Option<String>, Option<String>)> = Vec::new();
3221 for i in 0..sg6_count {
3222 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG6"], i);
3223 let maybe_zid = rffs.iter().find_map(|s| {
3225 let qual = s
3226 .elements
3227 .first()
3228 .and_then(|e| e.first())
3229 .map(|v| v.as_str())?;
3230 if qual == "Z47" || qual == "Z54" {
3231 s.elements
3232 .first()
3233 .and_then(|e| e.get(2))
3234 .and_then(|v| v.parse::<u32>().ok())
3235 } else {
3236 None
3237 }
3238 });
3239 if let Some(zid) = maybe_zid {
3240 let dtms = nav.find_segments_in_group("DTM", &["SG4", "SG6"], i);
3241 let z25 = dtms.iter().find_map(|s| {
3242 if s.elements
3243 .first()
3244 .and_then(|e| e.first())
3245 .map(|v| v.as_str())
3246 == Some("Z25")
3247 {
3248 s.elements.first().and_then(|e| e.get(1)).cloned()
3249 } else {
3250 None
3251 }
3252 });
3253 let z26 = dtms.iter().find_map(|s| {
3254 if s.elements
3255 .first()
3256 .and_then(|e| e.first())
3257 .map(|v| v.as_str())
3258 == Some("Z26")
3259 {
3260 s.elements.first().and_then(|e| e.get(1)).cloned()
3261 } else {
3262 None
3263 }
3264 });
3265 slices.push((zid, z25, z26));
3266 }
3267 }
3268 if slices.is_empty() {
3269 return ConditionResult::Unknown;
3270 }
3271 for i in 0..slices.len() {
3273 let (zid, ref z25, _) = slices[i];
3274 if zid <= 1 {
3275 continue;
3276 }
3277 let prev_id = zid - 1;
3278 match slices.iter().find(|(id, _, _)| *id == prev_id) {
3279 Some((_, _, prev_z26)) => match (z25, prev_z26) {
3280 (Some(curr), Some(prev_end)) => {
3281 if curr != prev_end {
3282 return ConditionResult::False;
3283 }
3284 }
3285 _ => return ConditionResult::Unknown,
3286 },
3287 None => return ConditionResult::Unknown,
3288 }
3289 }
3290 ConditionResult::True
3291 }
3292
3293 fn evaluate_136(&self, ctx: &EvaluationContext) -> ConditionResult {
3295 let cci_segs = ctx.find_segments("CCI");
3296 let found = cci_segs.iter().any(|s| {
3297 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "E13")
3298 });
3299 ConditionResult::from(found)
3300 }
3301
3302 fn evaluate_137(&self, ctx: &EvaluationContext) -> ConditionResult {
3304 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "7");
3307 let is_neuanlage = sts_segs.iter().any(|s| {
3308 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "E01" || v == "E03")
3309 });
3310 ConditionResult::from(!is_neuanlage)
3311 }
3312
3313 fn evaluate_138(&self, ctx: &EvaluationContext) -> ConditionResult {
3315 let qty_segs = ctx.find_segments("QTY");
3316 let found = qty_segs.iter().any(|s| {
3317 s.elements.first().and_then(|e| e.first())
3318 .is_some_and(|v| ["Z35"].contains(&v.as_str()))
3319 });
3320 ConditionResult::from(found)
3321 }
3322
3323 fn evaluate_139(&self, ctx: &EvaluationContext) -> ConditionResult {
3326 let nav = match ctx.navigator {
3327 Some(n) => n,
3328 None => return ctx.lacks_qualifier("CAV", 0, "IVA"),
3329 };
3330 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
3331 for i in 0..sg8_count {
3332 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
3333 for j in 0..sg10_count {
3334 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
3335 if cavs.iter().any(|s| {
3336 s.elements
3337 .first()
3338 .and_then(|e: &Vec<String>| e.first())
3339 .is_some_and(|v: &String| v == "IVA")
3340 }) {
3341 return ConditionResult::False;
3342 }
3343 }
3344 }
3345 ConditionResult::True
3346 }
3347
3348 fn evaluate_140(&self, ctx: &EvaluationContext) -> ConditionResult {
3350 let qty_segs = ctx.find_segments("QTY");
3351 let found = qty_segs.iter().any(|s| {
3352 s.elements.first().and_then(|e| e.first())
3353 .is_some_and(|v| ["Z34", "Z35"].contains(&v.as_str()))
3354 });
3355 ConditionResult::from(found)
3356 }
3357
3358 fn evaluate_141(&self, ctx: &EvaluationContext) -> ConditionResult {
3360 let cav_segs = ctx.find_segments("CAV");
3361 let found = cav_segs.iter().any(|s| {
3362 s.elements.first().and_then(|e| e.first())
3363 .is_some_and(|v| ["MIW", "MPW", "MBW"].contains(&v.as_str()))
3364 });
3365 ConditionResult::from(found)
3366 }
3367
3368 fn evaluate_142(&self, ctx: &EvaluationContext) -> ConditionResult {
3370 let pia_segs = ctx.find_segments("PIA");
3371 let found = pia_segs.iter().any(|s| {
3372 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z01")
3373 && s.elements.get(1).and_then(|e| e.get(1))
3374 .is_some_and(|v| ["Z04", "Z05"].contains(&v.as_str()))
3375 });
3376 ConditionResult::from(found)
3377 }
3378
3379 fn evaluate_143(&self, ctx: &EvaluationContext) -> ConditionResult {
3381 let sts_segs = ctx.find_segments("STS");
3382 let found = sts_segs.iter().any(|s| {
3383 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3384 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZX3")
3385 });
3386 ConditionResult::from(found)
3387 }
3388
3389 fn evaluate_144(&self, ctx: &EvaluationContext) -> ConditionResult {
3391 let sts_segs = ctx.find_segments("STS");
3392 let found = sts_segs.iter().any(|s| {
3393 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3394 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZAN")
3395 });
3396 ConditionResult::from(found)
3397 }
3398
3399 fn evaluate_145(&self, ctx: &EvaluationContext) -> ConditionResult {
3401 let sts_segs = ctx.find_segments("STS");
3402 let found = sts_segs.iter().any(|s| {
3403 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3404 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZX2")
3405 });
3406 ConditionResult::from(found)
3407 }
3408
3409 fn evaluate_146(&self, ctx: &EvaluationContext) -> ConditionResult {
3411 let sts_segs = ctx.find_segments("STS");
3412 let found = sts_segs.iter().any(|s| {
3413 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3414 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA0")
3415 });
3416 ConditionResult::from(found)
3417 }
3418
3419 fn evaluate_147(&self, _ctx: &EvaluationContext) -> ConditionResult {
3421 ConditionResult::Unknown
3423 }
3424
3425 fn evaluate_148(&self, ctx: &EvaluationContext) -> ConditionResult {
3427 let pia_segs = ctx.find_segments("PIA");
3428 let found = pia_segs.iter().any(|s| {
3429 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z02")
3430 && s.elements.get(1).and_then(|e| e.first())
3431 .is_some_and(|v| ["1-02-0-017", "1-02-0-018"].contains(&v.as_str()))
3432 });
3433 ConditionResult::from(found)
3434 }
3435
3436 fn evaluate_149(&self, ctx: &EvaluationContext) -> ConditionResult {
3439 use std::collections::{HashMap, HashSet};
3440 let seq_quals = ctx.collect_group_values("SEQ", 0, 0, &["SG4", "SG8"]);
3441 let seq_zeitraum = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
3442 let pia_quals = ctx.collect_group_values("PIA", 0, 0, &["SG4", "SG8"]);
3443 let pia_prods = ctx.collect_group_values("PIA", 1, 0, &["SG4", "SG8"]);
3444 let mut idx_to_zeitraum: HashMap<usize, String> = HashMap::new();
3446 for ((gi, q), (_, zid)) in seq_quals.iter().zip(seq_zeitraum.iter()) {
3447 if q == "Z45" && !zid.is_empty() {
3448 idx_to_zeitraum.insert(*gi, zid.clone());
3449 }
3450 }
3451 if idx_to_zeitraum.is_empty() {
3452 return ConditionResult::False;
3453 }
3454 let mut zeitraum_products: HashMap<String, HashSet<String>> = HashMap::new();
3456 for (i, (gi, qual)) in pia_quals.iter().enumerate() {
3457 if qual == "Z02" {
3458 if let Some(zid) = idx_to_zeitraum.get(gi) {
3459 if let Some((_, prod)) = pia_prods.get(i) {
3460 if !prod.is_empty() {
3461 zeitraum_products
3462 .entry(zid.clone())
3463 .or_default()
3464 .insert(prod.clone());
3465 }
3466 }
3467 }
3468 }
3469 }
3470 ConditionResult::from(
3471 zeitraum_products
3472 .values()
3473 .any(|codes| codes.contains("1-02-0-017") && codes.contains("1-02-0-018")),
3474 )
3475 }
3476
3477 fn evaluate_150(&self, ctx: &EvaluationContext) -> ConditionResult {
3479 let pia_segs = ctx.find_segments("PIA");
3480 let found = pia_segs.iter().any(|s| {
3481 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z02")
3482 && s.elements.get(1).and_then(|e| e.first())
3483 .is_some_and(|v| ["1-02-0-002"].contains(&v.as_str()))
3484 });
3485 ConditionResult::from(found)
3486 }
3487
3488 fn evaluate_151(&self, ctx: &EvaluationContext) -> ConditionResult {
3490 ctx.external.evaluate("code_list_membership_check")
3491 }
3492
3493 fn evaluate_152(&self, ctx: &EvaluationContext) -> ConditionResult {
3495 let ftx_segs = ctx.find_segments("FTX");
3496 let found = ftx_segs.iter().any(|s| {
3497 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z28")
3498 });
3499 ConditionResult::from(!found)
3500 }
3501
3502 fn evaluate_153(&self, ctx: &EvaluationContext) -> ConditionResult {
3504 let ftx_segs = ctx.find_segments("FTX");
3505 let found = ftx_segs.iter().any(|s| {
3506 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z27")
3507 });
3508 ConditionResult::from(!found)
3509 }
3510
3511 fn evaluate_156(&self, ctx: &EvaluationContext) -> ConditionResult {
3513 let ftx_segs = ctx.find_segments("FTX");
3514 let found = ftx_segs.iter().any(|s| {
3515 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z17")
3516 });
3517 ConditionResult::from(found)
3518 }
3519
3520 fn evaluate_161(&self, ctx: &EvaluationContext) -> ConditionResult {
3522 let sts_segs = ctx.find_segments("STS");
3523 let found = sts_segs.iter().any(|s| {
3524 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3525 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "E03")
3526 && s.elements.get(3).and_then(|e| e.first()).is_some_and(|v| v == "ZW8")
3527 });
3528 ConditionResult::from(found)
3529 }
3530
3531 fn evaluate_162(&self, ctx: &EvaluationContext) -> ConditionResult {
3533 let sts_segs = ctx.find_segments("STS");
3534 let found = sts_segs.iter().any(|s| {
3535 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3536 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "E03")
3537 && s.elements.get(3).and_then(|e| e.first()).is_some_and(|v| v == "ZW9")
3538 });
3539 ConditionResult::from(found)
3540 }
3541
3542 fn evaluate_163(&self, ctx: &EvaluationContext) -> ConditionResult {
3544 let sts_segs = ctx.find_segments("STS");
3545 let found = sts_segs.iter().any(|s| {
3546 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3547 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "E03")
3548 && s.elements.get(3).and_then(|e| e.first()).is_some_and(|v| v == "ZX0")
3549 });
3550 ConditionResult::from(found)
3551 }
3552
3553 fn evaluate_164(&self, ctx: &EvaluationContext) -> ConditionResult {
3555 let sts_segs = ctx.find_segments("STS");
3556 let found = sts_segs.iter().any(|s| {
3557 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3558 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "E03")
3559 && s.elements.get(3).and_then(|e| e.first()).is_some_and(|v| v == "ZX1")
3560 });
3561 ConditionResult::from(found)
3562 }
3563
3564 fn evaluate_165(&self, _ctx: &EvaluationContext) -> ConditionResult {
3566 ConditionResult::Unknown
3568 }
3569
3570 fn evaluate_166(&self, _ctx: &EvaluationContext) -> ConditionResult {
3572 ConditionResult::True
3574 }
3575
3576 fn evaluate_167(&self, ctx: &EvaluationContext) -> ConditionResult {
3578 let loc_segs = ctx.find_segments("LOC");
3579 let found = loc_segs.iter().any(|s| {
3580 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z21")
3581 });
3582 ConditionResult::from(found)
3583 }
3584
3585 fn evaluate_170(&self, _ctx: &EvaluationContext) -> ConditionResult {
3587 ConditionResult::Unknown
3589 }
3590
3591 fn evaluate_172(&self, ctx: &EvaluationContext) -> ConditionResult {
3593 let qty_segs = ctx.find_segments("QTY");
3594 let found = qty_segs.iter().any(|s| {
3595 s.elements.first().and_then(|e| e.first())
3596 .is_some_and(|v| ["Z37"].contains(&v.as_str()))
3597 });
3598 ConditionResult::from(found)
3599 }
3600
3601 fn evaluate_173(&self, ctx: &EvaluationContext) -> ConditionResult {
3604 use std::collections::HashSet;
3605 let seq_quals = ctx.collect_group_values("SEQ", 0, 0, &["SG4", "SG8"]);
3606 let target_indices: HashSet<usize> = seq_quals
3607 .iter()
3608 .filter(|(_, q)| matches!(q.as_str(), "Z58" | "ZC9" | "ZD0" | "ZD6"))
3609 .map(|(i, _)| *i)
3610 .collect();
3611 if target_indices.is_empty() {
3612 return ConditionResult::Unknown;
3613 }
3614 let rff_quals = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG8"]);
3616 let rff_de1156 = ctx.collect_group_values("RFF", 0, 2, &["SG4", "SG8"]);
3617 let mut found_rff_z33 = false;
3618 for (i, (gi, qual)) in rff_quals.iter().enumerate() {
3619 if qual == "Z33" && target_indices.contains(gi) {
3620 found_rff_z33 = true;
3621 let de1156_empty = rff_de1156.get(i).map(|(_, v)| v.is_empty()).unwrap_or(true);
3622 if de1156_empty {
3623 return ConditionResult::True;
3624 }
3625 }
3626 }
3627 if found_rff_z33 {
3628 ConditionResult::False
3629 } else {
3630 ConditionResult::Unknown
3631 }
3632 }
3633
3634 fn evaluate_174(&self, ctx: &EvaluationContext) -> ConditionResult {
3636 let rff_z33 = ctx.find_segments_with_qualifier("RFF", 0, "Z33");
3638 let found = rff_z33.iter().any(|s| {
3639 s.elements.first().and_then(|e| e.get(2)).is_some_and(|v| !v.is_empty())
3640 });
3641 ConditionResult::from(found)
3642 }
3643
3644 fn evaluate_175(&self, ctx: &EvaluationContext) -> ConditionResult {
3647 let nav = match ctx.navigator {
3648 Some(n) => n,
3649 None => return ConditionResult::Unknown,
3650 };
3651 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
3652 let mut entries: Vec<(usize, String, String)> = Vec::new();
3653 for i in 0..sg8_count {
3654 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
3655 if !seqs.iter().any(|s| {
3656 s.elements
3657 .first()
3658 .and_then(|e: &Vec<String>| e.first())
3659 .is_some_and(|v: &String| v == "Z58")
3660 }) {
3661 continue;
3662 }
3663 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
3664 for rff in &rffs {
3665 let elems = match rff.elements.first() {
3666 Some(e) => e,
3667 None => continue,
3668 };
3669 if elems.first().map(|s| s.as_str()) != Some("Z33") {
3670 continue;
3671 }
3672 let objektcode = elems.get(1).cloned().unwrap_or_default();
3673 let fort_nr = elems.get(2).cloned().unwrap_or_default();
3674 if !objektcode.is_empty() {
3675 entries.push((i, objektcode, fort_nr));
3676 }
3677 }
3678 }
3679 for a in 0..entries.len() {
3680 for b in (a + 1)..entries.len() {
3681 if entries[a].0 != entries[b].0
3682 && entries[a].1 == entries[b].1
3683 && entries[a].2 == entries[b].2
3684 {
3685 return ConditionResult::True;
3686 }
3687 }
3688 }
3689 ConditionResult::False
3690 }
3691
3692 fn evaluate_176(&self, ctx: &EvaluationContext) -> ConditionResult {
3694 let rff_segs = ctx.find_segments("RFF");
3695 let found = rff_segs.iter().any(|s| {
3696 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z34")
3697 });
3698 ConditionResult::from(found)
3699 }
3700
3701 fn evaluate_177(&self, ctx: &EvaluationContext) -> ConditionResult {
3703 let rff_segs = ctx.find_segments("RFF");
3704 let found = rff_segs.iter().any(|s| {
3705 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z35")
3706 });
3707 ConditionResult::from(found)
3708 }
3709
3710 fn evaluate_178(&self, ctx: &EvaluationContext) -> ConditionResult {
3712 let loc_segs = ctx.find_segments("LOC");
3713 let found = loc_segs.iter().any(|s| {
3714 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z18")
3715 });
3716 ConditionResult::from(found)
3717 }
3718
3719 fn evaluate_179(&self, ctx: &EvaluationContext) -> ConditionResult {
3721 let rff_z33 = ctx.find_segments_with_qualifier("RFF", 0, "Z33");
3723 let found = rff_z33.iter().any(|s| {
3724 s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| !v.is_empty())
3725 });
3726 ConditionResult::from(found)
3727 }
3728
3729 fn evaluate_180(&self, ctx: &EvaluationContext) -> ConditionResult {
3731 let qty_segs = ctx.find_segments("QTY");
3732 let found = qty_segs.iter().any(|s| {
3733 s.elements.first().and_then(|e| e.first())
3734 .is_some_and(|v| ["Z46"].contains(&v.as_str()))
3735 });
3736 ConditionResult::from(found)
3737 }
3738
3739 fn evaluate_184(&self, ctx: &EvaluationContext) -> ConditionResult {
3741 let seq_segs = ctx.find_segments("SEQ");
3742 let found = seq_segs.iter().any(|s| {
3743 s.elements.first().and_then(|e| e.first())
3744 .is_some_and(|v| ["Z18"].contains(&v.as_str()))
3745 });
3746 ConditionResult::from(found)
3747 }
3748
3749 fn evaluate_190(&self, ctx: &EvaluationContext) -> ConditionResult {
3751 let pia_segs = ctx.find_segments("PIA");
3753 let found = pia_segs.iter().any(|s| {
3754 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
3755 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| v == "9991000000721")
3756 });
3757 ConditionResult::from(found)
3758 }
3759
3760 fn evaluate_191(&self, ctx: &EvaluationContext) -> ConditionResult {
3762 let sts_segs = ctx.find_segments("STS");
3763 let found = sts_segs.iter().any(|s| {
3764 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
3765 });
3766 ConditionResult::from(!found)
3767 }
3768
3769 fn evaluate_192(&self, ctx: &EvaluationContext) -> ConditionResult {
3771 let sts_segs = ctx.find_segments("STS");
3772 let found = sts_segs.iter().any(|s| {
3773 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
3774 && s.elements.get(3).and_then(|e| e.first())
3775 .is_some_and(|v| ["ZW4", "ZAP"].contains(&v.as_str()))
3776 });
3777 ConditionResult::from(found)
3778 }
3779
3780 fn evaluate_193(&self, ctx: &EvaluationContext) -> ConditionResult {
3782 let nav = match ctx.navigator {
3783 Some(n) => n,
3784 None => {
3785 let cavs = ctx.find_segments("CAV");
3786 return ConditionResult::from(cavs.iter().any(|s| {
3787 s.elements
3788 .first()
3789 .and_then(|e: &Vec<String>| e.first())
3790 .is_some_and(|v: &String| v == "E06")
3791 }));
3792 }
3793 };
3794 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
3795 for i in 0..sg8_count {
3796 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
3797 for j in 0..sg10_count {
3798 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
3799 let has_cci_zb5 = ccis.iter().any(|s| {
3800 s.elements
3801 .get(2)
3802 .and_then(|e: &Vec<String>| e.first())
3803 .is_some_and(|v: &String| v == "ZB5")
3804 });
3805 if !has_cci_zb5 {
3806 continue;
3807 }
3808 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
3809 if cavs.iter().any(|s| {
3810 s.elements
3811 .first()
3812 .and_then(|e: &Vec<String>| e.first())
3813 .is_some_and(|v: &String| v == "E06")
3814 }) {
3815 return ConditionResult::True;
3816 }
3817 }
3818 }
3819 ConditionResult::False
3820 }
3821
3822 fn evaluate_194(&self, ctx: &EvaluationContext) -> ConditionResult {
3824 let cci_segs = ctx.find_segments("CCI");
3825 let has_cci = cci_segs.iter().any(|s| {
3826 s.elements.iter().any(|e| e.first().is_some_and(|v| v == "ZB5"))
3827 });
3828 let cav_segs = ctx.find_segments("CAV");
3829 let has_cav = cav_segs.iter().any(|s| {
3830 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E05")
3831 });
3832 ConditionResult::from(has_cci && has_cav)
3833 }
3834
3835 fn evaluate_195(&self, ctx: &EvaluationContext) -> ConditionResult {
3837 let cci_segs = ctx.find_segments("CCI");
3838 let has_cci = cci_segs.iter().any(|s| {
3839 s.elements.iter().any(|e| e.first().is_some_and(|v| v == "ZB5"))
3840 });
3841 let cav_segs = ctx.find_segments("CAV");
3842 let has_cav = cav_segs.iter().any(|s| {
3843 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E04")
3844 });
3845 ConditionResult::from(has_cci && has_cav)
3846 }
3847
3848 fn evaluate_196(&self, ctx: &EvaluationContext) -> ConditionResult {
3851 let nav = match ctx.navigator {
3852 Some(n) => n,
3853 None => return ConditionResult::Unknown,
3854 };
3855 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
3856 let mut entries: Vec<(usize, String, String, String, String)> = Vec::new();
3857 for i in 0..sg8_count {
3858 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
3859 let seq_opt = seqs.iter().find(|s| {
3860 s.elements
3861 .first()
3862 .and_then(|e: &Vec<String>| e.first())
3863 .is_some_and(|v: &String| matches!(v.as_str(), "Z58" | "ZC9" | "ZD0"))
3864 });
3865 let seq = match seq_opt {
3866 Some(s) => s,
3867 None => continue,
3868 };
3869 let seq_code = seq
3870 .elements
3871 .first()
3872 .and_then(|e: &Vec<String>| e.first())
3873 .cloned()
3874 .unwrap_or_default();
3875 let zeitraum_id = seq
3876 .elements
3877 .get(1)
3878 .and_then(|e: &Vec<String>| e.first())
3879 .cloned()
3880 .unwrap_or_default();
3881 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
3882 for rff in &rffs {
3883 let elems = match rff.elements.first() {
3884 Some(e) => e,
3885 None => continue,
3886 };
3887 if elems.first().map(|s| s.as_str()) != Some("Z33") {
3888 continue;
3889 }
3890 let objektcode = elems.get(1).cloned().unwrap_or_default();
3891 let fort_nr = elems.get(2).cloned().unwrap_or_default();
3892 if !objektcode.is_empty() {
3893 entries.push((
3894 i,
3895 seq_code.clone(),
3896 zeitraum_id.clone(),
3897 objektcode,
3898 fort_nr,
3899 ));
3900 }
3901 }
3902 }
3903 for a in 0..entries.len() {
3904 for b in (a + 1)..entries.len() {
3905 if entries[a].0 != entries[b].0
3906 && entries[a].1 == entries[b].1
3907 && entries[a].2 == entries[b].2
3908 && entries[a].3 == entries[b].3
3909 && entries[a].4 == entries[b].4
3910 {
3911 return ConditionResult::True;
3912 }
3913 }
3914 }
3915 ConditionResult::False
3916 }
3917
3918 fn evaluate_197(&self, ctx: &EvaluationContext) -> ConditionResult {
3921 let nav = match ctx.navigator {
3922 Some(n) => n,
3923 None => return ConditionResult::Unknown,
3924 };
3925 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
3926 let mut qualifying_malo_ids: Vec<String> = Vec::new();
3927 for i in 0..sg8_count {
3928 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
3929 if !seqs.iter().any(|s| {
3930 s.elements
3931 .first()
3932 .and_then(|e: &Vec<String>| e.first())
3933 .is_some_and(|v: &String| v == "Z01")
3934 }) {
3935 continue;
3936 }
3937 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
3938 let has_prog = (0..sg10_count).any(|j| {
3939 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
3940 let has_za6 = ccis.iter().any(|s| {
3941 s.elements
3942 .get(2)
3943 .and_then(|e: &Vec<String>| e.first())
3944 .is_some_and(|v: &String| v == "ZA6")
3945 });
3946 if !has_za6 {
3947 return false;
3948 }
3949 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
3950 cavs.iter().any(|s| {
3951 s.elements
3952 .first()
3953 .and_then(|e: &Vec<String>| e.first())
3954 .is_some_and(|v: &String| v == "E02")
3955 })
3956 });
3957 if !has_prog {
3958 continue;
3959 }
3960 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
3961 for rff in &rffs {
3962 let elems = match rff.elements.first() {
3963 Some(e) => e,
3964 None => continue,
3965 };
3966 if elems.first().map(|s| s.as_str()) != Some("Z18") {
3967 continue;
3968 }
3969 if let Some(malo_id) = elems.get(1) {
3970 if !malo_id.is_empty() {
3971 qualifying_malo_ids.push(malo_id.clone());
3972 }
3973 }
3974 }
3975 }
3976 if qualifying_malo_ids.is_empty() {
3977 return ConditionResult::False;
3978 }
3979 for i in 0..sg8_count {
3980 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
3981 for rff in &rffs {
3982 let elems = match rff.elements.first() {
3983 Some(e) => e,
3984 None => continue,
3985 };
3986 if elems.first().map(|s| s.as_str()) != Some("Z18") {
3987 continue;
3988 }
3989 if let Some(malo_id) = elems.get(1) {
3990 if qualifying_malo_ids.contains(malo_id) {
3991 return ConditionResult::True;
3992 }
3993 }
3994 }
3995 }
3996 ConditionResult::False
3997 }
3998
3999 fn evaluate_198(&self, ctx: &EvaluationContext) -> ConditionResult {
4001 let sts_segs = ctx.find_segments("STS");
4002 let found = sts_segs.iter().any(|s| {
4003 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
4004 && s.elements.get(2).and_then(|e| e.first())
4005 .is_some_and(|v| ["E03"].contains(&v.as_str()))
4006 });
4007 ConditionResult::from(found)
4008 }
4009
4010 fn evaluate_199(&self, ctx: &EvaluationContext) -> ConditionResult {
4013 let nav = match ctx.navigator {
4014 Some(n) => n,
4015 None => {
4016 return ctx.filtered_parent_child_has_qualifier(
4017 &["SG4", "SG8"],
4018 "SEQ",
4019 0,
4020 "Z01",
4021 "SG10",
4022 "CCI",
4023 2,
4024 "ZA6",
4025 )
4026 }
4027 };
4028 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
4029 for i in 0..sg8_count {
4030 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
4031 if !seqs.iter().any(|s| {
4032 s.elements
4033 .first()
4034 .and_then(|e: &Vec<String>| e.first())
4035 .is_some_and(|v: &String| v == "Z01")
4036 }) {
4037 continue;
4038 }
4039 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
4040 for j in 0..sg10_count {
4041 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
4042 if !ccis.iter().any(|s| {
4043 s.elements
4044 .get(2)
4045 .and_then(|e: &Vec<String>| e.first())
4046 .is_some_and(|v: &String| v == "ZA6")
4047 }) {
4048 continue;
4049 }
4050 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
4051 if cavs.iter().any(|s| {
4052 s.elements
4053 .first()
4054 .and_then(|e: &Vec<String>| e.first())
4055 .is_some_and(|v: &String| v == "E02")
4056 }) {
4057 return ConditionResult::True;
4058 }
4059 }
4060 }
4061 ConditionResult::False
4062 }
4063
4064 fn evaluate_201(&self, _ctx: &EvaluationContext) -> ConditionResult {
4066 ConditionResult::Unknown
4068 }
4069
4070 fn evaluate_202(&self, ctx: &EvaluationContext) -> ConditionResult {
4073 use std::collections::HashSet;
4074 let loc_zeitraum_ids: HashSet<String> = ctx
4076 .find_segments("LOC")
4077 .into_iter()
4078 .filter_map(|s| s.elements.get(1)?.get(3).cloned())
4079 .filter(|v| !v.is_empty())
4080 .collect();
4081 if loc_zeitraum_ids.is_empty() {
4082 return ConditionResult::False;
4083 }
4084 let matching_seq = ctx
4086 .find_segments_with_qualifier("SEQ", 0, "Z78")
4087 .into_iter()
4088 .any(|s| {
4089 s.elements
4090 .get(1)
4091 .and_then(|e: &Vec<String>| e.first())
4092 .is_some_and(|v: &String| {
4093 !v.is_empty() && loc_zeitraum_ids.contains(v.as_str())
4094 })
4095 });
4096 if !matching_seq {
4097 return ConditionResult::False;
4098 }
4099 ctx.has_qualifier("RFF", 0, "Z39")
4101 }
4102
4103 fn evaluate_203(&self, ctx: &EvaluationContext) -> ConditionResult {
4105 let sts_segs = ctx.find_segments("STS");
4106 let found = sts_segs.iter().any(|s| {
4107 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
4108 && s.elements.get(2).and_then(|e| e.first())
4109 .is_some_and(|v| ["E06", "Z39", "ZC6", "ZC7", "ZT6", "ZT7"].contains(&v.as_str()))
4110 });
4111 ConditionResult::from(found)
4112 }
4113
4114 fn evaluate_204(&self, ctx: &EvaluationContext) -> ConditionResult {
4117 for qual in &["Z03", "ZA3", "ZA4"] {
4119 if matches!(
4120 ctx.any_group_has_qualifier_without(
4121 "SEQ",
4122 0,
4123 qual,
4124 "RFF",
4125 0,
4126 "Z14",
4127 &["SG4", "SG8"]
4128 ),
4129 ConditionResult::True
4130 ) {
4131 return ConditionResult::True;
4132 }
4133 }
4134 ConditionResult::False
4135 }
4136
4137 fn evaluate_205(&self, ctx: &EvaluationContext) -> ConditionResult {
4139 let loc_segs = ctx.find_segments("LOC");
4140 let found = loc_segs.iter().any(|s| {
4141 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z19")
4142 });
4143 ConditionResult::from(found)
4144 }
4145
4146 fn evaluate_206(&self, ctx: &EvaluationContext) -> ConditionResult {
4148 let sts_segs = ctx.find_segments("STS");
4149 let found = sts_segs.iter().any(|s| {
4150 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
4151 && s.elements.get(2).and_then(|e| e.first())
4152 .is_some_and(|v| ["ZG5"].contains(&v.as_str()))
4153 });
4154 ConditionResult::from(!found)
4155 }
4156
4157 fn evaluate_209(&self, ctx: &EvaluationContext) -> ConditionResult {
4159 let dtm_segs = ctx.find_segments("DTM");
4160 let found = dtm_segs.iter().any(|s| {
4161 s.elements.first().and_then(|e| e.get(2)).is_some_and(|v| v == "303")
4162 });
4163 ConditionResult::from(found)
4164 }
4165
4166 fn evaluate_210(&self, ctx: &EvaluationContext) -> ConditionResult {
4168 let cci_segs = ctx.find_segments("CCI");
4169 let found = cci_segs.iter().any(|s| {
4170 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA6")
4171 });
4172 ConditionResult::from(found)
4173 }
4174
4175 fn evaluate_212(&self, ctx: &EvaluationContext) -> ConditionResult {
4177 let nad_segs = ctx.find_segments("NAD");
4178 let found = nad_segs.iter().any(|s| {
4179 s.elements.get(3).and_then(|e| e.first()).is_some_and(|v| !v.is_empty())
4180 });
4181 ConditionResult::from(!found)
4182 }
4183
4184 fn evaluate_213(&self, ctx: &EvaluationContext) -> ConditionResult {
4186 let nad_segs = ctx.find_segments("NAD");
4187 let found = nad_segs.iter().any(|s| {
4188 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z09")
4189 });
4190 ConditionResult::from(found)
4191 }
4192
4193 fn evaluate_215(&self, ctx: &EvaluationContext) -> ConditionResult {
4195 let has_cci_e13 = ctx.find_segments("CCI").iter().any(|s| {
4197 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "E13")
4198 });
4199 let has_cav_mme = ctx.find_segments("CAV").iter().any(|s| {
4200 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "MME")
4201 });
4202 ConditionResult::from(has_cci_e13 && has_cav_mme)
4203 }
4204
4205 fn evaluate_216(&self, ctx: &EvaluationContext) -> ConditionResult {
4207 let cci_segs = ctx.find_segments("CCI");
4208 let found = cci_segs.iter().any(|s| {
4209 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "Z88")
4210 });
4211 ConditionResult::from(found)
4212 }
4213
4214 fn evaluate_217(&self, ctx: &EvaluationContext) -> ConditionResult {
4216 let rff_segs = ctx.find_segments("RFF");
4217 let found = rff_segs.iter().any(|s| {
4218 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z49")
4219 });
4220 ConditionResult::from(found)
4221 }
4222
4223 fn evaluate_219(&self, ctx: &EvaluationContext) -> ConditionResult {
4225 let nad_segs = ctx.find_segments("NAD");
4226 let found = nad_segs.iter().any(|s| {
4227 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z65")
4228 });
4229 ConditionResult::from(found)
4230 }
4231
4232 fn evaluate_220(&self, ctx: &EvaluationContext) -> ConditionResult {
4234 let seq_segs = ctx.find_segments("SEQ");
4235 let has_seq = seq_segs.iter().any(|s| {
4236 s.elements.first().and_then(|e| e.first())
4237 .is_some_and(|v| ["Z01", "Z98"].contains(&v.as_str()))
4238 });
4239 let cci_segs = ctx.find_segments("CCI");
4240 let has_cci = cci_segs.iter().any(|s| {
4241 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z30") && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "Z06")
4242 });
4243 ConditionResult::from(has_seq && has_cci)
4244 }
4245
4246 fn evaluate_221(&self, ctx: &EvaluationContext) -> ConditionResult {
4248 let has_seq_z15 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z15").is_empty();
4250 if !has_seq_z15 {
4251 return ConditionResult::True;
4252 }
4253 ctx.any_group_has_qualifier_without(
4255 "SEQ", 0, "Z15", "RFF", 0, "Z18", &["SG4", "SG8"],
4256 )
4257 }
4258
4259 fn evaluate_223(&self, ctx: &EvaluationContext) -> ConditionResult {
4261 let rff_z18 = ctx.find_segments_with_qualifier("RFF", 0, "Z18");
4263 let loc_z16 = ctx.find_segments_with_qualifier("LOC", 0, "Z16");
4264 if rff_z18.is_empty() || loc_z16.is_empty() {
4265 return ConditionResult::Unknown;
4266 }
4267 let loc_ids: Vec<&str> = loc_z16.iter()
4269 .filter_map(|s| s.elements.get(1).and_then(|e| e.first()).map(|v| v.as_str()))
4270 .collect();
4271 let found = rff_z18.iter().any(|s| {
4272 s.elements.first().and_then(|e| e.get(1))
4273 .is_some_and(|v| loc_ids.contains(&v.as_str()))
4274 });
4275 ConditionResult::from(found)
4276 }
4277
4278 fn evaluate_224(&self, ctx: &EvaluationContext) -> ConditionResult {
4280 let has_seq_ze7 = !ctx.find_segments_with_qualifier("SEQ", 0, "ZE7").is_empty();
4282 if !has_seq_ze7 {
4283 return ConditionResult::True;
4284 }
4285 ctx.any_group_has_qualifier_without(
4286 "SEQ", 0, "ZE7", "RFF", 0, "Z18", &["SG4", "SG8"],
4287 )
4288 }
4289
4290 fn evaluate_227(&self, ctx: &EvaluationContext) -> ConditionResult {
4292 let r1 = ctx.filtered_parent_child_has_qualifier(
4294 &["SG4", "SG8"], "SEQ", 0, "Z98",
4295 "SG10", "CAV", 0, "E14",
4296 );
4297 if r1 == ConditionResult::True { return ConditionResult::True; }
4298 ctx.filtered_parent_child_has_qualifier(
4299 &["SG4", "SG8"], "SEQ", 0, "Z98",
4300 "SG10", "CAV", 0, "ETK",
4301 )
4302 }
4303
4304 fn evaluate_229(&self, ctx: &EvaluationContext) -> ConditionResult {
4307 use std::collections::HashSet;
4308 let target_quals: HashSet<&str> = ["Z58", "ZC9", "ZD0", "ZD6"].iter().cloned().collect();
4309 let seq_quals = ctx.collect_group_values("SEQ", 0, 0, &["SG4", "SG8"]);
4311 let seq_zeitraums = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
4312 let rff_quals = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG8"]);
4314 let rff_codes = ctx.collect_group_values("RFF", 0, 1, &["SG4", "SG8"]);
4315 let mut seen: HashSet<(String, String, String)> = HashSet::new();
4317 for (idx, seq_qual) in &seq_quals {
4318 if seq_qual.is_empty() || !target_quals.contains(seq_qual.as_str()) {
4319 continue;
4320 }
4321 let zeitraum_id = seq_zeitraums
4322 .iter()
4323 .find(|(i, _)| i == idx)
4324 .map(|(_, v)| v.as_str())
4325 .unwrap_or("");
4326 for (ridx, rff_qual) in rff_quals.iter() {
4328 if ridx != idx || rff_qual != "Z33" {
4329 continue;
4330 }
4331 if let Some((_, obj_code)) = rff_codes.iter().find(|(i, _)| i == ridx) {
4332 if obj_code.is_empty() {
4333 continue;
4334 }
4335 let key = (seq_qual.clone(), zeitraum_id.to_string(), obj_code.clone());
4336 if seen.contains(&key) {
4337 return ConditionResult::True;
4338 }
4339 seen.insert(key);
4340 }
4341 }
4342 }
4343 ConditionResult::False
4344 }
4345
4346 fn evaluate_232(&self, ctx: &EvaluationContext) -> ConditionResult {
4348 let cci_segs = ctx.find_segments("CCI");
4349 let found = cci_segs.iter().any(|s| {
4350 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "Z83")
4351 });
4352 ConditionResult::from(found)
4353 }
4354
4355 fn evaluate_233(&self, ctx: &EvaluationContext) -> ConditionResult {
4357 ctx.external.evaluate("recipient_role_check")
4358 }
4359
4360 fn evaluate_234(&self, ctx: &EvaluationContext) -> ConditionResult {
4362 let cci_segs = ctx.find_segments("CCI");
4363 let found = cci_segs.iter().any(|s| {
4364 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "Z83")
4365 });
4366 ConditionResult::from(found)
4367 }
4368
4369 fn evaluate_237(&self, ctx: &EvaluationContext) -> ConditionResult {
4371 let pia_segs = ctx.find_segments("PIA");
4373 let found = pia_segs.iter().any(|s| {
4374 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z02")
4375 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4376 v.starts_with("1-08") && v.contains("AGS")
4377 })
4378 });
4379 ConditionResult::from(found)
4380 }
4381
4382 fn evaluate_238(&self, ctx: &EvaluationContext) -> ConditionResult {
4384 let ide_segs = ctx.find_segments("IDE");
4385 let found = ide_segs.iter().any(|s| {
4386 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "24")
4387 });
4388 ConditionResult::from(!found)
4389 }
4390
4391 fn evaluate_239(&self, ctx: &EvaluationContext) -> ConditionResult {
4393 let cci_segs = ctx.find_segments("CCI");
4394 let found = cci_segs.iter().any(|s| {
4395 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z17")
4396 });
4397 ConditionResult::from(found)
4398 }
4399
4400 fn evaluate_240(&self, ctx: &EvaluationContext) -> ConditionResult {
4402 let seq_segs = ctx.find_segments("SEQ");
4403 let found = seq_segs.iter().any(|s| {
4404 s.elements.first().and_then(|e| e.first())
4405 .is_some_and(|v| ["Z01"].contains(&v.as_str()))
4406 });
4407 ConditionResult::from(found)
4408 }
4409
4410 fn evaluate_241(&self, ctx: &EvaluationContext) -> ConditionResult {
4412 ctx.external.evaluate("recipient_role_check")
4413 }
4414
4415 fn evaluate_243(&self, ctx: &EvaluationContext) -> ConditionResult {
4417 let cci_segs = ctx.find_segments("CCI");
4418 let found = cci_segs.iter().any(|s| {
4419 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "6")
4420 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA8")
4421 });
4422 ConditionResult::from(found)
4423 }
4424
4425 fn evaluate_244(&self, ctx: &EvaluationContext) -> ConditionResult {
4427 let cci_segs = ctx.find_segments("CCI");
4428 let found = cci_segs.iter().any(|s| {
4429 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "6")
4430 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA9")
4431 });
4432 ConditionResult::from(found)
4433 }
4434
4435 fn evaluate_248(&self, _ctx: &EvaluationContext) -> ConditionResult {
4437 ConditionResult::Unknown
4439 }
4440
4441 fn evaluate_249(&self, ctx: &EvaluationContext) -> ConditionResult {
4443 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
4445 if sts_segs.len() <= 1 {
4446 return ConditionResult::True;
4447 }
4448 let first_val = sts_segs[0].elements.first().and_then(|e| e.get(1));
4449 let all_same = sts_segs.iter().all(|s| {
4450 s.elements.first().and_then(|e| e.get(1)) == first_val
4451 });
4452 ConditionResult::from(all_same)
4453 }
4454
4455 fn evaluate_251(&self, ctx: &EvaluationContext) -> ConditionResult {
4457 ctx.external.evaluate("sender_role_check")
4458 }
4459
4460 fn evaluate_252(&self, ctx: &EvaluationContext) -> ConditionResult {
4462 let unb_segs = ctx.find_segments("UNB");
4463 let found = unb_segs.iter().any(|s| {
4464 s.elements.get(4).and_then(|e| e.first()).is_some_and(|v| !v.is_empty())
4465 });
4466 ConditionResult::from(found)
4467 }
4468
4469 fn evaluate_254(&self, _ctx: &EvaluationContext) -> ConditionResult {
4471 ConditionResult::True }
4474
4475 fn evaluate_255(&self, _ctx: &EvaluationContext) -> ConditionResult {
4477 ConditionResult::Unknown
4479 }
4480
4481 fn evaluate_256(&self, ctx: &EvaluationContext) -> ConditionResult {
4483 let pia_segs = ctx.find_segments("PIA");
4485 let found = pia_segs.iter().any(|s| {
4486 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
4487 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4488 (v.contains(":1.8.") || v.contains(":2.8.")) && v.starts_with("1-")
4489 })
4490 });
4491 ConditionResult::from(found)
4492 }
4493
4494 fn evaluate_257(&self, ctx: &EvaluationContext) -> ConditionResult {
4496 let pia_segs = ctx.find_segments("PIA");
4498 let found = pia_segs.iter().any(|s| {
4499 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
4500 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4501 v.contains(":1.9.") && v.starts_with("1-")
4502 })
4503 });
4504 ConditionResult::from(found)
4505 }
4506
4507 fn evaluate_259(&self, ctx: &EvaluationContext) -> ConditionResult {
4509 let pia_segs = ctx.find_segments("PIA");
4510 let found = pia_segs.iter().any(|s| {
4511 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4512 let prefixes = ["1-01", "1-03", "1-05"];
4513 prefixes.iter().any(|p| v.starts_with(p))
4514 })
4515 });
4516 ConditionResult::from(found)
4517 }
4518
4519 fn evaluate_261(&self, ctx: &EvaluationContext) -> ConditionResult {
4521 let pia_segs = ctx.find_segments("PIA");
4522 let found = pia_segs.iter().any(|s| {
4523 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4524 let prefixes = ["1-07-1", "2", "1-10-1", "2", "4", "5", "6", "7", "8", "9", "1-11-1"];
4525 prefixes.iter().any(|p| v.starts_with(p))
4526 })
4527 });
4528 ConditionResult::from(found)
4529 }
4530
4531 fn evaluate_262(&self, _ctx: &EvaluationContext) -> ConditionResult {
4533 ConditionResult::Unknown
4535 }
4536
4537 fn evaluate_265(&self, ctx: &EvaluationContext) -> ConditionResult {
4539 for &seq_qual in &["Z01", "Z98"] {
4541 for &cav_qual in &["E14", "ETK"] {
4542 let r = ctx.filtered_parent_child_has_qualifier(
4543 &["SG4", "SG8"], "SEQ", 0, seq_qual,
4544 "SG10", "CAV", 0, cav_qual,
4545 );
4546 if r == ConditionResult::True { return ConditionResult::True; }
4547 }
4548 }
4549 ConditionResult::False
4550 }
4551
4552 fn evaluate_266(&self, ctx: &EvaluationContext) -> ConditionResult {
4555 let nav = match ctx.navigator {
4556 Some(n) => n,
4557 None => {
4558 return ctx.filtered_parent_child_has_qualifier(
4560 &["SG4", "SG8"],
4561 "SEQ",
4562 0,
4563 "Z01",
4564 "SG10",
4565 "CAV",
4566 0,
4567 "Z36",
4568 );
4569 }
4570 };
4571 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
4572 for i in 0..sg8_count {
4573 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
4574 for j in 0..sg10_count {
4575 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
4577 let has_cci_za6 = ccis.iter().any(|s| {
4578 s.elements
4579 .get(2)
4580 .and_then(|e: &Vec<String>| e.first())
4581 .is_some_and(|v: &String| v == "ZA6")
4582 });
4583 if has_cci_za6 {
4584 let cavs =
4585 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
4586 if cavs.iter().any(|s| {
4587 s.elements
4588 .first()
4589 .and_then(|e: &Vec<String>| e.first())
4590 .is_some_and(|v: &String| v == "Z36")
4591 }) {
4592 return ConditionResult::True;
4593 }
4594 }
4595 }
4596 }
4597 ConditionResult::False
4598 }
4599
4600 fn evaluate_267(&self, ctx: &EvaluationContext) -> ConditionResult {
4602 let seq_segs = ctx.find_segments("SEQ");
4603 let found = seq_segs.iter().any(|s| {
4604 s.elements.first().and_then(|e| e.first())
4605 .is_some_and(|v| ["Z38"].contains(&v.as_str()))
4606 });
4607 ConditionResult::from(!found)
4608 }
4609
4610 fn evaluate_268(&self, _ctx: &EvaluationContext) -> ConditionResult {
4612 ConditionResult::True
4614 }
4615
4616 fn evaluate_269(&self, _ctx: &EvaluationContext) -> ConditionResult {
4618 ConditionResult::Unknown
4620 }
4621
4622 fn evaluate_270(&self, ctx: &EvaluationContext) -> ConditionResult {
4624 let pia_segs = ctx.find_segments("PIA");
4625 let found = pia_segs.iter().any(|s| {
4626 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4627 let prefixes = ["1-02", "1-04", "1-06", "1-09"];
4628 prefixes.iter().any(|p| v.starts_with(p))
4629 })
4630 });
4631 ConditionResult::from(found)
4632 }
4633
4634 fn evaluate_273(&self, ctx: &EvaluationContext) -> ConditionResult {
4636 let pia_segs = ctx.find_segments("PIA");
4638 let found = pia_segs.iter().any(|s| {
4639 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
4640 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4641 v.starts_with("1-") && (v.contains(":1.8.") || v.contains(":2.8.") || v.contains(":1.29."))
4642 })
4643 });
4644 ConditionResult::from(found)
4645 }
4646
4647 fn evaluate_279(&self, ctx: &EvaluationContext) -> ConditionResult {
4649 let sts_segs = ctx.find_segments("STS");
4650 let found = sts_segs.iter().any(|s| {
4651 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
4652 && s.elements.get(3).and_then(|e| e.first())
4653 .is_some_and(|v| ["ZW4", "ZAP"].contains(&v.as_str()))
4654 });
4655 ConditionResult::from(found)
4656 }
4657
4658 fn evaluate_280(&self, ctx: &EvaluationContext) -> ConditionResult {
4660 ctx.external.evaluate("sector_check")
4663 }
4664
4665 fn evaluate_282(&self, ctx: &EvaluationContext) -> ConditionResult {
4667 let pia_segs = ctx.find_segments("PIA");
4669 let found = pia_segs.iter().any(|s| {
4670 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4671 v.starts_with("1-01-6-005") || v.starts_with("1-01-9-001") || v.starts_with("1-01-9-002")
4672 || v.starts_with("1-07-3-001") || v.starts_with("1-08-1-001")
4673 || v.starts_with("1-08-3-001") || v.starts_with("1-08-4-001")
4674 || v.starts_with("1-08-4-002") || v.starts_with("1-08-4-003")
4675 || v.starts_with("1-08-5")
4676 })
4677 });
4678 ConditionResult::from(found)
4679 }
4680
4681 fn evaluate_284(&self, _ctx: &EvaluationContext) -> ConditionResult {
4683 ConditionResult::Unknown
4685 }
4686
4687 fn evaluate_285(&self, ctx: &EvaluationContext) -> ConditionResult {
4689 let pia_segs = ctx.find_segments("PIA");
4691 let found = pia_segs.iter().any(|s| {
4692 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| v.contains("1-08-3") && v.contains("AGS"))
4693 });
4694 ConditionResult::from(found)
4695 }
4696
4697 fn evaluate_286(&self, ctx: &EvaluationContext) -> ConditionResult {
4699 let pia_segs = ctx.find_segments("PIA");
4701 let found = pia_segs.iter().any(|s| {
4702 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4703 (v.starts_with("1-08-1") || v.starts_with("1-08-2")
4704 || v.starts_with("1-08-4") || v.starts_with("1-08-5"))
4705 && v.contains("AGS") && v.contains("KG")
4706 })
4707 });
4708 ConditionResult::from(found)
4709 }
4710
4711 fn evaluate_287(&self, _ctx: &EvaluationContext) -> ConditionResult {
4713 ConditionResult::Unknown
4715 }
4716
4717 fn evaluate_288(&self, ctx: &EvaluationContext) -> ConditionResult {
4719 let pia_segs = ctx.find_segments("PIA");
4721 let found = pia_segs.iter().any(|s| {
4722 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
4723 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
4724 v.contains(":2.9.") && v.starts_with("1-")
4725 })
4726 });
4727 ConditionResult::from(found)
4728 }
4729
4730 fn evaluate_291(&self, ctx: &EvaluationContext) -> ConditionResult {
4732 let rff_segs = ctx.find_segments("RFF");
4733 let found = rff_segs.iter().any(|s| {
4734 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z37")
4735 });
4736 ConditionResult::from(found)
4737 }
4738
4739 fn evaluate_292(&self, ctx: &EvaluationContext) -> ConditionResult {
4741 ctx.external.evaluate("code_list_membership_check")
4742 }
4743
4744 fn evaluate_293(&self, ctx: &EvaluationContext) -> ConditionResult {
4746 let loc_segs = ctx.find_segments("LOC");
4747 let found = loc_segs.iter().any(|s| {
4748 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z22")
4749 });
4750 ConditionResult::from(found)
4751 }
4752
4753 fn evaluate_294(&self, ctx: &EvaluationContext) -> ConditionResult {
4755 let loc_segs = ctx.find_segments("LOC");
4756 let found = loc_segs.iter().any(|s| {
4757 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z18")
4758 });
4759 ConditionResult::from(found)
4760 }
4761
4762 fn evaluate_295(&self, ctx: &EvaluationContext) -> ConditionResult {
4764 let loc_segs = ctx.find_segments("LOC");
4765 let found = loc_segs.iter().any(|s| {
4766 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z15")
4767 });
4768 ConditionResult::from(!found)
4769 }
4770
4771 fn evaluate_296(&self, ctx: &EvaluationContext) -> ConditionResult {
4773 let loc_segs = ctx.find_segments("LOC");
4774 let found = loc_segs.iter().any(|s| {
4775 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z20")
4776 });
4777 ConditionResult::from(found)
4778 }
4779
4780 fn evaluate_297(&self, ctx: &EvaluationContext) -> ConditionResult {
4782 let loc_segs = ctx.find_segments("LOC");
4783 let found = loc_segs.iter().any(|s| {
4784 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z18")
4785 });
4786 ConditionResult::from(!found)
4787 }
4788
4789 fn evaluate_298(&self, ctx: &EvaluationContext) -> ConditionResult {
4791 let loc_segs = ctx.find_segments("LOC");
4792 let found = loc_segs.iter().any(|s| {
4793 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z20")
4794 });
4795 ConditionResult::from(!found)
4796 }
4797
4798 fn evaluate_299(&self, ctx: &EvaluationContext) -> ConditionResult {
4800 let loc_segs = ctx.find_segments("LOC");
4801 let found = loc_segs.iter().any(|s| {
4802 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z19")
4803 });
4804 ConditionResult::from(!found)
4805 }
4806
4807 fn evaluate_300(&self, ctx: &EvaluationContext) -> ConditionResult {
4809 let seq_segs = ctx.find_segments("SEQ");
4810 let found = seq_segs.iter().any(|s| {
4811 s.elements.first().and_then(|e| e.first())
4812 .is_some_and(|v| ["Z15", "ZE7"].contains(&v.as_str()))
4813 });
4814 ConditionResult::from(!found)
4815 }
4816
4817 fn evaluate_301(&self, ctx: &EvaluationContext) -> ConditionResult {
4819 let bgm_segs = ctx.find_segments("BGM");
4820 let found = bgm_segs.iter().any(|s| {
4821 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E03")
4822 });
4823 ConditionResult::from(found)
4824 }
4825
4826 fn evaluate_302(&self, ctx: &EvaluationContext) -> ConditionResult {
4828 let seq_segs = ctx.find_segments("SEQ");
4829 let found = seq_segs.iter().any(|s| {
4830 s.elements.first().and_then(|e| e.first())
4831 .is_some_and(|v| ["Z08"].contains(&v.as_str()))
4832 });
4833 ConditionResult::from(!found)
4834 }
4835
4836 fn evaluate_303(&self, ctx: &EvaluationContext) -> ConditionResult {
4838 let seq_segs = ctx.find_segments("SEQ");
4839 let found = seq_segs.iter().any(|s| {
4840 s.elements.first().and_then(|e| e.first())
4841 .is_some_and(|v| ["Z21"].contains(&v.as_str()))
4842 });
4843 ConditionResult::from(!found)
4844 }
4845
4846 fn evaluate_304(&self, ctx: &EvaluationContext) -> ConditionResult {
4848 let seq_segs = ctx.find_segments("SEQ");
4849 let found = seq_segs.iter().any(|s| {
4850 s.elements.first().and_then(|e| e.first())
4851 .is_some_and(|v| ["Z22"].contains(&v.as_str()))
4852 });
4853 ConditionResult::from(found)
4854 }
4855
4856 fn evaluate_305(&self, ctx: &EvaluationContext) -> ConditionResult {
4858 let seq_segs = ctx.find_segments("SEQ");
4859 let found = seq_segs.iter().any(|s| {
4860 s.elements.first().and_then(|e| e.first())
4861 .is_some_and(|v| ["Z24"].contains(&v.as_str()))
4862 });
4863 ConditionResult::from(found)
4864 }
4865
4866 fn evaluate_306(&self, ctx: &EvaluationContext) -> ConditionResult {
4868 use std::collections::HashSet;
4869 let loc_z22_ids: HashSet<String> = ctx
4871 .find_segments_with_qualifier("LOC", 0, "Z22")
4872 .into_iter()
4873 .filter_map(|s| s.elements.get(1)?.get(3).cloned())
4874 .filter(|v| !v.is_empty())
4875 .collect();
4876 if loc_z22_ids.is_empty() {
4877 return ConditionResult::False;
4878 }
4879 let has_match = ctx
4881 .find_segments_with_qualifier("SEQ", 0, "Z58")
4882 .iter()
4883 .any(|s| {
4884 s.elements
4885 .get(1)
4886 .and_then(|e: &Vec<String>| e.first())
4887 .is_some_and(|v: &String| !v.is_empty() && loc_z22_ids.contains(v.as_str()))
4888 });
4889 ConditionResult::from(has_match)
4890 }
4891
4892 fn evaluate_307(&self, ctx: &EvaluationContext) -> ConditionResult {
4895 let seq_segs = ctx.find_segments_with_qualifier("SEQ", 0, "Z58");
4896 if seq_segs.is_empty() {
4897 return ConditionResult::Unknown;
4898 }
4899 let loc_segs = ctx.find_segments_with_qualifier("LOC", 0, "Z22");
4900 let loc_z22_zeitraum_ids: Vec<&str> = loc_segs
4901 .iter()
4902 .filter_map(|s| s.elements.get(1).and_then(|e| e.get(3)).map(|v| v.as_str()))
4903 .filter(|v| !v.is_empty())
4904 .collect();
4905 ConditionResult::from(seq_segs.iter().any(|seq| {
4906 let zid = seq
4907 .elements
4908 .get(1)
4909 .and_then(|e: &Vec<String>| e.first())
4910 .map(|v| v.as_str())
4911 .unwrap_or("");
4912 !zid.is_empty() && !loc_z22_zeitraum_ids.contains(&zid)
4913 }))
4914 }
4915
4916 fn evaluate_309(&self, ctx: &EvaluationContext) -> ConditionResult {
4918 let loc_segs = ctx.find_segments("LOC");
4919 let found = loc_segs.iter().any(|s| {
4920 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z22")
4921 });
4922 ConditionResult::from(!found)
4923 }
4924
4925 fn evaluate_314(&self, ctx: &EvaluationContext) -> ConditionResult {
4927 ctx.external.evaluate("code_list_membership_check")
4928 }
4929
4930 fn evaluate_315(&self, ctx: &EvaluationContext) -> ConditionResult {
4932 ctx.external.evaluate("data_clearing_required")
4933 }
4934
4935 fn evaluate_316(&self, ctx: &EvaluationContext) -> ConditionResult {
4937 ctx.any_group_has_qualifier_without("SEQ", 0, "Z03", "RFF", 0, "Z14", &["SG4", "SG8"])
4938 }
4939
4940 fn evaluate_317(&self, ctx: &EvaluationContext) -> ConditionResult {
4942 let found = !ctx.find_segments_with_qualifier("DTM", 0, "92").is_empty();
4944 if found { ConditionResult::True } else { ConditionResult::Unknown }
4945 }
4946
4947 fn evaluate_318(&self, ctx: &EvaluationContext) -> ConditionResult {
4949 let found = !ctx.find_segments_with_qualifier("DTM", 0, "93").is_empty();
4951 if found { ConditionResult::True } else { ConditionResult::Unknown }
4952 }
4953
4954 fn evaluate_321(&self, ctx: &EvaluationContext) -> ConditionResult {
4956 let com_segs = ctx.find_segments("COM");
4957 let has_em = com_segs.iter().any(|s| {
4958 s.elements.first()
4959 .and_then(|e| e.get(1))
4960 .is_some_and(|v| v == "EM")
4961 });
4962 ConditionResult::from(has_em)
4963 }
4964
4965 fn evaluate_322(&self, ctx: &EvaluationContext) -> ConditionResult {
4967 let com_segs = ctx.find_segments("COM");
4968 let has_phone = com_segs.iter().any(|s| {
4969 s.elements.first()
4970 .and_then(|e| e.get(1))
4971 .is_some_and(|v| matches!(v.as_str(), "TE" | "FX" | "AJ" | "AL"))
4972 });
4973 ConditionResult::from(has_phone)
4974 }
4975
4976 fn evaluate_323(&self, ctx: &EvaluationContext) -> ConditionResult {
4978 ctx.external.evaluate("code_list_membership_check")
4979 }
4980
4981 fn evaluate_327(&self, ctx: &EvaluationContext) -> ConditionResult {
4984 const THRESHOLD: &str = "202212312300+00";
4985 let seq_zeitraum_ids: Vec<String> = ctx
4986 .find_segments("SEQ")
4987 .iter()
4988 .filter_map(|s| {
4989 s.elements
4990 .get(1)
4991 .and_then(|e: &Vec<String>| e.first())
4992 .cloned()
4993 })
4994 .filter(|v| !v.is_empty())
4995 .collect();
4996 if seq_zeitraum_ids.is_empty() {
4997 return ConditionResult::Unknown;
4998 }
4999 let rff_segs = ctx.find_segments("RFF");
5000 let matching_rff = rff_segs.iter().any(|rff| {
5001 let qual = rff
5002 .elements
5003 .first()
5004 .and_then(|e: &Vec<String>| e.first())
5005 .map(|v| v.as_str())
5006 .unwrap_or("");
5007 if !["Z47", "Z48", "Z49"].contains(&qual) {
5008 return false;
5009 }
5010 let zid = rff
5011 .elements
5012 .first()
5013 .and_then(|e| e.get(2))
5014 .map(|v| v.as_str())
5015 .unwrap_or("");
5016 !zid.is_empty() && seq_zeitraum_ids.iter().any(|id| id.as_str() == zid)
5017 });
5018 if !matching_rff {
5019 return ConditionResult::False;
5020 }
5021 for dtm in ctx.find_segments_with_qualifier("DTM", 0, "Z25") {
5022 let val = dtm
5023 .elements
5024 .first()
5025 .and_then(|e| e.get(1))
5026 .map(|v| v.replace("?+", "+"))
5027 .unwrap_or_default();
5028 if !val.is_empty() && val.as_str() >= THRESHOLD {
5029 return ConditionResult::True;
5030 }
5031 }
5032 ConditionResult::False
5033 }
5034
5035 fn evaluate_329(&self, ctx: &EvaluationContext) -> ConditionResult {
5037 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
5039 let has_a03_e0096 = sts_segs.iter().any(|s| {
5040 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "A03")
5041 && s.elements.get(2).and_then(|e| e.get(1)).is_some_and(|v| v == "E_0096")
5042 });
5043 let has_a04_e0097 = sts_segs.iter().any(|s| {
5044 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "A04")
5045 && s.elements.get(2).and_then(|e| e.get(1)).is_some_and(|v| v == "E_0097")
5046 });
5047 ConditionResult::from(!has_a03_e0096 && !has_a04_e0097)
5048 }
5049
5050 fn evaluate_331(&self, ctx: &EvaluationContext) -> ConditionResult {
5052 let seq_segs = ctx.find_segments("SEQ");
5053 let has_seq = seq_segs.iter().any(|s| {
5054 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z98")
5055 });
5056 let cci_segs = ctx.find_segments("CCI");
5057 let has_cci = cci_segs.iter().any(|s| {
5058 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "6")
5059 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA9")
5060 });
5061 ConditionResult::from(!(has_seq && has_cci))
5062 }
5063
5064 fn evaluate_332(&self, ctx: &EvaluationContext) -> ConditionResult {
5067 let nav = match ctx.navigator {
5068 Some(n) => n,
5069 None => {
5070 if ctx.find_segments_with_qualifier("SEQ", 0, "Z01").is_empty() {
5071 return ConditionResult::Unknown;
5072 }
5073 let has_cci_za9 = ctx
5074 .find_segments_with_qualifier("CCI", 0, "6")
5075 .iter()
5076 .any(|s| {
5077 s.elements
5078 .get(2)
5079 .and_then(|e: &Vec<String>| e.first())
5080 .map(|v| v.as_str())
5081 == Some("ZA9")
5082 });
5083 return ConditionResult::from(!has_cci_za9);
5084 }
5085 };
5086 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
5087 if sg8_count == 0 {
5088 return ConditionResult::Unknown;
5089 }
5090 for sg8_idx in 0..sg8_count {
5091 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], sg8_idx, "SG10");
5092 let mut has_cci_za9 = false;
5093 for sg10_idx in 0..sg10_count {
5094 let ccis = nav.find_segments_in_child_group(
5095 "CCI",
5096 &["SG4", "SG8"],
5097 sg8_idx,
5098 "SG10",
5099 sg10_idx,
5100 );
5101 if ccis.iter().any(|s| {
5102 s.elements
5103 .first()
5104 .and_then(|e: &Vec<String>| e.first())
5105 .map(|v| v.as_str())
5106 == Some("6")
5107 && s.elements
5108 .get(2)
5109 .and_then(|e: &Vec<String>| e.first())
5110 .map(|v| v.as_str())
5111 == Some("ZA9")
5112 }) {
5113 has_cci_za9 = true;
5114 break;
5115 }
5116 }
5117 if !has_cci_za9 {
5118 return ConditionResult::True;
5119 }
5120 }
5121 ConditionResult::False
5122 }
5123
5124 fn evaluate_333(&self, ctx: &EvaluationContext) -> ConditionResult {
5126 let rff_segs = ctx.find_segments("RFF");
5127 let found = rff_segs.iter().any(|s| {
5128 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z31")
5129 });
5130 ConditionResult::from(found)
5131 }
5132
5133 fn evaluate_334(&self, ctx: &EvaluationContext) -> ConditionResult {
5135 ctx.external.evaluate("sector_check")
5137 }
5138
5139 fn evaluate_335(&self, ctx: &EvaluationContext) -> ConditionResult {
5142 let z58_ids: Vec<String> = ctx
5143 .find_segments_with_qualifier("SEQ", 0, "Z58")
5144 .iter()
5145 .filter_map(|s| {
5146 s.elements
5147 .get(1)
5148 .and_then(|e: &Vec<String>| e.first())
5149 .cloned()
5150 })
5151 .filter(|v| !v.is_empty())
5152 .collect();
5153 if z58_ids.is_empty() {
5154 return ConditionResult::Unknown;
5155 }
5156 if ctx.find_segments_with_qualifier("SEQ", 0, "Z78").is_empty() {
5157 return ConditionResult::False;
5158 }
5159 let rff_z31_ids: Vec<String> = ctx
5160 .find_segments("RFF")
5161 .iter()
5162 .filter(|rff| {
5163 rff.elements
5164 .first()
5165 .and_then(|e: &Vec<String>| e.first())
5166 .map(|v| v.as_str())
5167 == Some("Z31")
5168 })
5169 .filter_map(|rff| rff.elements.first().and_then(|e| e.get(1)).cloned())
5170 .filter(|v| !v.is_empty())
5171 .collect();
5172 ConditionResult::from(z58_ids.iter().any(|id| rff_z31_ids.contains(id)))
5173 }
5174
5175 fn evaluate_336(&self, _ctx: &EvaluationContext) -> ConditionResult {
5177 ConditionResult::Unknown
5179 }
5180
5181 fn evaluate_337(&self, ctx: &EvaluationContext) -> ConditionResult {
5183 let cci_segs = ctx.find_segments("CCI");
5184 let has_cci = cci_segs.iter().any(|s| {
5185 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZB4")
5186 });
5187 let cav_segs = ctx.find_segments("CAV");
5188 let has_cav = cav_segs.iter().any(|s| {
5189 s.elements.first().and_then(|e| e.first())
5190 .is_some_and(|v| ["Z95", "Z96"].contains(&v.as_str()))
5191 });
5192 ConditionResult::from(has_cci && has_cav)
5193 }
5194
5195 fn evaluate_338(&self, ctx: &EvaluationContext) -> ConditionResult {
5197 let cci_segs = ctx.find_segments("CCI");
5198 let has_cci = cci_segs.iter().any(|s| {
5199 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZB4")
5200 });
5201 let cav_segs = ctx.find_segments("CAV");
5202 let has_cav = cav_segs.iter().any(|s| {
5203 s.elements.first().and_then(|e| e.first())
5204 .is_some_and(|v| ["Z95", "Z96", "Z97", "Z99", "ZA1", "ZA3", "ZA4", "ZG7"].contains(&v.as_str()))
5205 });
5206 ConditionResult::from(has_cci && has_cav)
5207 }
5208
5209 fn evaluate_339(&self, ctx: &EvaluationContext) -> ConditionResult {
5211 let cci_segs = ctx.find_segments("CCI");
5212 let has_cci = cci_segs.iter().any(|s| {
5213 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZB4")
5214 });
5215 let cav_segs = ctx.find_segments("CAV");
5216 let has_cav = cav_segs.iter().any(|s| {
5217 s.elements.first().and_then(|e| e.first())
5218 .is_some_and(|v| ["Z97", "Z98", "Z99", "ZA0", "ZA1", "ZA2", "ZA3", "ZA6", "ZG7"].contains(&v.as_str()))
5219 });
5220 ConditionResult::from(has_cci && has_cav)
5221 }
5222
5223 fn evaluate_340(&self, ctx: &EvaluationContext) -> ConditionResult {
5225 let cci_segs = ctx.find_segments("CCI");
5226 let has_cci = cci_segs.iter().any(|s| {
5227 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZB4")
5228 });
5229 let cav_segs = ctx.find_segments("CAV");
5230 let has_cav = cav_segs.iter().any(|s| {
5231 s.elements.first().and_then(|e| e.first())
5232 .is_some_and(|v| ["Z95", "Z97", "Z98", "Z99", "ZA1", "ZA2", "ZA3", "ZA4", "ZA5", "ZA6"].contains(&v.as_str()))
5233 });
5234 ConditionResult::from(has_cci && has_cav)
5235 }
5236
5237 fn evaluate_341(&self, ctx: &EvaluationContext) -> ConditionResult {
5239 let cci_segs = ctx.find_segments("CCI");
5240 let has_cci = cci_segs.iter().any(|s| {
5241 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZB4")
5242 });
5243 let cav_segs = ctx.find_segments("CAV");
5244 let has_cav = cav_segs.iter().any(|s| {
5245 s.elements.first().and_then(|e| e.first())
5246 .is_some_and(|v| ["Z96", "ZA0", "ZG7"].contains(&v.as_str()))
5247 });
5248 ConditionResult::from(has_cci && has_cav)
5249 }
5250
5251 fn evaluate_342(&self, _ctx: &EvaluationContext) -> ConditionResult {
5253 ConditionResult::Unknown
5255 }
5256
5257 fn evaluate_344(&self, ctx: &EvaluationContext) -> ConditionResult {
5259 let cci_segs = ctx.find_segments("CCI");
5260 let has_cci = cci_segs.iter().any(|s| {
5261 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZB4")
5262 });
5263 let cav_segs = ctx.find_segments("CAV");
5264 let has_cav = cav_segs.iter().any(|s| {
5265 s.elements.first().and_then(|e| e.first())
5266 .is_some_and(|v| ["ZF1"].contains(&v.as_str()))
5267 });
5268 ConditionResult::from(has_cci && has_cav)
5269 }
5270
5271 fn evaluate_345(&self, ctx: &EvaluationContext) -> ConditionResult {
5273 let loc_segs = ctx.find_segments("LOC");
5274 let found = loc_segs.iter().any(|s| {
5275 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z17")
5276 });
5277 ConditionResult::from(found)
5278 }
5279
5280 fn evaluate_346(&self, ctx: &EvaluationContext) -> ConditionResult {
5282 let cci_segs = ctx.find_segments("CCI");
5283 let found = cci_segs.iter().any(|s| {
5284 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "E13")
5285 });
5286 ConditionResult::from(found)
5287 }
5288
5289 fn evaluate_347(&self, ctx: &EvaluationContext) -> ConditionResult {
5291 let loc_segs = ctx.find_segments("LOC");
5292 let found = loc_segs.iter().any(|s| {
5293 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z16")
5294 });
5295 ConditionResult::from(!found)
5296 }
5297
5298 fn evaluate_348(&self, ctx: &EvaluationContext) -> ConditionResult {
5300 let loc_segs = ctx.find_segments("LOC");
5301 let found = loc_segs.iter().any(|s| {
5302 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z21")
5303 });
5304 ConditionResult::from(!found)
5305 }
5306
5307 fn evaluate_349(&self, ctx: &EvaluationContext) -> ConditionResult {
5309 let loc_segs = ctx.find_segments("LOC");
5310 let found = loc_segs.iter().any(|s| {
5311 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z17")
5312 });
5313 ConditionResult::from(!found)
5314 }
5315
5316 fn evaluate_350(&self, ctx: &EvaluationContext) -> ConditionResult {
5318 let seq_segs = ctx.find_segments("SEQ");
5319 let has_seq = seq_segs.iter().any(|s| {
5320 s.elements.first().and_then(|e| e.first())
5321 .is_some_and(|v| ["Z78", "ZD5"].contains(&v.as_str()))
5322 });
5323 let rff_segs = ctx.find_segments("RFF");
5324 let has_rff = rff_segs.iter().any(|s| {
5325 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z31")
5326 });
5327 ConditionResult::from(has_seq && has_rff)
5328 }
5329
5330 fn evaluate_351(&self, ctx: &EvaluationContext) -> ConditionResult {
5332 let sts_segs = ctx.find_segments("STS");
5333 let found = sts_segs.iter().any(|s| {
5334 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
5335 && s.elements.get(2).and_then(|e| e.first())
5336 .is_some_and(|v| ["A04", "A05", "A13", "A14"].contains(&v.as_str()))
5337 });
5338 ConditionResult::from(found)
5339 }
5340
5341 fn evaluate_352(&self, ctx: &EvaluationContext) -> ConditionResult {
5343 let sts_segs = ctx.find_segments("STS");
5344 let found = sts_segs.iter().any(|s| {
5345 s.elements.get(1).and_then(|e| e.first())
5346 .is_some_and(|v| ["A05", "A06", "A14", "A15"].contains(&v.as_str()))
5347 });
5348 ConditionResult::from(found)
5349 }
5350
5351 fn evaluate_355(&self, ctx: &EvaluationContext) -> ConditionResult {
5353 let sts_segs = ctx.find_segments("STS");
5354 let found = sts_segs.iter().any(|s| {
5355 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
5356 && s.elements.get(2).and_then(|e| e.first())
5357 .is_some_and(|v| ["A45"].contains(&v.as_str()))
5358 });
5359 ConditionResult::from(found)
5360 }
5361
5362 fn evaluate_356(&self, ctx: &EvaluationContext) -> ConditionResult {
5364 let sts_segs = ctx.find_segments("STS");
5365 let found = sts_segs.iter().any(|s| {
5366 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
5367 && s.elements.get(2).and_then(|e| e.first())
5368 .is_some_and(|v| ["A50"].contains(&v.as_str()))
5369 });
5370 ConditionResult::from(found)
5371 }
5372
5373 fn evaluate_357(&self, ctx: &EvaluationContext) -> ConditionResult {
5375 let sts_segs = ctx.find_segments("STS");
5376 let found = sts_segs.iter().any(|s| {
5377 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
5378 && s.elements.get(2).and_then(|e| e.first())
5379 .is_some_and(|v| ["A03", "A09", "A12", "A17"].contains(&v.as_str()))
5380 });
5381 ConditionResult::from(found)
5382 }
5383
5384 fn evaluate_358(&self, ctx: &EvaluationContext) -> ConditionResult {
5386 let sts_segs = ctx.find_segments("STS");
5387 let found = sts_segs.iter().any(|s| {
5388 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
5389 && s.elements.get(2).and_then(|e| e.first())
5390 .is_some_and(|v| ["A06"].contains(&v.as_str()))
5391 });
5392 ConditionResult::from(found)
5393 }
5394
5395 fn evaluate_359(&self, ctx: &EvaluationContext) -> ConditionResult {
5397 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
5399 if sts_segs.is_empty() {
5400 return ConditionResult::Unknown;
5401 }
5402 let all_rejection = sts_segs.iter().all(|s| {
5403 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| {
5404 v.starts_with("A") && v.len() == 3
5406 && v.as_bytes().get(1).is_some_and(|&b| b >= b'2')
5407 })
5408 });
5409 ConditionResult::from(all_rejection)
5410 }
5411
5412 fn evaluate_360(&self, ctx: &EvaluationContext) -> ConditionResult {
5414 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
5416 if sts_segs.is_empty() {
5417 return ConditionResult::Unknown;
5418 }
5419 let all_approval = sts_segs.iter().all(|s| {
5420 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| {
5421 ["A01", "A02", "A03", "A04", "A05", "A06", "A07", "A08", "A09", "A10",
5423 "A11", "A12", "A13", "A14", "A15", "A16", "A17", "A25"].contains(&v.as_str())
5424 })
5425 });
5426 ConditionResult::from(all_approval)
5427 }
5428
5429 fn evaluate_363(&self, ctx: &EvaluationContext) -> ConditionResult {
5431 let sts_segs = ctx.find_segments("STS");
5432 let found = sts_segs.iter().any(|s| {
5433 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
5434 && s.elements.get(2).and_then(|e| e.first())
5435 .is_some_and(|v| ["A50"].contains(&v.as_str()))
5436 });
5437 ConditionResult::from(found)
5438 }
5439
5440 fn evaluate_365(&self, ctx: &EvaluationContext) -> ConditionResult {
5442 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
5444 let has_excluded = sts_segs.iter().any(|s| {
5445 let code = s.elements.get(2).and_then(|e| e.first()).map(|v| v.as_str());
5446 let ebd = s.elements.get(2).and_then(|e| e.get(1)).map(|v| v.as_str());
5447 matches!((code, ebd),
5448 (Some("A04"), Some("E_0047")) | (Some("A04"), Some("E_0014"))
5449 | (Some("A03"), Some("E_0049")) | (Some("A03"), Some("E_0004"))
5450 )
5451 });
5452 ConditionResult::from(!has_excluded)
5453 }
5454
5455 fn evaluate_366(&self, ctx: &EvaluationContext) -> ConditionResult {
5457 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
5459 if sts_segs.is_empty() {
5460 return ConditionResult::Unknown;
5461 }
5462 let all_valid = sts_segs.iter().all(|s| {
5463 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v != "A30")
5464 });
5465 ConditionResult::from(all_valid)
5466 }
5467
5468 fn evaluate_367(&self, ctx: &EvaluationContext) -> ConditionResult {
5470 let sts_segs = ctx.find_segments("STS");
5471 let found = sts_segs.iter().any(|s| {
5472 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
5473 && s.elements.get(2).and_then(|e| e.first())
5474 .is_some_and(|v| ["A05", "A14"].contains(&v.as_str()))
5475 });
5476 ConditionResult::from(found)
5477 }
5478
5479 fn evaluate_368(&self, ctx: &EvaluationContext) -> ConditionResult {
5481 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
5483 if sts_segs.is_empty() {
5484 return ConditionResult::Unknown;
5485 }
5486 let all_valid = sts_segs.iter().all(|s| {
5487 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v != "A41")
5488 });
5489 ConditionResult::from(all_valid)
5490 }
5491
5492 fn evaluate_370(&self, ctx: &EvaluationContext) -> ConditionResult {
5494 let cav_segs = ctx.find_segments("CAV");
5495 let found = cav_segs.iter().any(|s| {
5496 s.elements.first().and_then(|e| e.first())
5497 .is_some_and(|v| ["TLS", "TES", "BIT", "GET", "GAT", "SOT", "WNT", "WFT", "WAT"].contains(&v.as_str()))
5498 });
5499 ConditionResult::from(found)
5500 }
5501
5502 fn evaluate_371(&self, ctx: &EvaluationContext) -> ConditionResult {
5504 let seq_segs = ctx.find_segments("SEQ");
5505 let found = seq_segs.iter().any(|s| {
5506 s.elements.first().and_then(|e| e.first())
5507 .is_some_and(|v| ["Z38"].contains(&v.as_str()))
5508 });
5509 ConditionResult::from(!found)
5510 }
5511
5512 fn evaluate_372(&self, ctx: &EvaluationContext) -> ConditionResult {
5514 let cav_segs = ctx.find_segments("CAV");
5515 let found = cav_segs.iter().any(|s| {
5516 s.elements.first().and_then(|e| e.first())
5517 .is_some_and(|v| ["TES", "BIT", "GET", "GAT", "SOT", "WNT", "WFT", "WAT"].contains(&v.as_str()))
5518 });
5519 ConditionResult::from(found)
5520 }
5521
5522 fn evaluate_373(&self, _ctx: &EvaluationContext) -> ConditionResult {
5524 ConditionResult::Unknown
5526 }
5527
5528 fn evaluate_375(&self, ctx: &EvaluationContext) -> ConditionResult {
5530 ctx.lacks_qualifier("SEQ", 0, "Z24")
5532 }
5533
5534 fn evaluate_376(&self, ctx: &EvaluationContext) -> ConditionResult {
5536 ctx.lacks_qualifier("SEQ", 0, "Z22")
5538 }
5539
5540 fn evaluate_377(&self, ctx: &EvaluationContext) -> ConditionResult {
5543 let nav = match ctx.navigator {
5544 Some(n) => n,
5545 None => return ctx.has_qualified_value("CAV", 0, "AUS", 0, 0, &["AUS"]),
5546 };
5547 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
5548 for i in 0..sg8_count {
5549 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
5550 for j in 0..sg10_count {
5551 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
5552 let has_cci = ccis.iter().any(|s| {
5553 s.elements
5554 .first()
5555 .and_then(|e: &Vec<String>| e.first())
5556 .is_some_and(|v: &String| v == "15")
5557 && s.elements
5558 .get(2)
5559 .and_then(|e: &Vec<String>| e.first())
5560 .is_some_and(|v: &String| v == "Z21")
5561 });
5562 if has_cci {
5563 let cavs =
5564 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
5565 if cavs.iter().any(|s| {
5566 s.elements
5567 .first()
5568 .and_then(|e: &Vec<String>| e.first())
5569 .is_some_and(|v: &String| v == "AUS")
5570 }) {
5571 return ConditionResult::True;
5572 }
5573 }
5574 }
5575 }
5576 ConditionResult::False
5577 }
5578
5579 fn evaluate_378(&self, ctx: &EvaluationContext) -> ConditionResult {
5582 let nav = match ctx.navigator {
5583 Some(n) => n,
5584 None => {
5585 let r = ctx.has_qualified_value("CAV", 0, "AUS", 0, 0, &["AUS"]);
5586 return match r {
5587 ConditionResult::True => ConditionResult::False,
5588 ConditionResult::False => ConditionResult::True,
5589 ConditionResult::Unknown => ConditionResult::Unknown,
5590 };
5591 }
5592 };
5593 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
5594 for i in 0..sg8_count {
5595 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
5596 for j in 0..sg10_count {
5597 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
5598 let has_cci = ccis.iter().any(|s| {
5599 s.elements
5600 .first()
5601 .and_then(|e: &Vec<String>| e.first())
5602 .is_some_and(|v: &String| v == "15")
5603 && s.elements
5604 .get(2)
5605 .and_then(|e: &Vec<String>| e.first())
5606 .is_some_and(|v: &String| v == "Z21")
5607 });
5608 if has_cci {
5609 let cavs =
5610 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
5611 if cavs.iter().any(|s| {
5612 s.elements
5613 .first()
5614 .and_then(|e: &Vec<String>| e.first())
5615 .is_some_and(|v: &String| v == "AUS")
5616 }) {
5617 return ConditionResult::False;
5618 }
5619 }
5620 }
5621 }
5622 ConditionResult::True
5623 }
5624
5625 fn evaluate_379(&self, ctx: &EvaluationContext) -> ConditionResult {
5627 let cci_segs = ctx.find_segments("CCI");
5628 let found = cci_segs.iter().any(|s| {
5629 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "15")
5630 && s.elements.get(2).and_then(|e| e.first())
5631 .is_some_and(|v| ["Z21"].contains(&v.as_str()))
5632 });
5633 ConditionResult::from(found)
5634 }
5635
5636 fn evaluate_380(&self, ctx: &EvaluationContext) -> ConditionResult {
5639 let nav = match ctx.navigator {
5640 Some(n) => n,
5641 None => {
5642 return ctx.any_group_has_any_qualifier("CAV", 0, &["AUS", "AU1"], &["SG4", "SG8"])
5643 }
5644 };
5645 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
5646 for i in 0..sg8_count {
5647 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
5648 for j in 0..sg10_count {
5649 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
5650 let has_cci = ccis.iter().any(|s| {
5651 s.elements
5652 .first()
5653 .and_then(|e: &Vec<String>| e.first())
5654 .is_some_and(|v: &String| v == "15")
5655 && s.elements
5656 .get(2)
5657 .and_then(|e: &Vec<String>| e.first())
5658 .is_some_and(|v: &String| v == "Z21")
5659 });
5660 if has_cci {
5661 let cavs =
5662 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
5663 if cavs.iter().any(|s| {
5664 s.elements
5665 .first()
5666 .and_then(|e: &Vec<String>| e.first())
5667 .is_some_and(|v: &String| v == "AUS" || v == "AU1")
5668 }) {
5669 return ConditionResult::True;
5670 }
5671 }
5672 }
5673 }
5674 ConditionResult::False
5675 }
5676
5677 fn evaluate_384(&self, ctx: &EvaluationContext) -> ConditionResult {
5679 let cci_segs = ctx.find_segments("CCI");
5680 let found = cci_segs.iter().any(|s| {
5681 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z37")
5682 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZD1")
5683 });
5684 ConditionResult::from(found)
5685 }
5686
5687 fn evaluate_386(&self, ctx: &EvaluationContext) -> ConditionResult {
5689 let seq_count = ctx.find_segments("SEQ").iter().filter(|s| {
5691 s.elements.first().and_then(|e| e.first())
5692 .is_some_and(|v| v == "Z02" || v == "ZE3")
5693 }).count();
5694 ConditionResult::from(seq_count > 1)
5695 }
5696
5697 fn evaluate_387(&self, ctx: &EvaluationContext) -> ConditionResult {
5699 let pia_segs = ctx.find_segments("PIA");
5701 let found = pia_segs.iter().any(|s| {
5702 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
5703 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5704 v.starts_with("1-") && (v.contains(":1.8.") || v.contains(":2.8.")
5705 || v.contains(":1.9.") || v.contains(":2.9."))
5706 })
5707 });
5708 ConditionResult::from(found)
5709 }
5710
5711 fn evaluate_388(&self, ctx: &EvaluationContext) -> ConditionResult {
5713 let found = !ctx.find_segments_with_qualifier("RFF", 0, "Z49").is_empty();
5715 ConditionResult::from(found)
5716 }
5717
5718 fn evaluate_391(&self, ctx: &EvaluationContext) -> ConditionResult {
5720 let pia_segs = ctx.find_segments("PIA");
5722 let found = pia_segs.iter().any(|s| {
5723 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
5724 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5725 v.starts_with("1-") && (v.contains(":1.8.") || v.contains(":2.8."))
5726 })
5727 });
5728 ConditionResult::from(found)
5729 }
5730
5731 fn evaluate_392(&self, ctx: &EvaluationContext) -> ConditionResult {
5733 let pia_segs = ctx.find_segments("PIA");
5735 let found = pia_segs.iter().any(|s| {
5736 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5737 let parts: Vec<&str> = v.split('-').collect();
5738 parts.len() == 3
5739 && parts[0].len() == 1 && parts[0].chars().all(|c| c.is_ascii_digit())
5740 && parts[1].len() == 2 && parts[1].chars().all(|c| c.is_ascii_digit())
5741 && parts[2].len() == 1 && parts[2].chars().all(|c| c.is_ascii_digit())
5742 })
5743 });
5744 ConditionResult::from(found)
5745 }
5746
5747 fn evaluate_393(&self, ctx: &EvaluationContext) -> ConditionResult {
5749 let pia_segs = ctx.find_segments("PIA");
5751 let found = pia_segs.iter().any(|s| {
5752 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5753 let parts: Vec<&str> = v.split('-').collect();
5754 parts.len() == 4
5755 && parts[0].len() == 1 && parts[0].chars().all(|c| c.is_ascii_digit())
5756 && parts[1].len() == 2 && parts[1].chars().all(|c| c.is_ascii_digit())
5757 && parts[2].len() == 1 && parts[2].chars().all(|c| c.is_ascii_digit())
5758 && parts[3].len() == 3 && parts[3].chars().all(|c| c.is_ascii_digit())
5759 })
5760 });
5761 ConditionResult::from(found)
5762 }
5763
5764 fn evaluate_394(&self, ctx: &EvaluationContext) -> ConditionResult {
5766 let pia_segs = ctx.find_segments("PIA");
5768 let found = pia_segs.iter().any(|s| {
5769 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5770 let parts: Vec<&str> = v.split('-').collect();
5771 parts.len() == 5
5772 && parts[0].len() == 1 && parts[0].chars().all(|c| c.is_ascii_digit())
5773 && parts[1].len() == 2 && parts[1].chars().all(|c| c.is_ascii_digit())
5774 && parts[2].len() == 1 && parts[2].chars().all(|c| c.is_ascii_digit())
5775 && parts[3].len() == 8 && parts[3].chars().all(|c| c.is_ascii_digit())
5776 && parts[4].len() == 2 && parts[4].chars().all(|c| c.is_ascii_digit())
5777 })
5778 });
5779 ConditionResult::from(found)
5780 }
5781
5782 fn evaluate_395(&self, ctx: &EvaluationContext) -> ConditionResult {
5784 let pia_segs = ctx.find_segments("PIA");
5786 let found = pia_segs.iter().any(|s| {
5787 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5788 let parts: Vec<&str> = v.split('-').collect();
5789 parts.len() == 4
5790 && parts[0].len() == 1 && parts[0].chars().all(|c| c.is_ascii_digit())
5791 && parts[1].len() == 2 && parts[1].chars().all(|c| c.is_ascii_digit())
5792 && parts[2].len() == 1 && parts[2].chars().all(|c| c.is_ascii_digit())
5793 && parts[3].len() == 8 && parts[3].chars().all(|c| c.is_ascii_digit())
5794 })
5795 });
5796 ConditionResult::from(found)
5797 }
5798
5799 fn evaluate_396(&self, ctx: &EvaluationContext) -> ConditionResult {
5801 let pia_segs = ctx.find_segments("PIA");
5803 let found = pia_segs.iter().any(|s| {
5804 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
5805 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5806 v.starts_with("1-") && v.contains(":1.8.")
5807 })
5808 });
5809 ConditionResult::from(found)
5810 }
5811
5812 fn evaluate_397(&self, ctx: &EvaluationContext) -> ConditionResult {
5814 let pia_segs = ctx.find_segments("PIA");
5815 let found = pia_segs.iter().any(|s| {
5816 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5817 let prefixes = ["1-08-1", "1-08-4"];
5818 prefixes.iter().any(|p| v.starts_with(p))
5819 })
5820 });
5821 ConditionResult::from(found)
5822 }
5823
5824 fn evaluate_398(&self, ctx: &EvaluationContext) -> ConditionResult {
5826 let pia_segs = ctx.find_segments("PIA");
5827 let found = pia_segs.iter().any(|s| {
5828 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5829 let prefixes = ["1-08-2", "1-08-5"];
5830 prefixes.iter().any(|p| v.starts_with(p))
5831 })
5832 });
5833 ConditionResult::from(found)
5834 }
5835
5836 fn evaluate_399(&self, ctx: &EvaluationContext) -> ConditionResult {
5839 let nav = match ctx.navigator() {
5840 Some(n) => n,
5841 None => return ConditionResult::Unknown,
5842 };
5843 let sg5_count = nav.group_instance_count(&["SG4", "SG5"]);
5846 let mut loc_zeitraum_ids: Vec<String> = Vec::new();
5847 for i in 0..sg5_count {
5848 let locs = nav.find_segments_in_group("LOC", &["SG4", "SG5"], i);
5849 for loc in &locs {
5850 if let Some(zid) = loc.elements.get(1).and_then(|e| e.get(3)) {
5851 if !zid.is_empty() {
5852 loc_zeitraum_ids.push(zid.clone());
5853 }
5854 }
5855 }
5856 }
5857 if loc_zeitraum_ids.is_empty() {
5858 return ConditionResult::Unknown;
5859 }
5860 let pauschal_id = "9992000000018";
5861 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
5862 for i in 0..sg8_count {
5865 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
5866 for seq in &seqs {
5867 if !seq
5868 .elements
5869 .first()
5870 .and_then(|e| e.first())
5871 .is_some_and(|v| v == "Z78")
5872 {
5873 continue;
5874 }
5875 let zid = seq
5876 .elements
5877 .get(1)
5878 .and_then(|e| e.first())
5879 .map(|s| s.as_str())
5880 .unwrap_or("");
5881 if !loc_zeitraum_ids.iter().any(|z| z == zid) {
5882 continue;
5883 }
5884 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
5886 for rff in &rffs {
5887 let qual = rff
5888 .elements
5889 .first()
5890 .and_then(|e| e.first())
5891 .map(|v| v.as_str())
5892 .unwrap_or("");
5893 if qual == "Z31" {
5894 let id = rff
5895 .elements
5896 .first()
5897 .and_then(|e| e.get(1))
5898 .map(|v| v.as_str())
5899 .unwrap_or("");
5900 let normalized = id.replace(' ', "");
5901 if !normalized.is_empty() && normalized != pauschal_id {
5902 return ConditionResult::True;
5903 }
5904 }
5905 }
5906 }
5907 }
5908 ConditionResult::False
5909 }
5910
5911 fn evaluate_401(&self, ctx: &EvaluationContext) -> ConditionResult {
5913 let has_z49 = !ctx.find_segments_with_qualifier("RFF", 0, "Z49").is_empty();
5916 let has_z53 = !ctx.find_segments_with_qualifier("RFF", 0, "Z53").is_empty();
5917 ConditionResult::from(!has_z49 && !has_z53)
5918 }
5919
5920 fn evaluate_402(&self, ctx: &EvaluationContext) -> ConditionResult {
5922 let pia_segs = ctx.find_segments("PIA");
5924 let found = pia_segs.iter().any(|s| {
5925 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
5926 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5927 v.starts_with("1-") && (v.contains(":1.8.") || v.contains(":2.8."))
5928 })
5929 });
5930 ConditionResult::from(found)
5931 }
5932
5933 fn evaluate_403(&self, ctx: &EvaluationContext) -> ConditionResult {
5936 let sender_mp_id: String = match ctx.find_segments_with_qualifier("NAD", 0, "MS").first() {
5937 Some(nad) => match nad.elements.get(1).and_then(|e: &Vec<String>| e.first()) {
5938 Some(id) if !id.is_empty() => id.clone(),
5939 _ => return ConditionResult::Unknown,
5940 },
5941 None => return ConditionResult::Unknown,
5942 };
5943 let nav = match ctx.navigator {
5944 Some(n) => n,
5945 None => return ConditionResult::Unknown,
5946 };
5947 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
5948 for i in 0..sg8_count {
5949 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
5950 for j in 0..sg10_count {
5951 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
5952 let has_cci_zb3 = ccis.iter().any(|s| {
5953 s.elements
5954 .get(2)
5955 .and_then(|e: &Vec<String>| e.first())
5956 .is_some_and(|v: &String| v == "ZB3")
5957 });
5958 if !has_cci_zb3 {
5959 continue;
5960 }
5961 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
5962 for cav in &cavs {
5963 if cav
5964 .elements
5965 .first()
5966 .and_then(|e: &Vec<String>| e.first())
5967 .is_some_and(|v: &String| v == "Z91")
5968 {
5969 if let Some(msb_id) = cav.elements.first().and_then(|e| e.get(1)) {
5970 if !msb_id.is_empty() {
5971 return ConditionResult::from(
5972 sender_mp_id.as_str() != msb_id.as_str(),
5973 );
5974 }
5975 }
5976 }
5977 }
5978 }
5979 }
5980 ConditionResult::Unknown
5981 }
5982
5983 fn evaluate_404(&self, ctx: &EvaluationContext) -> ConditionResult {
5986 let mr_nads = ctx.find_segments_with_qualifier("NAD", 0, "MR");
5987 let mr_mp_id = match mr_nads.first() {
5988 Some(nad) => nad
5989 .elements
5990 .get(1)
5991 .and_then(|e: &Vec<String>| e.first())
5992 .cloned()
5993 .unwrap_or_default(),
5994 None => return ConditionResult::Unknown,
5995 };
5996 if mr_mp_id.is_empty() {
5997 return ConditionResult::Unknown;
5998 }
5999
6000 let nav = match ctx.navigator {
6001 Some(n) => n,
6002 None => {
6003 let cavs = ctx.find_segments("CAV");
6004 let same_id_exists = cavs.iter().any(|s| {
6005 s.elements
6006 .first()
6007 .and_then(|e: &Vec<String>| e.first())
6008 .is_some_and(|v: &String| v == "Z91")
6009 && s.elements
6010 .first()
6011 .and_then(|e| e.get(1))
6012 .is_some_and(|v: &String| v == &mr_mp_id)
6013 });
6014 return ConditionResult::from(!same_id_exists);
6015 }
6016 };
6017
6018 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
6019 for i in 0..sg8_count {
6020 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
6021 for j in 0..sg10_count {
6022 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
6023 let has_cci_zb3 = ccis.iter().any(|s| {
6024 s.elements
6025 .get(2)
6026 .and_then(|e: &Vec<String>| e.first())
6027 .is_some_and(|v: &String| v == "ZB3")
6028 });
6029 if !has_cci_zb3 {
6030 continue;
6031 }
6032 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
6033 for cav in &cavs {
6034 if cav
6035 .elements
6036 .first()
6037 .and_then(|e: &Vec<String>| e.first())
6038 .is_some_and(|v: &String| v == "Z91")
6039 {
6040 let cav_mp_id = cav
6041 .elements
6042 .first()
6043 .and_then(|e| e.get(1))
6044 .map(|s| s.as_str())
6045 .unwrap_or("");
6046 if cav_mp_id == mr_mp_id.as_str() {
6047 return ConditionResult::False;
6048 }
6049 }
6050 }
6051 }
6052 }
6053
6054 ConditionResult::True
6055 }
6056
6057 fn evaluate_405(&self, ctx: &EvaluationContext) -> ConditionResult {
6059 let pia_segs = ctx.find_segments("PIA");
6061 let found = pia_segs.iter().any(|s| {
6062 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
6063 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6064 v.starts_with("1-") && v.contains(":1.8.")
6065 })
6066 });
6067 ConditionResult::from(found)
6068 }
6069
6070 fn evaluate_406(&self, ctx: &EvaluationContext) -> ConditionResult {
6072 let pia_segs = ctx.find_segments("PIA");
6074 let found = pia_segs.iter().any(|s| {
6075 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
6076 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6077 v.starts_with("1-") && v.contains(":1.8.")
6078 })
6079 });
6080 ConditionResult::from(found)
6081 }
6082
6083 fn evaluate_407(&self, ctx: &EvaluationContext) -> ConditionResult {
6085 let pia_segs = ctx.find_segments("PIA");
6087 let found = pia_segs.iter().any(|s| {
6088 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
6089 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6090 v.starts_with("1-") && (v.contains(":3.8.") || v.contains(":4.8."))
6091 })
6092 });
6093 ConditionResult::from(found)
6094 }
6095
6096 fn evaluate_408(&self, ctx: &EvaluationContext) -> ConditionResult {
6098 let has_seq_z02 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z02").is_empty();
6100 ConditionResult::from(has_seq_z02)
6101 }
6102
6103 fn evaluate_409(&self, ctx: &EvaluationContext) -> ConditionResult {
6105 let has_seq_z02 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z02").is_empty();
6107 ConditionResult::from(!has_seq_z02)
6108 }
6109
6110 fn evaluate_410(&self, ctx: &EvaluationContext) -> ConditionResult {
6112 let has_seq_z02 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z02").is_empty();
6114 ConditionResult::from(has_seq_z02)
6115 }
6116
6117 fn evaluate_411(&self, ctx: &EvaluationContext) -> ConditionResult {
6119 let has_seq_z02 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z02").is_empty();
6121 ConditionResult::from(!has_seq_z02)
6122 }
6123
6124 fn evaluate_412(&self, ctx: &EvaluationContext) -> ConditionResult {
6126 ctx.external.evaluate("code_list_membership_check")
6127 }
6128
6129 fn evaluate_413(&self, ctx: &EvaluationContext) -> ConditionResult {
6131 let found = ctx.find_segments("SEQ").iter().any(|s| {
6133 s.elements.first().and_then(|e| e.first())
6134 .is_some_and(|v| ["Z02", "ZA1", "ZA2"].contains(&v.as_str()))
6135 });
6136 ConditionResult::from(found)
6137 }
6138
6139 fn evaluate_414(&self, ctx: &EvaluationContext) -> ConditionResult {
6141 let found = ctx.find_segments("SEQ").iter().any(|s| {
6143 s.elements.first().and_then(|e| e.first())
6144 .is_some_and(|v| ["Z02", "ZA1", "ZA2"].contains(&v.as_str()))
6145 });
6146 ConditionResult::from(!found)
6147 }
6148
6149 fn evaluate_415(&self, ctx: &EvaluationContext) -> ConditionResult {
6151 let count = ctx.find_segments("SEQ").iter().filter(|s| {
6153 s.elements.first().and_then(|e| e.first())
6154 .is_some_and(|v| ["Z02", "ZA1", "ZA2"].contains(&v.as_str()))
6155 }).count();
6156 ConditionResult::from(count > 1)
6157 }
6158
6159 fn evaluate_416(&self, ctx: &EvaluationContext) -> ConditionResult {
6161 let count = ctx.find_segments("SEQ").iter().filter(|s| {
6163 s.elements.first().and_then(|e| e.first())
6164 .is_some_and(|v| ["Z02", "ZA1", "ZA2"].contains(&v.as_str()))
6165 }).count();
6166 ConditionResult::from(count <= 1)
6167 }
6168
6169 fn evaluate_417(&self, _ctx: &EvaluationContext) -> ConditionResult {
6171 ConditionResult::Unknown
6173 }
6174
6175 fn evaluate_419(&self, _ctx: &EvaluationContext) -> ConditionResult {
6177 ConditionResult::Unknown
6179 }
6180
6181 fn evaluate_420(&self, ctx: &EvaluationContext) -> ConditionResult {
6183 let rff_segs = ctx.find_segments("RFF");
6184 let found = rff_segs.iter().any(|s| {
6185 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z14")
6186 });
6187 ConditionResult::from(found)
6188 }
6189
6190 fn evaluate_421(&self, ctx: &EvaluationContext) -> ConditionResult {
6192 ctx.any_group_has_qualifier("CCI", 0, "Z39", &["SG4", "SG8"])
6194 }
6195
6196 fn evaluate_425(&self, ctx: &EvaluationContext) -> ConditionResult {
6198 ctx.external.evaluate("code_list_membership_check")
6199 }
6200
6201 fn evaluate_426(&self, ctx: &EvaluationContext) -> ConditionResult {
6203 ctx.external.evaluate("code_list_membership_check")
6204 }
6205
6206 fn evaluate_427(&self, ctx: &EvaluationContext) -> ConditionResult {
6208 ctx.external.evaluate("code_list_membership_check")
6209 }
6210
6211 fn evaluate_428(&self, ctx: &EvaluationContext) -> ConditionResult {
6213 ctx.external.evaluate("code_list_membership_check")
6214 }
6215
6216 fn evaluate_429(&self, ctx: &EvaluationContext) -> ConditionResult {
6218 ctx.external.evaluate("code_list_membership_check")
6219 }
6220
6221 fn evaluate_430(&self, ctx: &EvaluationContext) -> ConditionResult {
6223 let seq_z27_count = ctx.find_segments_with_qualifier("SEQ", 0, "Z27").len();
6225 ConditionResult::from(seq_z27_count > 1)
6226 }
6227
6228 fn evaluate_431(&self, ctx: &EvaluationContext) -> ConditionResult {
6230 let seq_z27_count = ctx.find_segments_with_qualifier("SEQ", 0, "Z27").len();
6232 ConditionResult::from(seq_z27_count <= 1)
6233 }
6234
6235 fn evaluate_432(&self, ctx: &EvaluationContext) -> ConditionResult {
6237 let pia_segs = ctx.find_segments("PIA");
6239 let found = pia_segs.iter().any(|s| {
6240 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
6241 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| v == "9991000000078")
6242 });
6243 ConditionResult::from(found)
6244 }
6245
6246 fn evaluate_433(&self, ctx: &EvaluationContext) -> ConditionResult {
6248 ctx.external.evaluate("code_list_membership_check")
6249 }
6250
6251 fn evaluate_435(&self, ctx: &EvaluationContext) -> ConditionResult {
6253 ctx.external.evaluate("code_list_membership_check")
6254 }
6255
6256 fn evaluate_436(&self, ctx: &EvaluationContext) -> ConditionResult {
6258 let pia_segs = ctx.find_segments("PIA");
6260 let found = pia_segs.iter().any(|s| {
6261 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
6262 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| v == "9991000000086")
6263 });
6264 ConditionResult::from(found)
6265 }
6266
6267 fn evaluate_437(&self, ctx: &EvaluationContext) -> ConditionResult {
6269 let sts_segs = ctx.find_segments("STS");
6270 let found = sts_segs.iter().any(|s| {
6271 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "E01")
6272 && s.elements.get(2).and_then(|e| e.first())
6273 .is_some_and(|v| ["A04", "A23"].contains(&v.as_str()))
6274 });
6275 ConditionResult::from(found)
6276 }
6277
6278 fn evaluate_438(&self, ctx: &EvaluationContext) -> ConditionResult {
6280 let cci_segs = ctx.find_segments("CCI");
6281 let found = cci_segs.iter().any(|s| {
6282 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z39")
6283 });
6284 ConditionResult::from(found)
6285 }
6286
6287 fn evaluate_440(&self, ctx: &EvaluationContext) -> ConditionResult {
6289 ctx.has_qualifier("RFF", 0, "Z35")
6291 }
6292
6293 fn evaluate_441(&self, ctx: &EvaluationContext) -> ConditionResult {
6295 ctx.any_group_has_qualifier_without(
6297 "SEQ", 0, "Z03", "RFF", 0, "Z14", &["SG4", "SG8"],
6298 )
6299 }
6300
6301 fn evaluate_442(&self, ctx: &EvaluationContext) -> ConditionResult {
6303 ctx.has_qualifier("RFF", 0, "Z34")
6305 }
6306
6307 fn evaluate_444(&self, ctx: &EvaluationContext) -> ConditionResult {
6310 for code in ["Z60", "ZE0", "ZG8", "ZG9"] {
6311 if matches!(
6312 ctx.any_group_has_qualifier_without("SEQ", 0, code, "PIA", 0, "5", &["SG4", "SG8"]),
6313 ConditionResult::True
6314 ) {
6315 return ConditionResult::True;
6316 }
6317 }
6318 ConditionResult::False
6319 }
6320
6321 fn evaluate_445(&self, ctx: &EvaluationContext) -> ConditionResult {
6324 let nav = match ctx.navigator {
6325 Some(n) => n,
6326 None => {
6327 let has_cci11 = ["Z60", "ZE0", "ZG8", "ZG9"].iter().any(|code| {
6328 matches!(
6329 ctx.filtered_parent_child_has_qualifier(
6330 &["SG4", "SG8"],
6331 "SEQ",
6332 0,
6333 code,
6334 "SG10",
6335 "CCI",
6336 0,
6337 "11",
6338 ),
6339 ConditionResult::True
6340 )
6341 });
6342 return ConditionResult::from(!has_cci11);
6343 }
6344 };
6345
6346 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
6347 for i in 0..sg8_count {
6348 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
6349 let has_cci11 = (0..sg10_count).any(|j| {
6350 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
6351 ccis.iter().any(|s| {
6352 s.elements
6353 .first()
6354 .and_then(|e: &Vec<String>| e.first())
6355 .is_some_and(|v: &String| v == "11")
6356 })
6357 });
6358 if !has_cci11 {
6359 return ConditionResult::True;
6360 }
6361 }
6362 ConditionResult::False
6363 }
6364
6365 fn evaluate_446(&self, ctx: &EvaluationContext) -> ConditionResult {
6367 let cci_segs = ctx.find_segments("CCI");
6368 let found = cci_segs.iter().any(|s| {
6369 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z17")
6370 });
6371 ConditionResult::from(found)
6372 }
6373
6374 fn evaluate_447(&self, ctx: &EvaluationContext) -> ConditionResult {
6376 let cci_segs = ctx.find_segments("CCI");
6377 let found = cci_segs.iter().any(|s| {
6378 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z50")
6379 });
6380 ConditionResult::from(found)
6381 }
6382
6383 fn evaluate_448(&self, ctx: &EvaluationContext) -> ConditionResult {
6385 let cci_segs = ctx.find_segments("CCI");
6386 let found = cci_segs.iter().any(|s| {
6387 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z56")
6388 });
6389 ConditionResult::from(found)
6390 }
6391
6392 fn evaluate_449(&self, ctx: &EvaluationContext) -> ConditionResult {
6394 let cci_segs = ctx.find_segments("CCI");
6395 let has_cci = cci_segs.iter().any(|s| {
6396 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "6")
6397 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZA9")
6398 });
6399 let cav_segs = ctx.find_segments("CAV");
6400 let has_cav = cav_segs.iter().any(|s| {
6401 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZG3")
6402 });
6403 ConditionResult::from(has_cci && has_cav)
6404 }
6405
6406 fn evaluate_450(&self, ctx: &EvaluationContext) -> ConditionResult {
6408 ctx.has_qualifier("RFF", 0, "Z32")
6410 }
6411
6412 fn evaluate_451(&self, ctx: &EvaluationContext) -> ConditionResult {
6414 ctx.has_qualifier("RFF", 0, "Z18")
6416 }
6417
6418 fn evaluate_452(&self, ctx: &EvaluationContext) -> ConditionResult {
6420 ctx.has_qualifier("RFF", 0, "Z19")
6422 }
6423
6424 fn evaluate_453(&self, ctx: &EvaluationContext) -> ConditionResult {
6426 ctx.external.evaluate("code_list_membership_check")
6427 }
6428
6429 fn evaluate_454(&self, _ctx: &EvaluationContext) -> ConditionResult {
6431 ConditionResult::True
6433 }
6434
6435 fn evaluate_455(&self, _ctx: &EvaluationContext) -> ConditionResult {
6437 ConditionResult::True
6439 }
6440
6441 fn evaluate_456(&self, ctx: &EvaluationContext) -> ConditionResult {
6443 ctx.has_qualifier("RFF", 0, "Z37")
6445 }
6446
6447 fn evaluate_457(&self, ctx: &EvaluationContext) -> ConditionResult {
6449 let pia_segs = ctx.find_segments("PIA");
6451 let found = pia_segs.iter().any(|s| {
6452 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
6453 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| v == "9991000001498")
6454 });
6455 ConditionResult::from(found)
6456 }
6457
6458 fn evaluate_458(&self, ctx: &EvaluationContext) -> ConditionResult {
6460 let pia_segs = ctx.find_segments("PIA");
6462 let found = pia_segs.iter().any(|s| {
6463 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "5")
6464 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| v == "9991000000739")
6465 });
6466 ConditionResult::from(found)
6467 }
6468
6469 fn evaluate_459(&self, ctx: &EvaluationContext) -> ConditionResult {
6471 ctx.external.evaluate("code_list_membership_check")
6472 }
6473
6474 fn evaluate_460(&self, ctx: &EvaluationContext) -> ConditionResult {
6476 ctx.external.evaluate("code_list_membership_check")
6477 }
6478
6479 fn evaluate_461(&self, ctx: &EvaluationContext) -> ConditionResult {
6481 let cci_segs = ctx.find_segments("CCI");
6482 let found = cci_segs.iter().any(|s| {
6483 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z17")
6484 });
6485 ConditionResult::from(found)
6486 }
6487
6488 fn evaluate_462(&self, ctx: &EvaluationContext) -> ConditionResult {
6490 let cci_segs = ctx.find_segments("CCI");
6491 let found = cci_segs.iter().any(|s| {
6492 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z17")
6493 });
6494 ConditionResult::from(found)
6495 }
6496
6497 fn evaluate_463(&self, ctx: &EvaluationContext) -> ConditionResult {
6499 let cci_segs = ctx.find_segments("CCI");
6500 let found = cci_segs.iter().any(|s| {
6501 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z61")
6502 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| v == "ZF9")
6503 });
6504 ConditionResult::from(found)
6505 }
6506
6507 fn evaluate_465(&self, ctx: &EvaluationContext) -> ConditionResult {
6509 let rff_segs = ctx.find_segments("RFF");
6510 let found = rff_segs.iter().any(|s| {
6511 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z38")
6512 });
6513 ConditionResult::from(found)
6514 }
6515
6516 fn evaluate_466(&self, ctx: &EvaluationContext) -> ConditionResult {
6518 let rff_segs = ctx.find_segments("RFF");
6519 let found = rff_segs.iter().any(|s| {
6520 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "Z32")
6521 });
6522 ConditionResult::from(found)
6523 }
6524
6525 fn evaluate_467(&self, ctx: &EvaluationContext) -> ConditionResult {
6527 let segs = ctx.find_segments("CAV");
6528 let found = segs.iter().any(|s| {
6529 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZG8")
6530 });
6531 ConditionResult::from(found)
6532 }
6533
6534 fn evaluate_468(&self, ctx: &EvaluationContext) -> ConditionResult {
6536 let segs = ctx.find_segments("CAV");
6537 let found = segs.iter().any(|s| {
6538 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH0")
6539 });
6540 ConditionResult::from(found)
6541 }
6542
6543 fn evaluate_469(&self, ctx: &EvaluationContext) -> ConditionResult {
6545 let segs = ctx.find_segments("CAV");
6546 let found = segs.iter().any(|s| {
6547 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH1")
6548 });
6549 ConditionResult::from(found)
6550 }
6551
6552 fn evaluate_470(&self, ctx: &EvaluationContext) -> ConditionResult {
6554 let segs = ctx.find_segments("CAV");
6555 let found = segs.iter().any(|s| {
6556 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "ZH5")
6557 });
6558 ConditionResult::from(found)
6559 }
6560
6561 fn evaluate_471(&self, ctx: &EvaluationContext) -> ConditionResult {
6563 let found = ctx.find_segments("RFF").iter().any(|s| {
6565 let qual = s.elements.first().and_then(|e| e.first()).map(|v| v.as_str());
6566 matches!(qual, Some("Z49") | Some("Z53"))
6567 && s.elements.first().and_then(|e| e.get(2)).is_some_and(|v| {
6568 v.parse::<u32>().is_ok_and(|n| n > 1)
6569 })
6570 });
6571 ConditionResult::from(found)
6572 }
6573
6574 fn evaluate_472(&self, ctx: &EvaluationContext) -> ConditionResult {
6576 let found = ctx.find_segments("RFF").iter().any(|s| {
6578 let qual = s.elements.first().and_then(|e| e.first()).map(|v| v.as_str());
6579 matches!(qual, Some("Z48") | Some("Z55"))
6580 && s.elements.first().and_then(|e| e.get(2)).is_some_and(|v| {
6581 v.parse::<u32>().is_ok_and(|n| n > 1)
6582 })
6583 });
6584 ConditionResult::from(found)
6585 }
6586
6587 fn evaluate_473(&self, ctx: &EvaluationContext) -> ConditionResult {
6589 let found = ctx.find_segments("RFF").iter().any(|s| {
6591 let qual = s.elements.first().and_then(|e| e.first()).map(|v| v.as_str());
6592 matches!(qual, Some("Z47") | Some("Z54"))
6593 && s.elements.first().and_then(|e| e.get(2)).is_some_and(|v| {
6594 v.parse::<u32>().is_ok_and(|n| n > 1)
6595 })
6596 });
6597 ConditionResult::from(found)
6598 }
6599
6600 fn evaluate_474(&self, ctx: &EvaluationContext) -> ConditionResult {
6602 let sts_segs = ctx.find_segments("STS");
6603 let found = sts_segs.iter().any(|s| {
6604 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6605 && s.elements.get(2).and_then(|e| e.first())
6606 .is_some_and(|v| ["ZC8"].contains(&v.as_str()))
6607 });
6608 ConditionResult::from(found)
6609 }
6610
6611 fn evaluate_475(&self, ctx: &EvaluationContext) -> ConditionResult {
6613 let sts_segs = ctx.find_segments("STS");
6614 let found = sts_segs.iter().any(|s| {
6615 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6616 && s.elements.get(2).and_then(|e| e.first())
6617 .is_some_and(|v| ["ZH1"].contains(&v.as_str()))
6618 });
6619 ConditionResult::from(found)
6620 }
6621
6622 fn evaluate_476(&self, ctx: &EvaluationContext) -> ConditionResult {
6624 let sts_segs = ctx.find_segments("STS");
6625 let found = sts_segs.iter().any(|s| {
6626 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6627 && s.elements.get(3).and_then(|e| e.first())
6628 .is_some_and(|v| ["ZW0"].contains(&v.as_str()))
6629 });
6630 ConditionResult::from(found)
6631 }
6632
6633 fn evaluate_477(&self, ctx: &EvaluationContext) -> ConditionResult {
6635 let sts_segs = ctx.find_segments("STS");
6636 let found = sts_segs.iter().any(|s| {
6637 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6638 && s.elements.get(3).and_then(|e| e.first())
6639 .is_some_and(|v| ["ZW1"].contains(&v.as_str()))
6640 });
6641 ConditionResult::from(found)
6642 }
6643
6644 fn evaluate_478(&self, ctx: &EvaluationContext) -> ConditionResult {
6646 let sts_segs = ctx.find_segments("STS");
6647 let found = sts_segs.iter().any(|s| {
6648 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6649 && s.elements.get(3).and_then(|e| e.first())
6650 .is_some_and(|v| ["ZW2"].contains(&v.as_str()))
6651 });
6652 ConditionResult::from(found)
6653 }
6654
6655 fn evaluate_479(&self, ctx: &EvaluationContext) -> ConditionResult {
6657 let sts_segs = ctx.find_segments("STS");
6658 let found = sts_segs.iter().any(|s| {
6659 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6660 && s.elements.get(3).and_then(|e| e.first())
6661 .is_some_and(|v| ["ZW3"].contains(&v.as_str()))
6662 });
6663 ConditionResult::from(found)
6664 }
6665
6666 fn evaluate_480(&self, ctx: &EvaluationContext) -> ConditionResult {
6668 let sts_segs = ctx.find_segments("STS");
6669 let found = sts_segs.iter().any(|s| {
6670 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6671 && s.elements.get(3).and_then(|e| e.first())
6672 .is_some_and(|v| ["ZW4"].contains(&v.as_str()))
6673 });
6674 ConditionResult::from(found)
6675 }
6676
6677 fn evaluate_481(&self, ctx: &EvaluationContext) -> ConditionResult {
6679 let sts_segs = ctx.find_segments("STS");
6680 let found = sts_segs.iter().any(|s| {
6681 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6682 && s.elements.get(3).and_then(|e| e.first())
6683 .is_some_and(|v| ["ZW5"].contains(&v.as_str()))
6684 });
6685 ConditionResult::from(found)
6686 }
6687
6688 fn evaluate_483(&self, ctx: &EvaluationContext) -> ConditionResult {
6690 let sts_segs = ctx.find_segments("STS");
6691 let found = sts_segs.iter().any(|s| {
6692 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6693 && s.elements.get(3).and_then(|e| e.first())
6694 .is_some_and(|v| ["ZW7"].contains(&v.as_str()))
6695 });
6696 ConditionResult::from(found)
6697 }
6698
6699 fn evaluate_484(&self, ctx: &EvaluationContext) -> ConditionResult {
6701 let sts_segs = ctx.find_segments("STS");
6702 let found = sts_segs.iter().any(|s| {
6703 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6704 && s.elements.get(3).and_then(|e| e.first())
6705 .is_some_and(|v| ["ZW8"].contains(&v.as_str()))
6706 });
6707 ConditionResult::from(found)
6708 }
6709
6710 fn evaluate_487(&self, ctx: &EvaluationContext) -> ConditionResult {
6712 let sts_segs = ctx.find_segments("STS");
6713 let found = sts_segs.iter().any(|s| {
6714 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "7")
6715 && s.elements.get(3).and_then(|e| e.first())
6716 .is_some_and(|v| ["ZX1"].contains(&v.as_str()))
6717 });
6718 ConditionResult::from(found)
6719 }
6720
6721 fn evaluate_489(&self, ctx: &EvaluationContext) -> ConditionResult {
6723 let rff_z49 = ctx.find_segments_with_qualifier("RFF", 0, "Z49");
6725 if rff_z49.is_empty() {
6726 return ConditionResult::Unknown;
6727 }
6728 ConditionResult::True
6730 }
6731
6732 fn evaluate_490(&self, ctx: &EvaluationContext) -> ConditionResult {
6734 ctx.format_check("DTM", 0, 1, is_mesz_utc)
6735 }
6736
6737 fn evaluate_491(&self, ctx: &EvaluationContext) -> ConditionResult {
6739 ctx.format_check("DTM", 0, 1, is_mez_utc)
6740 }
6741
6742 fn evaluate_494(&self, ctx: &EvaluationContext) -> ConditionResult {
6744 let val = ctx.resolved_value.or_else(|| {
6747 ctx.find_segments_with_qualifier("DTM", 0, "137")
6748 .first()
6749 .and_then(|s| s.elements.first())
6750 .and_then(|e| e.get(1))
6751 .map(|v| v.as_str())
6752 });
6753 let Some(dtm_val) = val else {
6754 return ConditionResult::Unknown;
6755 };
6756 if dtm_val.len() < 12 {
6757 return ConditionResult::Unknown;
6758 }
6759 let now_str = crate::eval::format_validators::utc_now_ccyymmddhhmm();
6760 ConditionResult::from(&dtm_val[..12] <= now_str.as_str())
6761 }
6762
6763 fn evaluate_500(&self, _ctx: &EvaluationContext) -> ConditionResult {
6765 ConditionResult::True
6766 }
6767
6768 fn evaluate_501(&self, _ctx: &EvaluationContext) -> ConditionResult {
6770 ConditionResult::True
6771 }
6772
6773 fn evaluate_502(&self, _ctx: &EvaluationContext) -> ConditionResult {
6775 ConditionResult::True
6776 }
6777
6778 fn evaluate_503(&self, _ctx: &EvaluationContext) -> ConditionResult {
6780 ConditionResult::True
6781 }
6782
6783 fn evaluate_504(&self, _ctx: &EvaluationContext) -> ConditionResult {
6785 ConditionResult::True
6786 }
6787
6788 fn evaluate_505(&self, _ctx: &EvaluationContext) -> ConditionResult {
6790 ConditionResult::True
6791 }
6792
6793 fn evaluate_506(&self, _ctx: &EvaluationContext) -> ConditionResult {
6795 ConditionResult::True
6796 }
6797
6798 fn evaluate_507(&self, _ctx: &EvaluationContext) -> ConditionResult {
6800 ConditionResult::True
6801 }
6802
6803 fn evaluate_508(&self, _ctx: &EvaluationContext) -> ConditionResult {
6805 ConditionResult::True
6806 }
6807
6808 fn evaluate_509(&self, _ctx: &EvaluationContext) -> ConditionResult {
6810 ConditionResult::True
6811 }
6812
6813 fn evaluate_510(&self, _ctx: &EvaluationContext) -> ConditionResult {
6815 ConditionResult::True
6816 }
6817
6818 fn evaluate_511(&self, _ctx: &EvaluationContext) -> ConditionResult {
6820 ConditionResult::True
6821 }
6822
6823 fn evaluate_512(&self, _ctx: &EvaluationContext) -> ConditionResult {
6825 ConditionResult::True
6826 }
6827
6828 fn evaluate_513(&self, _ctx: &EvaluationContext) -> ConditionResult {
6830 ConditionResult::True
6831 }
6832
6833 fn evaluate_514(&self, _ctx: &EvaluationContext) -> ConditionResult {
6835 ConditionResult::True
6836 }
6837
6838 fn evaluate_515(&self, _ctx: &EvaluationContext) -> ConditionResult {
6840 ConditionResult::True
6841 }
6842
6843 fn evaluate_516(&self, _ctx: &EvaluationContext) -> ConditionResult {
6845 ConditionResult::True
6846 }
6847
6848 fn evaluate_517(&self, _ctx: &EvaluationContext) -> ConditionResult {
6850 ConditionResult::True
6851 }
6852
6853 fn evaluate_518(&self, _ctx: &EvaluationContext) -> ConditionResult {
6855 ConditionResult::True
6856 }
6857
6858 fn evaluate_519(&self, _ctx: &EvaluationContext) -> ConditionResult {
6860 ConditionResult::True
6861 }
6862
6863 fn evaluate_520(&self, _ctx: &EvaluationContext) -> ConditionResult {
6865 ConditionResult::True
6866 }
6867
6868 fn evaluate_521(&self, _ctx: &EvaluationContext) -> ConditionResult {
6870 ConditionResult::True
6871 }
6872
6873 fn evaluate_522(&self, _ctx: &EvaluationContext) -> ConditionResult {
6875 ConditionResult::True
6876 }
6877
6878 fn evaluate_523(&self, _ctx: &EvaluationContext) -> ConditionResult {
6880 ConditionResult::True
6881 }
6882
6883 fn evaluate_524(&self, _ctx: &EvaluationContext) -> ConditionResult {
6885 ConditionResult::True
6886 }
6887
6888 fn evaluate_525(&self, _ctx: &EvaluationContext) -> ConditionResult {
6890 ConditionResult::True
6891 }
6892
6893 fn evaluate_526(&self, _ctx: &EvaluationContext) -> ConditionResult {
6895 ConditionResult::True
6896 }
6897
6898 fn evaluate_527(&self, _ctx: &EvaluationContext) -> ConditionResult {
6900 ConditionResult::True
6901 }
6902
6903 fn evaluate_528(&self, _ctx: &EvaluationContext) -> ConditionResult {
6905 ConditionResult::True
6906 }
6907
6908 fn evaluate_529(&self, _ctx: &EvaluationContext) -> ConditionResult {
6910 ConditionResult::True
6911 }
6912
6913 fn evaluate_530(&self, _ctx: &EvaluationContext) -> ConditionResult {
6915 ConditionResult::True
6916 }
6917
6918 fn evaluate_531(&self, _ctx: &EvaluationContext) -> ConditionResult {
6920 ConditionResult::True
6921 }
6922
6923 fn evaluate_532(&self, _ctx: &EvaluationContext) -> ConditionResult {
6925 ConditionResult::True
6926 }
6927
6928 fn evaluate_533(&self, _ctx: &EvaluationContext) -> ConditionResult {
6930 ConditionResult::True
6931 }
6932
6933 fn evaluate_555(&self, _ctx: &EvaluationContext) -> ConditionResult {
6935 ConditionResult::Unknown
6937 }
6938
6939 fn evaluate_556(&self, _ctx: &EvaluationContext) -> ConditionResult {
6941 ConditionResult::True
6942 }
6943
6944 fn evaluate_558(&self, _ctx: &EvaluationContext) -> ConditionResult {
6946 ConditionResult::True
6947 }
6948
6949 fn evaluate_559(&self, _ctx: &EvaluationContext) -> ConditionResult {
6951 ConditionResult::True
6952 }
6953
6954 fn evaluate_563(&self, _ctx: &EvaluationContext) -> ConditionResult {
6956 ConditionResult::True
6957 }
6958
6959 fn evaluate_566(&self, _ctx: &EvaluationContext) -> ConditionResult {
6961 ConditionResult::True
6962 }
6963
6964 fn evaluate_567(&self, _ctx: &EvaluationContext) -> ConditionResult {
6966 ConditionResult::True
6967 }
6968
6969 fn evaluate_568(&self, _ctx: &EvaluationContext) -> ConditionResult {
6971 ConditionResult::True
6972 }
6973
6974 fn evaluate_569(&self, _ctx: &EvaluationContext) -> ConditionResult {
6976 ConditionResult::True
6977 }
6978
6979 fn evaluate_570(&self, _ctx: &EvaluationContext) -> ConditionResult {
6981 ConditionResult::True
6982 }
6983
6984 fn evaluate_572(&self, _ctx: &EvaluationContext) -> ConditionResult {
6986 ConditionResult::True
6987 }
6988
6989 fn evaluate_576(&self, _ctx: &EvaluationContext) -> ConditionResult {
6991 ConditionResult::True
6992 }
6993
6994 fn evaluate_577(&self, _ctx: &EvaluationContext) -> ConditionResult {
6996 ConditionResult::True
6997 }
6998
6999 fn evaluate_579(&self, _ctx: &EvaluationContext) -> ConditionResult {
7001 ConditionResult::True
7002 }
7003
7004 fn evaluate_580(&self, _ctx: &EvaluationContext) -> ConditionResult {
7006 ConditionResult::True
7007 }
7008
7009 fn evaluate_581(&self, _ctx: &EvaluationContext) -> ConditionResult {
7011 ConditionResult::True
7012 }
7013
7014 fn evaluate_586(&self, _ctx: &EvaluationContext) -> ConditionResult {
7016 ConditionResult::True
7017 }
7018
7019 fn evaluate_590(&self, _ctx: &EvaluationContext) -> ConditionResult {
7021 ConditionResult::True
7022 }
7023
7024 fn evaluate_594(&self, _ctx: &EvaluationContext) -> ConditionResult {
7026 ConditionResult::True
7027 }
7028
7029 fn evaluate_599(&self, _ctx: &EvaluationContext) -> ConditionResult {
7031 ConditionResult::True
7032 }
7033
7034 fn evaluate_601(&self, _ctx: &EvaluationContext) -> ConditionResult {
7036 ConditionResult::True
7037 }
7038
7039 fn evaluate_606(&self, _ctx: &EvaluationContext) -> ConditionResult {
7041 ConditionResult::True
7042 }
7043
7044 fn evaluate_609(&self, _ctx: &EvaluationContext) -> ConditionResult {
7046 ConditionResult::True
7047 }
7048
7049 fn evaluate_611(&self, _ctx: &EvaluationContext) -> ConditionResult {
7051 ConditionResult::True
7052 }
7053
7054 fn evaluate_614(&self, _ctx: &EvaluationContext) -> ConditionResult {
7056 ConditionResult::True
7057 }
7058
7059 fn evaluate_617(&self, _ctx: &EvaluationContext) -> ConditionResult {
7061 ConditionResult::True
7062 }
7063
7064 fn evaluate_618(&self, _ctx: &EvaluationContext) -> ConditionResult {
7066 ConditionResult::True
7067 }
7068
7069 fn evaluate_619(&self, _ctx: &EvaluationContext) -> ConditionResult {
7071 ConditionResult::True
7072 }
7073
7074 fn evaluate_621(&self, _ctx: &EvaluationContext) -> ConditionResult {
7076 ConditionResult::True
7077 }
7078
7079 fn evaluate_622(&self, _ctx: &EvaluationContext) -> ConditionResult {
7081 ConditionResult::True
7082 }
7083
7084 fn evaluate_623(&self, _ctx: &EvaluationContext) -> ConditionResult {
7086 ConditionResult::True
7087 }
7088
7089 fn evaluate_630(&self, _ctx: &EvaluationContext) -> ConditionResult {
7091 ConditionResult::True
7092 }
7093
7094 fn evaluate_631(&self, _ctx: &EvaluationContext) -> ConditionResult {
7096 ConditionResult::True
7097 }
7098
7099 fn evaluate_632(&self, _ctx: &EvaluationContext) -> ConditionResult {
7101 ConditionResult::True
7102 }
7103
7104 fn evaluate_637(&self, _ctx: &EvaluationContext) -> ConditionResult {
7106 ConditionResult::True
7107 }
7108
7109 fn evaluate_638(&self, _ctx: &EvaluationContext) -> ConditionResult {
7111 ConditionResult::True
7112 }
7113
7114 fn evaluate_639(&self, _ctx: &EvaluationContext) -> ConditionResult {
7116 ConditionResult::True
7117 }
7118
7119 fn evaluate_640(&self, _ctx: &EvaluationContext) -> ConditionResult {
7121 ConditionResult::True
7122 }
7123
7124 fn evaluate_641(&self, _ctx: &EvaluationContext) -> ConditionResult {
7126 ConditionResult::True
7127 }
7128
7129 fn evaluate_642(&self, _ctx: &EvaluationContext) -> ConditionResult {
7131 ConditionResult::True
7132 }
7133
7134 fn evaluate_643(&self, _ctx: &EvaluationContext) -> ConditionResult {
7136 ConditionResult::True
7137 }
7138
7139 fn evaluate_645(&self, _ctx: &EvaluationContext) -> ConditionResult {
7141 ConditionResult::True
7142 }
7143
7144 fn evaluate_646(&self, _ctx: &EvaluationContext) -> ConditionResult {
7146 ConditionResult::True
7147 }
7148
7149 fn evaluate_647(&self, _ctx: &EvaluationContext) -> ConditionResult {
7151 ConditionResult::True
7152 }
7153
7154 fn evaluate_648(&self, _ctx: &EvaluationContext) -> ConditionResult {
7156 ConditionResult::True
7157 }
7158
7159 fn evaluate_651(&self, _ctx: &EvaluationContext) -> ConditionResult {
7161 ConditionResult::True
7162 }
7163
7164 fn evaluate_653(&self, _ctx: &EvaluationContext) -> ConditionResult {
7166 ConditionResult::True
7167 }
7168
7169 fn evaluate_655(&self, _ctx: &EvaluationContext) -> ConditionResult {
7171 ConditionResult::True
7172 }
7173
7174 fn evaluate_659(&self, _ctx: &EvaluationContext) -> ConditionResult {
7176 ConditionResult::True
7177 }
7178
7179 fn evaluate_660(&self, _ctx: &EvaluationContext) -> ConditionResult {
7181 ConditionResult::True
7182 }
7183
7184 fn evaluate_662(&self, _ctx: &EvaluationContext) -> ConditionResult {
7186 ConditionResult::True
7187 }
7188
7189 fn evaluate_663(&self, _ctx: &EvaluationContext) -> ConditionResult {
7191 ConditionResult::True
7192 }
7193
7194 fn evaluate_664(&self, _ctx: &EvaluationContext) -> ConditionResult {
7196 ConditionResult::True
7197 }
7198
7199 fn evaluate_665(&self, _ctx: &EvaluationContext) -> ConditionResult {
7201 ConditionResult::True
7202 }
7203
7204 fn evaluate_667(&self, _ctx: &EvaluationContext) -> ConditionResult {
7206 ConditionResult::True
7207 }
7208
7209 fn evaluate_668(&self, _ctx: &EvaluationContext) -> ConditionResult {
7211 ConditionResult::True
7212 }
7213
7214 fn evaluate_670(&self, _ctx: &EvaluationContext) -> ConditionResult {
7216 ConditionResult::True
7217 }
7218
7219 fn evaluate_671(&self, _ctx: &EvaluationContext) -> ConditionResult {
7221 ConditionResult::True
7222 }
7223
7224 fn evaluate_672(&self, _ctx: &EvaluationContext) -> ConditionResult {
7226 ConditionResult::True
7227 }
7228
7229 fn evaluate_673(&self, _ctx: &EvaluationContext) -> ConditionResult {
7231 ConditionResult::True
7232 }
7233
7234 fn evaluate_674(&self, _ctx: &EvaluationContext) -> ConditionResult {
7236 ConditionResult::True
7237 }
7238
7239 fn evaluate_675(&self, _ctx: &EvaluationContext) -> ConditionResult {
7241 ConditionResult::True
7242 }
7243
7244 fn evaluate_677(&self, _ctx: &EvaluationContext) -> ConditionResult {
7246 ConditionResult::True
7247 }
7248
7249 fn evaluate_678(&self, _ctx: &EvaluationContext) -> ConditionResult {
7251 ConditionResult::True
7252 }
7253
7254 fn evaluate_679(&self, _ctx: &EvaluationContext) -> ConditionResult {
7256 ConditionResult::True
7257 }
7258
7259 fn evaluate_680(&self, _ctx: &EvaluationContext) -> ConditionResult {
7261 ConditionResult::True
7262 }
7263
7264 fn evaluate_682(&self, _ctx: &EvaluationContext) -> ConditionResult {
7266 ConditionResult::True
7267 }
7268
7269 fn evaluate_683(&self, _ctx: &EvaluationContext) -> ConditionResult {
7271 ConditionResult::True
7272 }
7273
7274 fn evaluate_684(&self, _ctx: &EvaluationContext) -> ConditionResult {
7276 ConditionResult::True
7277 }
7278
7279 fn evaluate_685(&self, _ctx: &EvaluationContext) -> ConditionResult {
7281 ConditionResult::True
7282 }
7283
7284 fn evaluate_687(&self, _ctx: &EvaluationContext) -> ConditionResult {
7286 ConditionResult::True
7287 }
7288
7289 fn evaluate_688(&self, _ctx: &EvaluationContext) -> ConditionResult {
7291 ConditionResult::True
7292 }
7293
7294 fn evaluate_689(&self, _ctx: &EvaluationContext) -> ConditionResult {
7296 ConditionResult::True
7297 }
7298
7299 fn evaluate_690(&self, _ctx: &EvaluationContext) -> ConditionResult {
7301 ConditionResult::True
7302 }
7303
7304 fn evaluate_693(&self, _ctx: &EvaluationContext) -> ConditionResult {
7306 ConditionResult::True
7307 }
7308
7309 fn evaluate_694(&self, _ctx: &EvaluationContext) -> ConditionResult {
7311 ConditionResult::True
7312 }
7313
7314 fn evaluate_695(&self, _ctx: &EvaluationContext) -> ConditionResult {
7316 ConditionResult::True
7317 }
7318
7319 fn evaluate_696(&self, _ctx: &EvaluationContext) -> ConditionResult {
7321 ConditionResult::True
7322 }
7323
7324 fn evaluate_698(&self, _ctx: &EvaluationContext) -> ConditionResult {
7326 ConditionResult::True
7327 }
7328
7329 fn evaluate_699(&self, _ctx: &EvaluationContext) -> ConditionResult {
7331 ConditionResult::True
7332 }
7333
7334 fn evaluate_700(&self, _ctx: &EvaluationContext) -> ConditionResult {
7336 ConditionResult::True
7337 }
7338
7339 fn evaluate_704(&self, _ctx: &EvaluationContext) -> ConditionResult {
7341 ConditionResult::True
7342 }
7343
7344 fn evaluate_705(&self, _ctx: &EvaluationContext) -> ConditionResult {
7346 ConditionResult::True
7347 }
7348
7349 fn evaluate_706(&self, ctx: &EvaluationContext) -> ConditionResult {
7351 ctx.external.evaluate("data_clearing_required")
7352 }
7353
7354 fn evaluate_707(&self, _ctx: &EvaluationContext) -> ConditionResult {
7356 ConditionResult::True
7357 }
7358
7359 fn evaluate_708(&self, _ctx: &EvaluationContext) -> ConditionResult {
7361 ConditionResult::True
7362 }
7363
7364 fn evaluate_709(&self, _ctx: &EvaluationContext) -> ConditionResult {
7366 ConditionResult::True
7367 }
7368
7369 fn evaluate_710(&self, _ctx: &EvaluationContext) -> ConditionResult {
7371 ConditionResult::True
7372 }
7373
7374 fn evaluate_711(&self, _ctx: &EvaluationContext) -> ConditionResult {
7376 ConditionResult::True
7377 }
7378
7379 fn evaluate_712(&self, _ctx: &EvaluationContext) -> ConditionResult {
7381 ConditionResult::True
7382 }
7383
7384 fn evaluate_713(&self, _ctx: &EvaluationContext) -> ConditionResult {
7386 ConditionResult::True
7387 }
7388
7389 fn evaluate_714(&self, _ctx: &EvaluationContext) -> ConditionResult {
7391 ConditionResult::True
7392 }
7393
7394 fn evaluate_715(&self, _ctx: &EvaluationContext) -> ConditionResult {
7396 ConditionResult::True
7397 }
7398
7399 fn evaluate_716(&self, _ctx: &EvaluationContext) -> ConditionResult {
7401 ConditionResult::True
7402 }
7403
7404 fn evaluate_717(&self, ctx: &EvaluationContext) -> ConditionResult {
7406 ctx.external.evaluate("data_clearing_required")
7407 }
7408
7409 fn evaluate_718(&self, _ctx: &EvaluationContext) -> ConditionResult {
7411 ConditionResult::True
7412 }
7413
7414 fn evaluate_719(&self, _ctx: &EvaluationContext) -> ConditionResult {
7416 ConditionResult::True
7417 }
7418
7419 fn evaluate_902(&self, _ctx: &EvaluationContext) -> ConditionResult {
7421 ConditionResult::True
7423 }
7424
7425 fn evaluate_910(&self, _ctx: &EvaluationContext) -> ConditionResult {
7427 ConditionResult::True
7429 }
7430
7431 fn evaluate_914(&self, ctx: &EvaluationContext) -> ConditionResult {
7433 ctx.format_check("SEQ", 1, 0, |val| validate_numeric(val, ">", 0.0))
7434 }
7435
7436 fn evaluate_922(&self, _ctx: &EvaluationContext) -> ConditionResult {
7438 ConditionResult::True
7440 }
7441
7442 fn evaluate_926(&self, _ctx: &EvaluationContext) -> ConditionResult {
7444 ConditionResult::True
7446 }
7447
7448 fn evaluate_930(&self, _ctx: &EvaluationContext) -> ConditionResult {
7450 ConditionResult::True
7452 }
7453
7454 fn evaluate_931(&self, ctx: &EvaluationContext) -> ConditionResult {
7456 ctx.format_check("DTM", 0, 1, validate_timezone_utc)
7457 }
7458
7459 fn evaluate_932(&self, ctx: &EvaluationContext) -> ConditionResult {
7461 ctx.format_check("DTM", 0, 1, |val| validate_hhmm_equals(val, "2200"))
7462 }
7463
7464 fn evaluate_933(&self, ctx: &EvaluationContext) -> ConditionResult {
7466 ctx.format_check("DTM", 0, 1, |val| validate_hhmm_equals(val, "2300"))
7467 }
7468
7469 fn evaluate_937(&self, ctx: &EvaluationContext) -> ConditionResult {
7471 ctx.format_check("SEQ", 1, 0, |val| validate_max_decimal_places(val, 0))
7472 }
7473
7474 fn evaluate_938(&self, _ctx: &EvaluationContext) -> ConditionResult {
7476 ConditionResult::True
7477 }
7478
7479 fn evaluate_939(&self, ctx: &EvaluationContext) -> ConditionResult {
7481 ctx.format_check("COM", 0, 0, validate_email)
7482 }
7483
7484 fn evaluate_940(&self, ctx: &EvaluationContext) -> ConditionResult {
7486 ctx.format_check("COM", 0, 0, validate_phone)
7487 }
7488
7489 fn evaluate_942(&self, _ctx: &EvaluationContext) -> ConditionResult {
7491 ConditionResult::True
7493 }
7494
7495 fn evaluate_943(&self, _ctx: &EvaluationContext) -> ConditionResult {
7497 ConditionResult::True
7499 }
7500
7501 fn evaluate_946(&self, _ctx: &EvaluationContext) -> ConditionResult {
7503 ConditionResult::True
7505 }
7506
7507 fn evaluate_948(&self, _ctx: &EvaluationContext) -> ConditionResult {
7509 ConditionResult::True
7511 }
7512
7513 fn evaluate_950(&self, _ctx: &EvaluationContext) -> ConditionResult {
7515 ConditionResult::True
7517 }
7518
7519 fn evaluate_951(&self, _ctx: &EvaluationContext) -> ConditionResult {
7521 ConditionResult::True
7523 }
7524
7525 fn evaluate_952(&self, _ctx: &EvaluationContext) -> ConditionResult {
7527 ConditionResult::True
7529 }
7530
7531 fn evaluate_955(&self, _ctx: &EvaluationContext) -> ConditionResult {
7533 ConditionResult::True
7535 }
7536
7537 fn evaluate_957(&self, _ctx: &EvaluationContext) -> ConditionResult {
7539 ConditionResult::True
7541 }
7542
7543 fn evaluate_960(&self, _ctx: &EvaluationContext) -> ConditionResult {
7545 ConditionResult::True
7547 }
7548
7549 fn evaluate_961(&self, _ctx: &EvaluationContext) -> ConditionResult {
7551 ConditionResult::True
7553 }
7554
7555 fn evaluate_967(&self, _ctx: &EvaluationContext) -> ConditionResult {
7557 ConditionResult::True
7559 }
7560
7561 fn evaluate_2001(&self, ctx: &EvaluationContext) -> ConditionResult {
7563 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
7565 ConditionResult::from(ide_count > 0)
7566 }
7567
7568 fn evaluate_2002(&self, ctx: &EvaluationContext) -> ConditionResult {
7570 let seq_segs = ctx.find_segments("SEQ");
7571 let has_z79 = seq_segs.iter().any(|s| {
7572 s.elements.first()
7573 .and_then(|e| e.first())
7574 .is_some_and(|v| v == "Z79")
7575 });
7576 ConditionResult::from(has_z79)
7577 }
7578
7579 fn evaluate_2003(&self, _ctx: &EvaluationContext) -> ConditionResult {
7581 ConditionResult::Unknown
7583 }
7584
7585 fn evaluate_2004(&self, ctx: &EvaluationContext) -> ConditionResult {
7588 let rff_qualifiers = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG6"]);
7589 let rff_zeitraum_ids = ctx.collect_group_values("RFF", 0, 2, &["SG4", "SG6"]);
7590
7591 let zeitraum_ids: Vec<String> = rff_qualifiers
7592 .iter()
7593 .filter(|(_, qual)| qual.as_str() == "Z49")
7594 .filter_map(|(idx, _)| {
7595 rff_zeitraum_ids
7596 .iter()
7597 .find(|(i, v)| i == idx && !v.is_empty())
7598 .map(|(_, v)| v.clone())
7599 })
7600 .collect();
7601
7602 if zeitraum_ids.is_empty() {
7603 return ConditionResult::Unknown;
7604 }
7605
7606 let seq_refs = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
7607
7608 for zid in &zeitraum_ids {
7609 let count = seq_refs.iter().filter(|(_, v)| v == zid).count();
7610 if count != 1 {
7611 return ConditionResult::False;
7612 }
7613 }
7614
7615 ConditionResult::True
7616 }
7617
7618 fn evaluate_2005(&self, ctx: &EvaluationContext) -> ConditionResult {
7621 let rff_qualifiers = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG6"]);
7622 let rff_zeitraum_ids = ctx.collect_group_values("RFF", 0, 2, &["SG4", "SG6"]);
7623
7624 let zeitraum_ids: Vec<String> = rff_qualifiers
7625 .iter()
7626 .filter(|(_, qual)| qual.as_str() == "Z49")
7627 .filter_map(|(idx, _)| {
7628 rff_zeitraum_ids
7629 .iter()
7630 .find(|(i, v)| i == idx && !v.is_empty())
7631 .map(|(_, v)| v.clone())
7632 })
7633 .collect();
7634
7635 if zeitraum_ids.is_empty() {
7636 return ConditionResult::Unknown;
7637 }
7638
7639 let seq_refs = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
7640
7641 for zid in &zeitraum_ids {
7642 let count = seq_refs.iter().filter(|(_, v)| v == zid).count();
7643 if count == 0 {
7644 return ConditionResult::False;
7645 }
7646 }
7647
7648 ConditionResult::True
7649 }
7650
7651 fn evaluate_2010(&self, _ctx: &EvaluationContext) -> ConditionResult {
7653 ConditionResult::Unknown
7655 }
7656
7657 fn evaluate_2011(&self, ctx: &EvaluationContext) -> ConditionResult {
7661 ctx.external
7662 .evaluate("request_message_zeitraum_ids_present")
7663 }
7664
7665 fn evaluate_2012(&self, _ctx: &EvaluationContext) -> ConditionResult {
7667 ConditionResult::Unknown
7669 }
7670
7671 fn evaluate_2013(&self, ctx: &EvaluationContext) -> ConditionResult {
7673 ctx.lacks_qualifier("RFF", 0, "Z54")
7675 }
7676
7677 fn evaluate_2014(&self, ctx: &EvaluationContext) -> ConditionResult {
7679 ctx.lacks_qualifier("RFF", 0, "Z47")
7681 }
7682
7683 fn evaluate_2015(&self, _ctx: &EvaluationContext) -> ConditionResult {
7685 ConditionResult::Unknown
7687 }
7688
7689 fn evaluate_2016(&self, ctx: &EvaluationContext) -> ConditionResult {
7691 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z16").len();
7693 ConditionResult::from(loc_count > 0)
7694 }
7695
7696 fn evaluate_2017(&self, ctx: &EvaluationContext) -> ConditionResult {
7698 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z17").len();
7700 ConditionResult::from(loc_count > 0)
7701 }
7702
7703 fn evaluate_2018(&self, _ctx: &EvaluationContext) -> ConditionResult {
7705 ConditionResult::Unknown
7707 }
7708
7709 fn evaluate_2060(&self, ctx: &EvaluationContext) -> ConditionResult {
7711 let found = ctx.find_segments("CAV").iter().any(|s| {
7713 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "NZR")
7714 });
7715 ConditionResult::from(found)
7716 }
7717
7718 fn evaluate_2061(&self, ctx: &EvaluationContext) -> ConditionResult {
7720 let ide_count = ctx.find_segments("IDE").len();
7722 ConditionResult::from(ide_count > 0)
7723 }
7724
7725 fn evaluate_2071(&self, ctx: &EvaluationContext) -> ConditionResult {
7727 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
7729 ConditionResult::from(ide_count > 0)
7730 }
7731
7732 fn evaluate_2073(&self, ctx: &EvaluationContext) -> ConditionResult {
7734 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
7736 ConditionResult::from(ide_count > 0)
7737 }
7738
7739 fn evaluate_2075(&self, ctx: &EvaluationContext) -> ConditionResult {
7741 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
7743 ConditionResult::from(ide_count > 0)
7744 }
7745
7746 fn evaluate_2080(&self, ctx: &EvaluationContext) -> ConditionResult {
7748 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
7750 ConditionResult::from(ide_count > 0)
7751 }
7752
7753 fn evaluate_2095(&self, ctx: &EvaluationContext) -> ConditionResult {
7755 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z15").len();
7757 ConditionResult::from(loc_count > 0)
7758 }
7759
7760 fn evaluate_2096(&self, ctx: &EvaluationContext) -> ConditionResult {
7762 let ide_count = ctx.find_segments("IDE").len();
7764 ConditionResult::from(ide_count > 0)
7765 }
7766
7767 fn evaluate_2119(&self, ctx: &EvaluationContext) -> ConditionResult {
7769 let found = ctx.find_segments("SEQ").iter().any(|s| {
7771 s.elements.first().and_then(|e| e.first())
7772 .is_some_and(|v| v == "Z13" || v == "ZG0")
7773 });
7774 ConditionResult::from(found)
7775 }
7776
7777 fn evaluate_2140(&self, ctx: &EvaluationContext) -> ConditionResult {
7779 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "Z01").len();
7781 ConditionResult::from(ide_count > 0)
7782 }
7783
7784 fn evaluate_2182(&self, ctx: &EvaluationContext) -> ConditionResult {
7786 let found = ctx.find_segments("SEQ").iter().any(|s| {
7788 s.elements.first().and_then(|e| e.first())
7789 .is_some_and(|v| ["Z01", "Z80", "Z81", "Z98"].contains(&v.as_str()))
7790 });
7791 ConditionResult::from(found)
7792 }
7793
7794 fn evaluate_2183(&self, ctx: &EvaluationContext) -> ConditionResult {
7796 let found = ctx.find_segments("SEQ").iter().any(|s| {
7798 s.elements.first().and_then(|e| e.first())
7799 .is_some_and(|v| ["Z01", "Z80", "Z81", "Z98"].contains(&v.as_str()))
7800 });
7801 ConditionResult::from(found)
7802 }
7803
7804 fn evaluate_2207(&self, ctx: &EvaluationContext) -> ConditionResult {
7806 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "Z01").len();
7808 ConditionResult::from(ide_count > 0)
7809 }
7810
7811 fn evaluate_2225(&self, _ctx: &EvaluationContext) -> ConditionResult {
7813 ConditionResult::Unknown
7815 }
7816
7817 fn evaluate_2236(&self, ctx: &EvaluationContext) -> ConditionResult {
7819 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
7821 ConditionResult::from(ide_count > 0)
7822 }
7823
7824 fn evaluate_2252(&self, _ctx: &EvaluationContext) -> ConditionResult {
7826 ConditionResult::Unknown
7828 }
7829
7830 fn evaluate_2261(&self, ctx: &EvaluationContext) -> ConditionResult {
7832 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z21").len();
7834 ConditionResult::from(loc_count > 0)
7835 }
7836
7837 fn evaluate_2284(&self, ctx: &EvaluationContext) -> ConditionResult {
7839 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z17").len();
7841 ConditionResult::from(loc_count > 0)
7842 }
7843
7844 fn evaluate_2286(&self, ctx: &EvaluationContext) -> ConditionResult {
7846 let found = !ctx.find_segments_with_qualifier("SEQ", 0, "ZF3").is_empty();
7848 ConditionResult::from(found)
7849 }
7850
7851 fn evaluate_2287(&self, ctx: &EvaluationContext) -> ConditionResult {
7853 let found = ctx.find_segments("SEQ").iter().any(|s| {
7855 s.elements.first().and_then(|e| e.first())
7856 .is_some_and(|v| v == "Z03" || v == "ZF5")
7857 });
7858 ConditionResult::from(found)
7859 }
7860
7861 fn evaluate_2288(&self, _ctx: &EvaluationContext) -> ConditionResult {
7863 ConditionResult::Unknown
7865 }
7866
7867 fn evaluate_2307(&self, ctx: &EvaluationContext) -> ConditionResult {
7869 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z21").len();
7871 ConditionResult::from(loc_count > 0)
7872 }
7873
7874 fn evaluate_2308(&self, ctx: &EvaluationContext) -> ConditionResult {
7876 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z16").len();
7878 ConditionResult::from(loc_count > 0)
7879 }
7880
7881 fn evaluate_2309(&self, ctx: &EvaluationContext) -> ConditionResult {
7883 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z17").len();
7885 ConditionResult::from(loc_count > 0)
7886 }
7887
7888 fn evaluate_2310(&self, ctx: &EvaluationContext) -> ConditionResult {
7890 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z16").len();
7892 ConditionResult::from(loc_count > 0)
7893 }
7894
7895 fn evaluate_2311(&self, ctx: &EvaluationContext) -> ConditionResult {
7897 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z21").len();
7899 ConditionResult::from(loc_count > 0)
7900 }
7901
7902 fn evaluate_2312(&self, ctx: &EvaluationContext) -> ConditionResult {
7904 let rff_z33 = ctx.find_segments_with_qualifier("RFF", 0, "Z33");
7906 let has_netzlokation = rff_z33.iter().any(|s| {
7907 s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| v == "9992000001256")
7908 });
7909 ConditionResult::from(!has_netzlokation)
7910 }
7911
7912 fn evaluate_2313(&self, ctx: &EvaluationContext) -> ConditionResult {
7914 let found = ctx.find_segments("SEQ").iter().any(|s| {
7916 s.elements.first().and_then(|e| e.first())
7917 .is_some_and(|v| ["Z58", "ZC9", "ZD0", "ZD6"].contains(&v.as_str()))
7918 });
7919 ConditionResult::from(found)
7920 }
7921
7922 fn evaluate_2317(&self, ctx: &EvaluationContext) -> ConditionResult {
7924 let has_cav = ctx.find_segments("CAV").iter().any(|s| {
7926 s.elements.first().and_then(|e| e.first())
7927 .is_some_and(|v| ["MIW", "MPW", "MUW"].contains(&v.as_str()))
7928 });
7929 ConditionResult::from(has_cav)
7930 }
7931
7932 fn evaluate_2318(&self, ctx: &EvaluationContext) -> ConditionResult {
7934 let has_cav = ctx.find_segments("CAV").iter().any(|s| {
7936 s.elements.first().and_then(|e| e.first()).is_some_and(|v| v == "MBW")
7937 });
7938 ConditionResult::from(has_cav)
7939 }
7940
7941 fn evaluate_2344(&self, _ctx: &EvaluationContext) -> ConditionResult {
7943 ConditionResult::Unknown
7945 }
7946
7947 fn evaluate_2350(&self, _ctx: &EvaluationContext) -> ConditionResult {
7949 ConditionResult::Unknown
7951 }
7952
7953 fn evaluate_2351(&self, _ctx: &EvaluationContext) -> ConditionResult {
7955 ConditionResult::Unknown
7957 }
7958
7959 fn evaluate_2352(&self, _ctx: &EvaluationContext) -> ConditionResult {
7961 ConditionResult::Unknown
7963 }
7964
7965 fn evaluate_2356(&self, ctx: &EvaluationContext) -> ConditionResult {
7967 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z18").len();
7969 ConditionResult::from(loc_count > 0)
7970 }
7971
7972 fn evaluate_2357(&self, ctx: &EvaluationContext) -> ConditionResult {
7974 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z20").len();
7976 ConditionResult::from(loc_count > 0)
7977 }
7978
7979 fn evaluate_2358(&self, ctx: &EvaluationContext) -> ConditionResult {
7981 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z19").len();
7983 ConditionResult::from(loc_count > 0)
7984 }
7985
7986 fn evaluate_2359(&self, ctx: &EvaluationContext) -> ConditionResult {
7988 let found = ctx.find_segments("LOC").iter().any(|s| {
7990 s.elements.first().and_then(|e| e.first())
7991 .is_some_and(|v| ["Z16", "Z17", "Z20"].contains(&v.as_str()))
7992 });
7993 ConditionResult::from(found)
7994 }
7995
7996 fn evaluate_2360(&self, ctx: &EvaluationContext) -> ConditionResult {
7998 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z18").len();
8000 ConditionResult::from(loc_count > 0)
8001 }
8002
8003 fn evaluate_2361(&self, ctx: &EvaluationContext) -> ConditionResult {
8005 let found = ctx.find_segments("LOC").iter().any(|s| {
8007 s.elements.first().and_then(|e| e.first())
8008 .is_some_and(|v| ["Z17", "Z20", "Z22"].contains(&v.as_str()))
8009 });
8010 ConditionResult::from(found)
8011 }
8012}