1#![allow(clippy::style, clippy::complexity)]
11
12#[allow(unused_imports)]
13use crate::eval::format_validators::*;
14use crate::eval::{Cluster, ConditionEvaluator, ConditionResult, EvaluationContext};
15use crate::eval::ebd_cluster::{all_sts_e01_in_cluster, ebd_ablehnung_except};
18
19pub struct UtilmdStromConditionEvaluatorFV2504 {
21 external_conditions: std::collections::HashSet<u32>,
23}
24
25impl Default for UtilmdStromConditionEvaluatorFV2504 {
26 fn default() -> Self {
27 let mut external_conditions = std::collections::HashSet::new();
28 external_conditions.insert(1);
29 external_conditions.insert(4);
30 external_conditions.insert(5);
31 external_conditions.insert(6);
32 external_conditions.insert(8);
33 external_conditions.insert(9);
34 external_conditions.insert(14);
35 external_conditions.insert(31);
36 external_conditions.insert(33);
37 external_conditions.insert(36);
38 external_conditions.insert(38);
39 external_conditions.insert(39);
40 external_conditions.insert(40);
41 external_conditions.insert(75);
42 external_conditions.insert(98);
43 external_conditions.insert(99);
44 external_conditions.insert(151);
45 external_conditions.insert(233);
46 external_conditions.insert(241);
47 external_conditions.insert(251);
48 external_conditions.insert(292);
49 external_conditions.insert(314);
50 external_conditions.insert(315);
51 external_conditions.insert(323);
52 external_conditions.insert(412);
53 external_conditions.insert(425);
54 external_conditions.insert(426);
55 external_conditions.insert(427);
56 external_conditions.insert(428);
57 external_conditions.insert(429);
58 external_conditions.insert(433);
59 external_conditions.insert(435);
60 external_conditions.insert(453);
61 external_conditions.insert(459);
62 external_conditions.insert(460);
63 external_conditions.insert(706);
64 external_conditions.insert(717);
65 external_conditions.insert(2011);
66 Self {
67 external_conditions,
68 }
69 }
70}
71
72impl ConditionEvaluator for UtilmdStromConditionEvaluatorFV2504 {
73 fn message_type(&self) -> &str {
74 "UTILMD_Strom"
75 }
76
77 fn format_version(&self) -> &str {
78 "FV2504"
79 }
80
81 fn evaluate(&self, condition: u32, ctx: &EvaluationContext) -> ConditionResult {
82 match condition {
83 1 => self.evaluate_1(ctx),
84 4 => self.evaluate_4(ctx),
85 5 => self.evaluate_5(ctx),
86 6 => self.evaluate_6(ctx),
87 7 => self.evaluate_7(ctx),
88 8 => self.evaluate_8(ctx),
89 9 => self.evaluate_9(ctx),
90 10 => self.evaluate_10(ctx),
91 11 => self.evaluate_11(ctx),
92 12 => self.evaluate_12(ctx),
93 13 => self.evaluate_13(ctx),
94 14 => self.evaluate_14(ctx),
95 15 => self.evaluate_15(ctx),
96 16 => self.evaluate_16(ctx),
97 17 => self.evaluate_17(ctx),
98 18 => self.evaluate_18(ctx),
99 19 => self.evaluate_19(ctx),
100 20 => self.evaluate_20(ctx),
101 21 => self.evaluate_21(ctx),
102 22 => self.evaluate_22(ctx),
103 23 => self.evaluate_23(ctx),
104 24 => self.evaluate_24(ctx),
105 25 => self.evaluate_25(ctx),
106 27 => self.evaluate_27(ctx),
107 30 => self.evaluate_30(ctx),
108 31 => self.evaluate_31(ctx),
109 32 => self.evaluate_32(ctx),
110 33 => self.evaluate_33(ctx),
111 34 => self.evaluate_34(ctx),
112 35 => self.evaluate_35(ctx),
113 36 => self.evaluate_36(ctx),
114 37 => self.evaluate_37(ctx),
115 38 => self.evaluate_38(ctx),
116 39 => self.evaluate_39(ctx),
117 40 => self.evaluate_40(ctx),
118 41 => self.evaluate_41(ctx),
119 42 => self.evaluate_42(ctx),
120 43 => self.evaluate_43(ctx),
121 44 => self.evaluate_44(ctx),
122 45 => self.evaluate_45(ctx),
123 46 => self.evaluate_46(ctx),
124 47 => self.evaluate_47(ctx),
125 48 => self.evaluate_48(ctx),
126 49 => self.evaluate_49(ctx),
127 50 => self.evaluate_50(ctx),
128 51 => self.evaluate_51(ctx),
129 52 => self.evaluate_52(ctx),
130 53 => self.evaluate_53(ctx),
131 54 => self.evaluate_54(ctx),
132 55 => self.evaluate_55(ctx),
133 56 => self.evaluate_56(ctx),
134 57 => self.evaluate_57(ctx),
135 58 => self.evaluate_58(ctx),
136 60 => self.evaluate_60(ctx),
137 61 => self.evaluate_61(ctx),
138 62 => self.evaluate_62(ctx),
139 63 => self.evaluate_63(ctx),
140 64 => self.evaluate_64(ctx),
141 65 => self.evaluate_65(ctx),
142 66 => self.evaluate_66(ctx),
143 67 => self.evaluate_67(ctx),
144 68 => self.evaluate_68(ctx),
145 69 => self.evaluate_69(ctx),
146 70 => self.evaluate_70(ctx),
147 71 => self.evaluate_71(ctx),
148 72 => self.evaluate_72(ctx),
149 73 => self.evaluate_73(ctx),
150 74 => self.evaluate_74(ctx),
151 75 => self.evaluate_75(ctx),
152 76 => self.evaluate_76(ctx),
153 77 => self.evaluate_77(ctx),
154 78 => self.evaluate_78(ctx),
155 83 => self.evaluate_83(ctx),
156 84 => self.evaluate_84(ctx),
157 85 => self.evaluate_85(ctx),
158 86 => self.evaluate_86(ctx),
159 87 => self.evaluate_87(ctx),
160 88 => self.evaluate_88(ctx),
161 89 => self.evaluate_89(ctx),
162 90 => self.evaluate_90(ctx),
163 91 => self.evaluate_91(ctx),
164 92 => self.evaluate_92(ctx),
165 93 => self.evaluate_93(ctx),
166 94 => self.evaluate_94(ctx),
167 95 => self.evaluate_95(ctx),
168 96 => self.evaluate_96(ctx),
169 97 => self.evaluate_97(ctx),
170 98 => self.evaluate_98(ctx),
171 99 => self.evaluate_99(ctx),
172 100 => self.evaluate_100(ctx),
173 101 => self.evaluate_101(ctx),
174 102 => self.evaluate_102(ctx),
175 103 => self.evaluate_103(ctx),
176 104 => self.evaluate_104(ctx),
177 105 => self.evaluate_105(ctx),
178 106 => self.evaluate_106(ctx),
179 107 => self.evaluate_107(ctx),
180 108 => self.evaluate_108(ctx),
181 110 => self.evaluate_110(ctx),
182 111 => self.evaluate_111(ctx),
183 112 => self.evaluate_112(ctx),
184 113 => self.evaluate_113(ctx),
185 114 => self.evaluate_114(ctx),
186 115 => self.evaluate_115(ctx),
187 116 => self.evaluate_116(ctx),
188 117 => self.evaluate_117(ctx),
189 118 => self.evaluate_118(ctx),
190 119 => self.evaluate_119(ctx),
191 120 => self.evaluate_120(ctx),
192 121 => self.evaluate_121(ctx),
193 122 => self.evaluate_122(ctx),
194 123 => self.evaluate_123(ctx),
195 124 => self.evaluate_124(ctx),
196 125 => self.evaluate_125(ctx),
197 126 => self.evaluate_126(ctx),
198 127 => self.evaluate_127(ctx),
199 128 => self.evaluate_128(ctx),
200 129 => self.evaluate_129(ctx),
201 130 => self.evaluate_130(ctx),
202 131 => self.evaluate_131(ctx),
203 132 => self.evaluate_132(ctx),
204 133 => self.evaluate_133(ctx),
205 134 => self.evaluate_134(ctx),
206 135 => self.evaluate_135(ctx),
207 136 => self.evaluate_136(ctx),
208 137 => self.evaluate_137(ctx),
209 138 => self.evaluate_138(ctx),
210 139 => self.evaluate_139(ctx),
211 140 => self.evaluate_140(ctx),
212 141 => self.evaluate_141(ctx),
213 142 => self.evaluate_142(ctx),
214 143 => self.evaluate_143(ctx),
215 144 => self.evaluate_144(ctx),
216 145 => self.evaluate_145(ctx),
217 146 => self.evaluate_146(ctx),
218 147 => self.evaluate_147(ctx),
219 148 => self.evaluate_148(ctx),
220 149 => self.evaluate_149(ctx),
221 150 => self.evaluate_150(ctx),
222 151 => self.evaluate_151(ctx),
223 152 => self.evaluate_152(ctx),
224 153 => self.evaluate_153(ctx),
225 156 => self.evaluate_156(ctx),
226 161 => self.evaluate_161(ctx),
227 162 => self.evaluate_162(ctx),
228 163 => self.evaluate_163(ctx),
229 164 => self.evaluate_164(ctx),
230 165 => self.evaluate_165(ctx),
231 166 => self.evaluate_166(ctx),
232 167 => self.evaluate_167(ctx),
233 170 => self.evaluate_170(ctx),
234 172 => self.evaluate_172(ctx),
235 173 => self.evaluate_173(ctx),
236 174 => self.evaluate_174(ctx),
237 175 => self.evaluate_175(ctx),
238 176 => self.evaluate_176(ctx),
239 177 => self.evaluate_177(ctx),
240 178 => self.evaluate_178(ctx),
241 179 => self.evaluate_179(ctx),
242 180 => self.evaluate_180(ctx),
243 184 => self.evaluate_184(ctx),
244 190 => self.evaluate_190(ctx),
245 191 => self.evaluate_191(ctx),
246 192 => self.evaluate_192(ctx),
247 193 => self.evaluate_193(ctx),
248 194 => self.evaluate_194(ctx),
249 195 => self.evaluate_195(ctx),
250 196 => self.evaluate_196(ctx),
251 197 => self.evaluate_197(ctx),
252 198 => self.evaluate_198(ctx),
253 199 => self.evaluate_199(ctx),
254 201 => self.evaluate_201(ctx),
255 202 => self.evaluate_202(ctx),
256 203 => self.evaluate_203(ctx),
257 204 => self.evaluate_204(ctx),
258 205 => self.evaluate_205(ctx),
259 206 => self.evaluate_206(ctx),
260 209 => self.evaluate_209(ctx),
261 210 => self.evaluate_210(ctx),
262 212 => self.evaluate_212(ctx),
263 213 => self.evaluate_213(ctx),
264 215 => self.evaluate_215(ctx),
265 216 => self.evaluate_216(ctx),
266 217 => self.evaluate_217(ctx),
267 219 => self.evaluate_219(ctx),
268 220 => self.evaluate_220(ctx),
269 221 => self.evaluate_221(ctx),
270 223 => self.evaluate_223(ctx),
271 224 => self.evaluate_224(ctx),
272 227 => self.evaluate_227(ctx),
273 229 => self.evaluate_229(ctx),
274 232 => self.evaluate_232(ctx),
275 233 => self.evaluate_233(ctx),
276 234 => self.evaluate_234(ctx),
277 237 => self.evaluate_237(ctx),
278 238 => self.evaluate_238(ctx),
279 239 => self.evaluate_239(ctx),
280 240 => self.evaluate_240(ctx),
281 241 => self.evaluate_241(ctx),
282 243 => self.evaluate_243(ctx),
283 244 => self.evaluate_244(ctx),
284 248 => self.evaluate_248(ctx),
285 249 => self.evaluate_249(ctx),
286 251 => self.evaluate_251(ctx),
287 252 => self.evaluate_252(ctx),
288 254 => self.evaluate_254(ctx),
289 255 => self.evaluate_255(ctx),
290 256 => self.evaluate_256(ctx),
291 257 => self.evaluate_257(ctx),
292 259 => self.evaluate_259(ctx),
293 261 => self.evaluate_261(ctx),
294 262 => self.evaluate_262(ctx),
295 265 => self.evaluate_265(ctx),
296 266 => self.evaluate_266(ctx),
297 267 => self.evaluate_267(ctx),
298 268 => self.evaluate_268(ctx),
299 269 => self.evaluate_269(ctx),
300 270 => self.evaluate_270(ctx),
301 273 => self.evaluate_273(ctx),
302 279 => self.evaluate_279(ctx),
303 280 => self.evaluate_280(ctx),
304 282 => self.evaluate_282(ctx),
305 284 => self.evaluate_284(ctx),
306 285 => self.evaluate_285(ctx),
307 286 => self.evaluate_286(ctx),
308 287 => self.evaluate_287(ctx),
309 288 => self.evaluate_288(ctx),
310 291 => self.evaluate_291(ctx),
311 292 => self.evaluate_292(ctx),
312 293 => self.evaluate_293(ctx),
313 294 => self.evaluate_294(ctx),
314 295 => self.evaluate_295(ctx),
315 296 => self.evaluate_296(ctx),
316 297 => self.evaluate_297(ctx),
317 298 => self.evaluate_298(ctx),
318 299 => self.evaluate_299(ctx),
319 300 => self.evaluate_300(ctx),
320 301 => self.evaluate_301(ctx),
321 302 => self.evaluate_302(ctx),
322 303 => self.evaluate_303(ctx),
323 304 => self.evaluate_304(ctx),
324 305 => self.evaluate_305(ctx),
325 306 => self.evaluate_306(ctx),
326 307 => self.evaluate_307(ctx),
327 309 => self.evaluate_309(ctx),
328 314 => self.evaluate_314(ctx),
329 315 => self.evaluate_315(ctx),
330 316 => self.evaluate_316(ctx),
331 317 => self.evaluate_317(ctx),
332 318 => self.evaluate_318(ctx),
333 321 => self.evaluate_321(ctx),
334 322 => self.evaluate_322(ctx),
335 323 => self.evaluate_323(ctx),
336 327 => self.evaluate_327(ctx),
337 329 => self.evaluate_329(ctx),
338 331 => self.evaluate_331(ctx),
339 332 => self.evaluate_332(ctx),
340 333 => self.evaluate_333(ctx),
341 334 => self.evaluate_334(ctx),
342 335 => self.evaluate_335(ctx),
343 336 => self.evaluate_336(ctx),
344 337 => self.evaluate_337(ctx),
345 338 => self.evaluate_338(ctx),
346 339 => self.evaluate_339(ctx),
347 340 => self.evaluate_340(ctx),
348 341 => self.evaluate_341(ctx),
349 342 => self.evaluate_342(ctx),
350 344 => self.evaluate_344(ctx),
351 345 => self.evaluate_345(ctx),
352 346 => self.evaluate_346(ctx),
353 347 => self.evaluate_347(ctx),
354 348 => self.evaluate_348(ctx),
355 349 => self.evaluate_349(ctx),
356 350 => self.evaluate_350(ctx),
357 351 => self.evaluate_351(ctx),
358 352 => self.evaluate_352(ctx),
359 355 => self.evaluate_355(ctx),
360 356 => self.evaluate_356(ctx),
361 357 => self.evaluate_357(ctx),
362 358 => self.evaluate_358(ctx),
363 359 => self.evaluate_359(ctx),
364 360 => self.evaluate_360(ctx),
365 363 => self.evaluate_363(ctx),
366 365 => self.evaluate_365(ctx),
367 366 => self.evaluate_366(ctx),
368 367 => self.evaluate_367(ctx),
369 368 => self.evaluate_368(ctx),
370 370 => self.evaluate_370(ctx),
371 371 => self.evaluate_371(ctx),
372 372 => self.evaluate_372(ctx),
373 373 => self.evaluate_373(ctx),
374 375 => self.evaluate_375(ctx),
375 376 => self.evaluate_376(ctx),
376 377 => self.evaluate_377(ctx),
377 378 => self.evaluate_378(ctx),
378 379 => self.evaluate_379(ctx),
379 380 => self.evaluate_380(ctx),
380 384 => self.evaluate_384(ctx),
381 386 => self.evaluate_386(ctx),
382 387 => self.evaluate_387(ctx),
383 388 => self.evaluate_388(ctx),
384 391 => self.evaluate_391(ctx),
385 392 => self.evaluate_392(ctx),
386 393 => self.evaluate_393(ctx),
387 394 => self.evaluate_394(ctx),
388 395 => self.evaluate_395(ctx),
389 396 => self.evaluate_396(ctx),
390 397 => self.evaluate_397(ctx),
391 398 => self.evaluate_398(ctx),
392 399 => self.evaluate_399(ctx),
393 401 => self.evaluate_401(ctx),
394 402 => self.evaluate_402(ctx),
395 403 => self.evaluate_403(ctx),
396 404 => self.evaluate_404(ctx),
397 405 => self.evaluate_405(ctx),
398 406 => self.evaluate_406(ctx),
399 407 => self.evaluate_407(ctx),
400 408 => self.evaluate_408(ctx),
401 409 => self.evaluate_409(ctx),
402 410 => self.evaluate_410(ctx),
403 411 => self.evaluate_411(ctx),
404 412 => self.evaluate_412(ctx),
405 413 => self.evaluate_413(ctx),
406 414 => self.evaluate_414(ctx),
407 415 => self.evaluate_415(ctx),
408 416 => self.evaluate_416(ctx),
409 417 => self.evaluate_417(ctx),
410 419 => self.evaluate_419(ctx),
411 420 => self.evaluate_420(ctx),
412 421 => self.evaluate_421(ctx),
413 425 => self.evaluate_425(ctx),
414 426 => self.evaluate_426(ctx),
415 427 => self.evaluate_427(ctx),
416 428 => self.evaluate_428(ctx),
417 429 => self.evaluate_429(ctx),
418 430 => self.evaluate_430(ctx),
419 431 => self.evaluate_431(ctx),
420 432 => self.evaluate_432(ctx),
421 433 => self.evaluate_433(ctx),
422 435 => self.evaluate_435(ctx),
423 436 => self.evaluate_436(ctx),
424 437 => self.evaluate_437(ctx),
425 438 => self.evaluate_438(ctx),
426 440 => self.evaluate_440(ctx),
427 441 => self.evaluate_441(ctx),
428 442 => self.evaluate_442(ctx),
429 444 => self.evaluate_444(ctx),
430 445 => self.evaluate_445(ctx),
431 446 => self.evaluate_446(ctx),
432 447 => self.evaluate_447(ctx),
433 448 => self.evaluate_448(ctx),
434 449 => self.evaluate_449(ctx),
435 450 => self.evaluate_450(ctx),
436 451 => self.evaluate_451(ctx),
437 452 => self.evaluate_452(ctx),
438 453 => self.evaluate_453(ctx),
439 454 => self.evaluate_454(ctx),
440 455 => self.evaluate_455(ctx),
441 456 => self.evaluate_456(ctx),
442 457 => self.evaluate_457(ctx),
443 458 => self.evaluate_458(ctx),
444 459 => self.evaluate_459(ctx),
445 460 => self.evaluate_460(ctx),
446 461 => self.evaluate_461(ctx),
447 462 => self.evaluate_462(ctx),
448 463 => self.evaluate_463(ctx),
449 465 => self.evaluate_465(ctx),
450 466 => self.evaluate_466(ctx),
451 467 => self.evaluate_467(ctx),
452 468 => self.evaluate_468(ctx),
453 469 => self.evaluate_469(ctx),
454 470 => self.evaluate_470(ctx),
455 471 => self.evaluate_471(ctx),
456 472 => self.evaluate_472(ctx),
457 473 => self.evaluate_473(ctx),
458 474 => self.evaluate_474(ctx),
459 475 => self.evaluate_475(ctx),
460 476 => self.evaluate_476(ctx),
461 477 => self.evaluate_477(ctx),
462 478 => self.evaluate_478(ctx),
463 479 => self.evaluate_479(ctx),
464 480 => self.evaluate_480(ctx),
465 481 => self.evaluate_481(ctx),
466 483 => self.evaluate_483(ctx),
467 484 => self.evaluate_484(ctx),
468 487 => self.evaluate_487(ctx),
469 489 => self.evaluate_489(ctx),
470 490 => self.evaluate_490(ctx),
471 491 => self.evaluate_491(ctx),
472 494 => self.evaluate_494(ctx),
473 500 => self.evaluate_500(ctx),
474 501 => self.evaluate_501(ctx),
475 502 => self.evaluate_502(ctx),
476 503 => self.evaluate_503(ctx),
477 504 => self.evaluate_504(ctx),
478 505 => self.evaluate_505(ctx),
479 506 => self.evaluate_506(ctx),
480 507 => self.evaluate_507(ctx),
481 508 => self.evaluate_508(ctx),
482 509 => self.evaluate_509(ctx),
483 510 => self.evaluate_510(ctx),
484 511 => self.evaluate_511(ctx),
485 512 => self.evaluate_512(ctx),
486 513 => self.evaluate_513(ctx),
487 514 => self.evaluate_514(ctx),
488 515 => self.evaluate_515(ctx),
489 516 => self.evaluate_516(ctx),
490 517 => self.evaluate_517(ctx),
491 518 => self.evaluate_518(ctx),
492 519 => self.evaluate_519(ctx),
493 520 => self.evaluate_520(ctx),
494 521 => self.evaluate_521(ctx),
495 522 => self.evaluate_522(ctx),
496 523 => self.evaluate_523(ctx),
497 524 => self.evaluate_524(ctx),
498 525 => self.evaluate_525(ctx),
499 526 => self.evaluate_526(ctx),
500 527 => self.evaluate_527(ctx),
501 528 => self.evaluate_528(ctx),
502 529 => self.evaluate_529(ctx),
503 530 => self.evaluate_530(ctx),
504 531 => self.evaluate_531(ctx),
505 532 => self.evaluate_532(ctx),
506 533 => self.evaluate_533(ctx),
507 555 => self.evaluate_555(ctx),
508 556 => self.evaluate_556(ctx),
509 558 => self.evaluate_558(ctx),
510 559 => self.evaluate_559(ctx),
511 563 => self.evaluate_563(ctx),
512 566 => self.evaluate_566(ctx),
513 567 => self.evaluate_567(ctx),
514 568 => self.evaluate_568(ctx),
515 569 => self.evaluate_569(ctx),
516 570 => self.evaluate_570(ctx),
517 572 => self.evaluate_572(ctx),
518 576 => self.evaluate_576(ctx),
519 577 => self.evaluate_577(ctx),
520 579 => self.evaluate_579(ctx),
521 580 => self.evaluate_580(ctx),
522 581 => self.evaluate_581(ctx),
523 586 => self.evaluate_586(ctx),
524 590 => self.evaluate_590(ctx),
525 594 => self.evaluate_594(ctx),
526 599 => self.evaluate_599(ctx),
527 601 => self.evaluate_601(ctx),
528 606 => self.evaluate_606(ctx),
529 609 => self.evaluate_609(ctx),
530 611 => self.evaluate_611(ctx),
531 614 => self.evaluate_614(ctx),
532 617 => self.evaluate_617(ctx),
533 618 => self.evaluate_618(ctx),
534 619 => self.evaluate_619(ctx),
535 621 => self.evaluate_621(ctx),
536 622 => self.evaluate_622(ctx),
537 623 => self.evaluate_623(ctx),
538 630 => self.evaluate_630(ctx),
539 631 => self.evaluate_631(ctx),
540 632 => self.evaluate_632(ctx),
541 637 => self.evaluate_637(ctx),
542 638 => self.evaluate_638(ctx),
543 639 => self.evaluate_639(ctx),
544 640 => self.evaluate_640(ctx),
545 641 => self.evaluate_641(ctx),
546 642 => self.evaluate_642(ctx),
547 643 => self.evaluate_643(ctx),
548 645 => self.evaluate_645(ctx),
549 646 => self.evaluate_646(ctx),
550 647 => self.evaluate_647(ctx),
551 648 => self.evaluate_648(ctx),
552 651 => self.evaluate_651(ctx),
553 653 => self.evaluate_653(ctx),
554 655 => self.evaluate_655(ctx),
555 659 => self.evaluate_659(ctx),
556 660 => self.evaluate_660(ctx),
557 662 => self.evaluate_662(ctx),
558 663 => self.evaluate_663(ctx),
559 664 => self.evaluate_664(ctx),
560 665 => self.evaluate_665(ctx),
561 667 => self.evaluate_667(ctx),
562 668 => self.evaluate_668(ctx),
563 670 => self.evaluate_670(ctx),
564 671 => self.evaluate_671(ctx),
565 672 => self.evaluate_672(ctx),
566 673 => self.evaluate_673(ctx),
567 674 => self.evaluate_674(ctx),
568 675 => self.evaluate_675(ctx),
569 677 => self.evaluate_677(ctx),
570 678 => self.evaluate_678(ctx),
571 679 => self.evaluate_679(ctx),
572 680 => self.evaluate_680(ctx),
573 682 => self.evaluate_682(ctx),
574 683 => self.evaluate_683(ctx),
575 684 => self.evaluate_684(ctx),
576 685 => self.evaluate_685(ctx),
577 687 => self.evaluate_687(ctx),
578 688 => self.evaluate_688(ctx),
579 689 => self.evaluate_689(ctx),
580 690 => self.evaluate_690(ctx),
581 693 => self.evaluate_693(ctx),
582 694 => self.evaluate_694(ctx),
583 695 => self.evaluate_695(ctx),
584 696 => self.evaluate_696(ctx),
585 698 => self.evaluate_698(ctx),
586 699 => self.evaluate_699(ctx),
587 700 => self.evaluate_700(ctx),
588 704 => self.evaluate_704(ctx),
589 705 => self.evaluate_705(ctx),
590 706 => self.evaluate_706(ctx),
591 707 => self.evaluate_707(ctx),
592 708 => self.evaluate_708(ctx),
593 709 => self.evaluate_709(ctx),
594 710 => self.evaluate_710(ctx),
595 711 => self.evaluate_711(ctx),
596 712 => self.evaluate_712(ctx),
597 713 => self.evaluate_713(ctx),
598 714 => self.evaluate_714(ctx),
599 715 => self.evaluate_715(ctx),
600 716 => self.evaluate_716(ctx),
601 717 => self.evaluate_717(ctx),
602 718 => self.evaluate_718(ctx),
603 719 => self.evaluate_719(ctx),
604 902 => self.evaluate_902(ctx),
605 910 => self.evaluate_910(ctx),
606 914 => self.evaluate_914(ctx),
607 922 => self.evaluate_922(ctx),
608 926 => self.evaluate_926(ctx),
609 930 => self.evaluate_930(ctx),
610 931 => self.evaluate_931(ctx),
611 932 => self.evaluate_932(ctx),
612 933 => self.evaluate_933(ctx),
613 937 => self.evaluate_937(ctx),
614 938 => self.evaluate_938(ctx),
615 939 => self.evaluate_939(ctx),
616 940 => self.evaluate_940(ctx),
617 942 => self.evaluate_942(ctx),
618 943 => self.evaluate_943(ctx),
619 946 => self.evaluate_946(ctx),
620 948 => self.evaluate_948(ctx),
621 950 => self.evaluate_950(ctx),
622 951 => self.evaluate_951(ctx),
623 952 => self.evaluate_952(ctx),
624 955 => self.evaluate_955(ctx),
625 957 => self.evaluate_957(ctx),
626 960 => self.evaluate_960(ctx),
627 961 => self.evaluate_961(ctx),
628 967 => self.evaluate_967(ctx),
629 2001 => self.evaluate_2001(ctx),
630 2002 => self.evaluate_2002(ctx),
631 2003 => self.evaluate_2003(ctx),
632 2004 => self.evaluate_2004(ctx),
633 2005 => self.evaluate_2005(ctx),
634 2006 => self.evaluate_2006(ctx),
635 2007 => self.evaluate_2007(ctx),
636 2008 => self.evaluate_2008(ctx),
637 2009 => self.evaluate_2009(ctx),
638 2010 => self.evaluate_2010(ctx),
639 2011 => self.evaluate_2011(ctx),
640 2012 => self.evaluate_2012(ctx),
641 2013 => self.evaluate_2013(ctx),
642 2014 => self.evaluate_2014(ctx),
643 2015 => self.evaluate_2015(ctx),
644 2016 => self.evaluate_2016(ctx),
645 2017 => self.evaluate_2017(ctx),
646 2018 => self.evaluate_2018(ctx),
647 2060 => self.evaluate_2060(ctx),
648 2061 => self.evaluate_2061(ctx),
649 2071 => self.evaluate_2071(ctx),
650 2073 => self.evaluate_2073(ctx),
651 2075 => self.evaluate_2075(ctx),
652 2080 => self.evaluate_2080(ctx),
653 2095 => self.evaluate_2095(ctx),
654 2096 => self.evaluate_2096(ctx),
655 2119 => self.evaluate_2119(ctx),
656 2140 => self.evaluate_2140(ctx),
657 2182 => self.evaluate_2182(ctx),
658 2183 => self.evaluate_2183(ctx),
659 2207 => self.evaluate_2207(ctx),
660 2225 => self.evaluate_2225(ctx),
661 2236 => self.evaluate_2236(ctx),
662 2252 => self.evaluate_2252(ctx),
663 2261 => self.evaluate_2261(ctx),
664 2284 => self.evaluate_2284(ctx),
665 2286 => self.evaluate_2286(ctx),
666 2287 => self.evaluate_2287(ctx),
667 2288 => self.evaluate_2288(ctx),
668 2307 => self.evaluate_2307(ctx),
669 2308 => self.evaluate_2308(ctx),
670 2309 => self.evaluate_2309(ctx),
671 2310 => self.evaluate_2310(ctx),
672 2311 => self.evaluate_2311(ctx),
673 2312 => self.evaluate_2312(ctx),
674 2313 => self.evaluate_2313(ctx),
675 2317 => self.evaluate_2317(ctx),
676 2318 => self.evaluate_2318(ctx),
677 2344 => self.evaluate_2344(ctx),
678 2350 => self.evaluate_2350(ctx),
679 2351 => self.evaluate_2351(ctx),
680 2352 => self.evaluate_2352(ctx),
681 2356 => self.evaluate_2356(ctx),
682 2357 => self.evaluate_2357(ctx),
683 2358 => self.evaluate_2358(ctx),
684 2359 => self.evaluate_2359(ctx),
685 2360 => self.evaluate_2360(ctx),
686 2361 => self.evaluate_2361(ctx),
687 _ => ConditionResult::Unknown,
688 }
689 }
690
691 fn is_external(&self, condition: u32) -> bool {
692 self.external_conditions.contains(&condition)
693 }
694 fn is_known(&self, condition: u32) -> bool {
695 matches!(
696 condition,
697 1 | 4
698 | 5
699 | 6
700 | 7
701 | 8
702 | 9
703 | 10
704 | 11
705 | 12
706 | 13
707 | 14
708 | 15
709 | 16
710 | 17
711 | 18
712 | 19
713 | 20
714 | 21
715 | 22
716 | 23
717 | 24
718 | 25
719 | 27
720 | 30
721 | 31
722 | 32
723 | 33
724 | 34
725 | 35
726 | 36
727 | 37
728 | 38
729 | 39
730 | 40
731 | 41
732 | 42
733 | 43
734 | 44
735 | 45
736 | 46
737 | 47
738 | 48
739 | 49
740 | 50
741 | 51
742 | 52
743 | 53
744 | 54
745 | 55
746 | 56
747 | 57
748 | 58
749 | 60
750 | 61
751 | 62
752 | 63
753 | 64
754 | 65
755 | 66
756 | 67
757 | 68
758 | 69
759 | 70
760 | 71
761 | 72
762 | 73
763 | 74
764 | 75
765 | 76
766 | 77
767 | 78
768 | 83
769 | 84
770 | 85
771 | 86
772 | 87
773 | 88
774 | 89
775 | 90
776 | 91
777 | 92
778 | 93
779 | 94
780 | 95
781 | 96
782 | 97
783 | 98
784 | 99
785 | 100
786 | 101
787 | 102
788 | 103
789 | 104
790 | 105
791 | 106
792 | 107
793 | 108
794 | 110
795 | 111
796 | 112
797 | 113
798 | 114
799 | 115
800 | 116
801 | 117
802 | 118
803 | 119
804 | 120
805 | 121
806 | 122
807 | 123
808 | 124
809 | 125
810 | 126
811 | 127
812 | 128
813 | 129
814 | 130
815 | 131
816 | 132
817 | 133
818 | 134
819 | 135
820 | 136
821 | 137
822 | 138
823 | 139
824 | 140
825 | 141
826 | 142
827 | 143
828 | 144
829 | 145
830 | 146
831 | 147
832 | 148
833 | 149
834 | 150
835 | 151
836 | 152
837 | 153
838 | 156
839 | 161
840 | 162
841 | 163
842 | 164
843 | 165
844 | 166
845 | 167
846 | 170
847 | 172
848 | 173
849 | 174
850 | 175
851 | 176
852 | 177
853 | 178
854 | 179
855 | 180
856 | 184
857 | 190
858 | 191
859 | 192
860 | 193
861 | 194
862 | 195
863 | 196
864 | 197
865 | 198
866 | 199
867 | 201
868 | 202
869 | 203
870 | 204
871 | 205
872 | 206
873 | 209
874 | 210
875 | 212
876 | 213
877 | 215
878 | 216
879 | 217
880 | 219
881 | 220
882 | 221
883 | 223
884 | 224
885 | 227
886 | 229
887 | 232
888 | 233
889 | 234
890 | 237
891 | 238
892 | 239
893 | 240
894 | 241
895 | 243
896 | 244
897 | 248
898 | 249
899 | 251
900 | 252
901 | 254
902 | 255
903 | 256
904 | 257
905 | 259
906 | 261
907 | 262
908 | 265
909 | 266
910 | 267
911 | 268
912 | 269
913 | 270
914 | 273
915 | 279
916 | 280
917 | 282
918 | 284
919 | 285
920 | 286
921 | 287
922 | 288
923 | 291
924 | 292
925 | 293
926 | 294
927 | 295
928 | 296
929 | 297
930 | 298
931 | 299
932 | 300
933 | 301
934 | 302
935 | 303
936 | 304
937 | 305
938 | 306
939 | 307
940 | 309
941 | 314
942 | 315
943 | 316
944 | 317
945 | 318
946 | 321
947 | 322
948 | 323
949 | 327
950 | 329
951 | 331
952 | 332
953 | 333
954 | 334
955 | 335
956 | 336
957 | 337
958 | 338
959 | 339
960 | 340
961 | 341
962 | 342
963 | 344
964 | 345
965 | 346
966 | 347
967 | 348
968 | 349
969 | 350
970 | 351
971 | 352
972 | 355
973 | 356
974 | 357
975 | 358
976 | 359
977 | 360
978 | 363
979 | 365
980 | 366
981 | 367
982 | 368
983 | 370
984 | 371
985 | 372
986 | 373
987 | 375
988 | 376
989 | 377
990 | 378
991 | 379
992 | 380
993 | 384
994 | 386
995 | 387
996 | 388
997 | 391
998 | 392
999 | 393
1000 | 394
1001 | 395
1002 | 396
1003 | 397
1004 | 398
1005 | 399
1006 | 401
1007 | 402
1008 | 403
1009 | 404
1010 | 405
1011 | 406
1012 | 407
1013 | 408
1014 | 409
1015 | 410
1016 | 411
1017 | 412
1018 | 413
1019 | 414
1020 | 415
1021 | 416
1022 | 417
1023 | 419
1024 | 420
1025 | 421
1026 | 425
1027 | 426
1028 | 427
1029 | 428
1030 | 429
1031 | 430
1032 | 431
1033 | 432
1034 | 433
1035 | 435
1036 | 436
1037 | 437
1038 | 438
1039 | 440
1040 | 441
1041 | 442
1042 | 444
1043 | 445
1044 | 446
1045 | 447
1046 | 448
1047 | 449
1048 | 450
1049 | 451
1050 | 452
1051 | 453
1052 | 454
1053 | 455
1054 | 456
1055 | 457
1056 | 458
1057 | 459
1058 | 460
1059 | 461
1060 | 462
1061 | 463
1062 | 465
1063 | 466
1064 | 467
1065 | 468
1066 | 469
1067 | 470
1068 | 471
1069 | 472
1070 | 473
1071 | 474
1072 | 475
1073 | 476
1074 | 477
1075 | 478
1076 | 479
1077 | 480
1078 | 481
1079 | 483
1080 | 484
1081 | 487
1082 | 489
1083 | 490
1084 | 491
1085 | 494
1086 | 500
1087 | 501
1088 | 502
1089 | 503
1090 | 504
1091 | 505
1092 | 506
1093 | 507
1094 | 508
1095 | 509
1096 | 510
1097 | 511
1098 | 512
1099 | 513
1100 | 514
1101 | 515
1102 | 516
1103 | 517
1104 | 518
1105 | 519
1106 | 520
1107 | 521
1108 | 522
1109 | 523
1110 | 524
1111 | 525
1112 | 526
1113 | 527
1114 | 528
1115 | 529
1116 | 530
1117 | 531
1118 | 532
1119 | 533
1120 | 555
1121 | 556
1122 | 558
1123 | 559
1124 | 563
1125 | 566
1126 | 567
1127 | 568
1128 | 569
1129 | 570
1130 | 572
1131 | 576
1132 | 577
1133 | 579
1134 | 580
1135 | 581
1136 | 586
1137 | 590
1138 | 594
1139 | 599
1140 | 601
1141 | 606
1142 | 609
1143 | 611
1144 | 614
1145 | 617
1146 | 618
1147 | 619
1148 | 621
1149 | 622
1150 | 623
1151 | 630
1152 | 631
1153 | 632
1154 | 637
1155 | 638
1156 | 639
1157 | 640
1158 | 641
1159 | 642
1160 | 643
1161 | 645
1162 | 646
1163 | 647
1164 | 648
1165 | 651
1166 | 653
1167 | 655
1168 | 659
1169 | 660
1170 | 662
1171 | 663
1172 | 664
1173 | 665
1174 | 667
1175 | 668
1176 | 670
1177 | 671
1178 | 672
1179 | 673
1180 | 674
1181 | 675
1182 | 677
1183 | 678
1184 | 679
1185 | 680
1186 | 682
1187 | 683
1188 | 684
1189 | 685
1190 | 687
1191 | 688
1192 | 689
1193 | 690
1194 | 693
1195 | 694
1196 | 695
1197 | 696
1198 | 698
1199 | 699
1200 | 700
1201 | 704
1202 | 705
1203 | 706
1204 | 707
1205 | 708
1206 | 709
1207 | 710
1208 | 711
1209 | 712
1210 | 713
1211 | 714
1212 | 715
1213 | 716
1214 | 717
1215 | 718
1216 | 719
1217 | 902
1218 | 910
1219 | 914
1220 | 922
1221 | 926
1222 | 930
1223 | 931
1224 | 932
1225 | 933
1226 | 937
1227 | 938
1228 | 939
1229 | 940
1230 | 942
1231 | 943
1232 | 946
1233 | 948
1234 | 950
1235 | 951
1236 | 952
1237 | 955
1238 | 957
1239 | 960
1240 | 961
1241 | 967
1242 | 2001
1243 | 2002
1244 | 2003
1245 | 2004
1246 | 2005
1247 | 2006
1248 | 2007
1249 | 2008
1250 | 2009
1251 | 2010
1252 | 2011
1253 | 2012
1254 | 2013
1255 | 2014
1256 | 2015
1257 | 2016
1258 | 2017
1259 | 2018
1260 | 2060
1261 | 2061
1262 | 2071
1263 | 2073
1264 | 2075
1265 | 2080
1266 | 2095
1267 | 2096
1268 | 2119
1269 | 2140
1270 | 2182
1271 | 2183
1272 | 2207
1273 | 2225
1274 | 2236
1275 | 2252
1276 | 2261
1277 | 2284
1278 | 2286
1279 | 2287
1280 | 2288
1281 | 2307
1282 | 2308
1283 | 2309
1284 | 2310
1285 | 2311
1286 | 2312
1287 | 2313
1288 | 2317
1289 | 2318
1290 | 2344
1291 | 2350
1292 | 2351
1293 | 2352
1294 | 2356
1295 | 2357
1296 | 2358
1297 | 2359
1298 | 2360
1299 | 2361
1300 )
1301 }
1302}
1303
1304impl UtilmdStromConditionEvaluatorFV2504 {
1305 fn evaluate_2006(&self, ctx: &EvaluationContext) -> ConditionResult {
1308 let nav = match ctx.navigator() {
1309 Some(n) => n,
1310 None => return ConditionResult::Unknown,
1311 };
1312 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1313 let mut qualifying_zeitraum_ids: Vec<String> = Vec::new();
1314 for i in 0..sg8_count {
1315 let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1316 let is_z01 = seq_segs.iter().any(|s| {
1317 s.elements
1318 .first()
1319 .and_then(|e| e.first())
1320 .is_some_and(|v| v == "Z01")
1321 });
1322 if is_z01 && matches!(self.evaluate(199, ctx), ConditionResult::True) {
1323 for seq in &seq_segs {
1324 if seq
1325 .elements
1326 .first()
1327 .and_then(|e| e.first())
1328 .is_some_and(|v| v == "Z01")
1329 {
1330 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1331 if !zid.is_empty() {
1332 qualifying_zeitraum_ids.push(zid.clone());
1333 }
1334 }
1335 }
1336 }
1337 }
1338 }
1339 if qualifying_zeitraum_ids.is_empty() {
1340 return ConditionResult::Unknown;
1341 }
1342 ConditionResult::True
1343 }
1344
1345 fn evaluate_2007(&self, ctx: &EvaluationContext) -> ConditionResult {
1348 let nav = match ctx.navigator() {
1349 Some(n) => n,
1350 None => return ConditionResult::Unknown,
1351 };
1352 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1353 let mut qualifying_zeitraum_ids: Vec<String> = Vec::new();
1354 for i in 0..sg8_count {
1355 let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1356 let is_z01 = seq_segs.iter().any(|s| {
1357 s.elements
1358 .first()
1359 .and_then(|e| e.first())
1360 .is_some_and(|v| v == "Z01")
1361 });
1362 if is_z01 && matches!(self.evaluate(199, ctx), ConditionResult::True) {
1363 for seq in &seq_segs {
1364 if seq
1365 .elements
1366 .first()
1367 .and_then(|e| e.first())
1368 .is_some_and(|v| v == "Z01")
1369 {
1370 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1371 if !zid.is_empty() {
1372 qualifying_zeitraum_ids.push(zid.clone());
1373 }
1374 }
1375 }
1376 }
1377 }
1378 }
1379 if qualifying_zeitraum_ids.is_empty() {
1380 return ConditionResult::Unknown;
1381 }
1382 ConditionResult::True
1383 }
1384
1385 fn evaluate_2008(&self, ctx: &EvaluationContext) -> ConditionResult {
1388 let nav = match ctx.navigator() {
1389 Some(n) => n,
1390 None => return ConditionResult::Unknown,
1391 };
1392 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1393 let mut qualifying_zeitraum_ids: Vec<String> = Vec::new();
1394 for i in 0..sg8_count {
1395 let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1396 let is_z01 = seq_segs.iter().any(|s| {
1397 s.elements
1398 .first()
1399 .and_then(|e| e.first())
1400 .is_some_and(|v| v == "Z01")
1401 });
1402 if is_z01 && matches!(self.evaluate(89, ctx), ConditionResult::True) {
1403 for seq in &seq_segs {
1404 if seq
1405 .elements
1406 .first()
1407 .and_then(|e| e.first())
1408 .is_some_and(|v| v == "Z01")
1409 {
1410 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1411 if !zid.is_empty() {
1412 qualifying_zeitraum_ids.push(zid.clone());
1413 }
1414 }
1415 }
1416 }
1417 }
1418 }
1419 if qualifying_zeitraum_ids.is_empty() {
1420 return ConditionResult::Unknown;
1421 }
1422 ConditionResult::True
1423 }
1424
1425 fn evaluate_2009(&self, ctx: &EvaluationContext) -> ConditionResult {
1428 let nav = match ctx.navigator() {
1429 Some(n) => n,
1430 None => return ConditionResult::Unknown,
1431 };
1432 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1433 let mut qualifying_zeitraum_ids: Vec<String> = Vec::new();
1434 for i in 0..sg8_count {
1435 let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
1436 let is_z01 = seq_segs.iter().any(|s| {
1437 s.elements
1438 .first()
1439 .and_then(|e| e.first())
1440 .is_some_and(|v| v == "Z01")
1441 });
1442 if is_z01 && matches!(self.evaluate(89, ctx), ConditionResult::True) {
1443 for seq in &seq_segs {
1444 if seq
1445 .elements
1446 .first()
1447 .and_then(|e| e.first())
1448 .is_some_and(|v| v == "Z01")
1449 {
1450 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
1451 if !zid.is_empty() {
1452 qualifying_zeitraum_ids.push(zid.clone());
1453 }
1454 }
1455 }
1456 }
1457 }
1458 }
1459 if qualifying_zeitraum_ids.is_empty() {
1460 return ConditionResult::Unknown;
1461 }
1462 ConditionResult::True
1463 }
1464
1465 fn evaluate_1(&self, ctx: &EvaluationContext) -> ConditionResult {
1467 ctx.external.evaluate("message_splitting")
1468 }
1469
1470 fn evaluate_4(&self, ctx: &EvaluationContext) -> ConditionResult {
1472 ctx.external.evaluate("recipient_is_lf")
1473 }
1474
1475 fn evaluate_5(&self, ctx: &EvaluationContext) -> ConditionResult {
1477 ctx.external.evaluate("sender_is_lf")
1478 }
1479
1480 fn evaluate_6(&self, ctx: &EvaluationContext) -> ConditionResult {
1482 ctx.external.evaluate("recipient_role_check")
1483 }
1484
1485 fn evaluate_7(&self, ctx: &EvaluationContext) -> ConditionResult {
1487 let sts_segs = ctx.find_segments("STS");
1488 let found = sts_segs.iter().any(|s| {
1489 s.elements
1490 .first()
1491 .and_then(|e| e.first())
1492 .is_some_and(|v| v == "7")
1493 && s.elements
1494 .get(2)
1495 .and_then(|e| e.first())
1496 .is_some_and(|v| ["ZG9", "ZH1", "ZH2"].contains(&v.as_str()))
1497 });
1498 ConditionResult::from(found)
1499 }
1500
1501 fn evaluate_8(&self, ctx: &EvaluationContext) -> ConditionResult {
1503 ctx.external.evaluate("data_clearing_required")
1504 }
1505
1506 fn evaluate_9(&self, ctx: &EvaluationContext) -> ConditionResult {
1508 ctx.external.evaluate("sender_role_check")
1509 }
1510
1511 fn evaluate_10(&self, ctx: &EvaluationContext) -> ConditionResult {
1513 ctx.has_qualified_value("STS", 0, "7", 4, 0, &["E01", "E03"])
1515 }
1516
1517 fn evaluate_11(&self, ctx: &EvaluationContext) -> ConditionResult {
1519 let sts_segs = ctx.find_segments("STS");
1520 let found = sts_segs.iter().any(|s| {
1521 s.elements
1522 .first()
1523 .and_then(|e| e.first())
1524 .is_some_and(|v| v == "7")
1525 && s.elements
1526 .get(2)
1527 .and_then(|e| e.first())
1528 .is_some_and(|v| ["ZG9", "ZH1", "ZH2"].contains(&v.as_str()))
1529 });
1530 ConditionResult::from(!found)
1531 }
1532
1533 fn evaluate_12(&self, ctx: &EvaluationContext) -> ConditionResult {
1535 let dtm_segs = ctx.find_segments("DTM");
1536 let found = dtm_segs.iter().any(|s| {
1537 s.elements
1538 .first()
1539 .and_then(|e| e.first())
1540 .is_some_and(|v| v == "471")
1541 });
1542 ConditionResult::from(!found)
1543 }
1544
1545 fn evaluate_13(&self, ctx: &EvaluationContext) -> ConditionResult {
1547 let sts_segs = ctx.find_segments("STS");
1548 let found = sts_segs.iter().any(|s| {
1549 s.elements
1550 .first()
1551 .and_then(|e| e.first())
1552 .is_some_and(|v| v == "E01")
1553 && s.elements
1554 .get(2)
1555 .and_then(|e| e.first())
1556 .is_some_and(|v| ["Z01"].contains(&v.as_str()))
1557 });
1558 ConditionResult::from(!found)
1559 }
1560
1561 fn evaluate_14(&self, ctx: &EvaluationContext) -> ConditionResult {
1563 ctx.external.evaluate("date_known")
1564 }
1565
1566 fn evaluate_15(&self, ctx: &EvaluationContext) -> ConditionResult {
1568 let seq_segs = ctx.scoped_find_segments_in("SG8", "SEQ");
1570 let found = seq_segs.iter().any(|s| {
1571 s.elements
1572 .first()
1573 .and_then(|e| e.first())
1574 .is_some_and(|v| ["Z98"].contains(&v.as_str()))
1575 });
1576 ConditionResult::from(found)
1577 }
1578
1579 fn evaluate_16(&self, ctx: &EvaluationContext) -> ConditionResult {
1581 let sts_segs = ctx.find_segments("STS");
1582 let found = sts_segs.iter().any(|s| {
1583 s.elements
1584 .first()
1585 .and_then(|e| e.first())
1586 .is_some_and(|v| v == "E01")
1587 && s.elements
1588 .get(2)
1589 .and_then(|e| e.first())
1590 .is_some_and(|v| ["Z12"].contains(&v.as_str()))
1591 });
1592 ConditionResult::from(found)
1593 }
1594
1595 fn evaluate_17(&self, ctx: &EvaluationContext) -> ConditionResult {
1597 let seq_segs = ctx.scoped_find_segments_in("SG8", "SEQ");
1599 let found = seq_segs.iter().any(|s| {
1600 s.elements
1601 .first()
1602 .and_then(|e| e.first())
1603 .is_some_and(|v| ["Z01", "Z80", "Z81"].contains(&v.as_str()))
1604 });
1605 ConditionResult::from(found)
1606 }
1607
1608 fn evaluate_18(&self, ctx: &EvaluationContext) -> ConditionResult {
1610 let dtm_segs = ctx.find_segments("DTM");
1611 let found = dtm_segs.iter().any(|s| {
1612 s.elements
1613 .first()
1614 .and_then(|e| e.first())
1615 .is_some_and(|v| v == "93")
1616 });
1617 ConditionResult::from(!found)
1618 }
1619
1620 fn evaluate_19(&self, ctx: &EvaluationContext) -> ConditionResult {
1622 let seq_segs = ctx.find_segments("SEQ");
1623 let found = seq_segs.iter().any(|s| {
1624 s.elements
1625 .first()
1626 .and_then(|e| e.first())
1627 .is_some_and(|v| ["Z01", "Z98"].contains(&v.as_str()))
1628 });
1629 ConditionResult::from(found)
1630 }
1631
1632 fn evaluate_20(&self, ctx: &EvaluationContext) -> ConditionResult {
1634 let seq_segs = ctx.find_segments("SEQ");
1635 let found = seq_segs.iter().any(|s| {
1636 s.elements
1637 .first()
1638 .and_then(|e| e.first())
1639 .is_some_and(|v| ["Z01"].contains(&v.as_str()))
1640 });
1641 ConditionResult::from(found)
1642 }
1643
1644 fn evaluate_21(&self, ctx: &EvaluationContext) -> ConditionResult {
1646 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
1648 let found = cci_segs.iter().any(|s| {
1649 s.elements
1650 .get(2)
1651 .and_then(|e| e.first())
1652 .is_some_and(|v| v == "ZA6")
1653 });
1654 ConditionResult::from(found)
1655 }
1656
1657 fn evaluate_22(&self, ctx: &EvaluationContext) -> ConditionResult {
1660 for qual in &["Z47", "Z48", "Z49"] {
1661 if matches!(
1662 ctx.groups_share_qualified_value(
1663 "RFF",
1664 0,
1665 qual,
1666 0,
1667 2,
1668 &["SG4", "SG6"],
1669 "SEQ",
1670 1,
1671 0,
1672 &["SG4", "SG8"],
1673 ),
1674 ConditionResult::True
1675 ) {
1676 return ConditionResult::True;
1677 }
1678 }
1679 ConditionResult::False
1680 }
1681
1682 fn evaluate_23(&self, ctx: &EvaluationContext) -> ConditionResult {
1684 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
1686 let found = sts_segs.iter().any(|s| {
1687 s.elements
1688 .first()
1689 .and_then(|e| e.first())
1690 .is_some_and(|v| v == "E01")
1691 && s.elements
1692 .get(2)
1693 .and_then(|e| e.first())
1694 .is_some_and(|v| ["A05", "A99"].contains(&v.as_str()))
1695 });
1696 ConditionResult::from(found)
1697 }
1698
1699 fn evaluate_24(&self, ctx: &EvaluationContext) -> ConditionResult {
1701 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
1703 let found = sts_segs.iter().any(|s| {
1704 s.elements
1705 .first()
1706 .and_then(|e| e.first())
1707 .is_some_and(|v| v == "E01")
1708 && s.elements
1709 .get(2)
1710 .and_then(|e| e.first())
1711 .is_some_and(|v| ["A25", "A99"].contains(&v.as_str()))
1712 });
1713 ConditionResult::from(found)
1714 }
1715
1716 fn evaluate_25(&self, _ctx: &EvaluationContext) -> ConditionResult {
1718 ConditionResult::Unknown
1720 }
1721
1722 fn evaluate_27(&self, ctx: &EvaluationContext) -> ConditionResult {
1724 let dtm_segs = ctx.find_segments("DTM");
1725 let found = dtm_segs.iter().any(|s| {
1726 s.elements
1727 .first()
1728 .and_then(|e| e.first())
1729 .is_some_and(|v| v == "Z01")
1730 && s.elements
1731 .first()
1732 .and_then(|e| e.get(1))
1733 .is_some_and(|v| v.chars().nth(3).is_some_and(|c| ['T', 'R'].contains(&c)))
1734 });
1735 ConditionResult::from(found)
1736 }
1737
1738 fn evaluate_30(&self, ctx: &EvaluationContext) -> ConditionResult {
1740 ctx.external.evaluate("activation_response")
1742 }
1743
1744 fn evaluate_31(&self, ctx: &EvaluationContext) -> ConditionResult {
1746 ctx.external.evaluate("correction_in_progress")
1747 }
1748
1749 fn evaluate_32(&self, ctx: &EvaluationContext) -> ConditionResult {
1751 let seq_segs = ctx.find_segments("SEQ");
1752 ConditionResult::from(seq_segs.len() > 1)
1753 }
1754
1755 fn evaluate_33(&self, ctx: &EvaluationContext) -> ConditionResult {
1757 ctx.external.evaluate("code_list_membership_check")
1758 }
1759
1760 fn evaluate_34(&self, ctx: &EvaluationContext) -> ConditionResult {
1762 ctx.external.evaluate("deactivation_response")
1764 }
1765
1766 fn evaluate_35(&self, ctx: &EvaluationContext) -> ConditionResult {
1768 let dtm_segs = ctx.find_segments("DTM");
1769 let found = dtm_segs.iter().any(|s| {
1770 s.elements
1771 .first()
1772 .and_then(|e| e.first())
1773 .is_some_and(|v| v == "Z01")
1774 && s.elements
1775 .first()
1776 .and_then(|e| e.get(1))
1777 .is_some_and(|v| v.chars().nth(3).is_some_and(|c| c == 'T'))
1778 });
1779 ConditionResult::from(found)
1780 }
1781
1782 fn evaluate_36(&self, ctx: &EvaluationContext) -> ConditionResult {
1784 ctx.external.evaluate("code_list_membership_check")
1785 }
1786
1787 fn evaluate_37(&self, ctx: &EvaluationContext) -> ConditionResult {
1789 ctx.has_qualified_value("STS", 0, "7", 4, 0, &["E01", "E03"])
1791 }
1792
1793 fn evaluate_38(&self, ctx: &EvaluationContext) -> ConditionResult {
1795 ctx.external.evaluate("code_list_membership_check")
1796 }
1797
1798 fn evaluate_39(&self, ctx: &EvaluationContext) -> ConditionResult {
1800 ctx.external.evaluate("code_list_membership_check")
1801 }
1802
1803 fn evaluate_40(&self, ctx: &EvaluationContext) -> ConditionResult {
1805 ctx.external.evaluate("code_list_membership_check")
1806 }
1807
1808 fn evaluate_41(&self, ctx: &EvaluationContext) -> ConditionResult {
1810 let seq_z79 = ctx.find_segments_with_qualifier("SEQ", 0, "Z79");
1812 if seq_z79.is_empty() {
1813 return ConditionResult::Unknown;
1814 }
1815 let found = seq_z79.iter().any(|s| {
1817 s.elements
1818 .get(1)
1819 .and_then(|e| e.first())
1820 .is_some_and(|v| !v.is_empty())
1821 });
1822 ConditionResult::from(found)
1823 }
1824
1825 fn evaluate_42(&self, ctx: &EvaluationContext) -> ConditionResult {
1827 let seq_segs = ctx.find_segments("SEQ");
1828 let zh0_count = seq_segs
1829 .iter()
1830 .filter(|s| {
1831 s.elements
1832 .first()
1833 .and_then(|e| e.first())
1834 .is_some_and(|v| v == "ZH0")
1835 })
1836 .count();
1837 ConditionResult::from(zh0_count > 1)
1838 }
1839
1840 fn evaluate_43(&self, ctx: &EvaluationContext) -> ConditionResult {
1842 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
1844 let found = sts_segs.iter().any(|s| {
1845 s.elements
1846 .first()
1847 .and_then(|e| e.first())
1848 .is_some_and(|v| v == "E01")
1849 && s.elements
1850 .get(2)
1851 .and_then(|e| e.first())
1852 .is_some_and(|v| ["A12", "A13"].contains(&v.as_str()))
1853 });
1854 ConditionResult::from(found)
1855 }
1856
1857 fn evaluate_44(&self, _ctx: &EvaluationContext) -> ConditionResult {
1859 ConditionResult::True
1861 }
1862
1863 fn evaluate_45(&self, ctx: &EvaluationContext) -> ConditionResult {
1865 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
1867 let found = cci_segs.iter().any(|s| {
1868 s.elements
1869 .first()
1870 .and_then(|e| e.first())
1871 .is_some_and(|v| v == "Z01")
1872 && s.elements
1873 .get(2)
1874 .and_then(|e| e.first())
1875 .is_some_and(|v| v == "Z82")
1876 });
1877 ConditionResult::from(found)
1878 }
1879
1880 fn evaluate_46(&self, _ctx: &EvaluationContext) -> ConditionResult {
1882 ConditionResult::Unknown
1884 }
1885
1886 fn evaluate_47(&self, ctx: &EvaluationContext) -> ConditionResult {
1889 const CODES: &[&str] = &[
1890 "DBA", "VZR", "EGS", "LGS", "SLS", "SES", "TLS", "TES", "BIL", "BIP", "BIT", "GAL",
1891 "GAP", "GAT", "GEL", "GEP", "GET", "SOL", "SOP", "SOT", "WFL", "WFP", "WFT", "WNL",
1892 "WNP", "WNT",
1893 ];
1894 let nav = match ctx.navigator {
1895 Some(n) => n,
1896 None => return ConditionResult::Unknown,
1897 };
1898 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
1899 for i in 0..sg8_count {
1900 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
1901 for j in 0..sg10_count {
1902 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
1903 let has_cci_15_z21 = ccis.iter().any(|s| {
1904 s.elements
1905 .first()
1906 .and_then(|e: &Vec<String>| e.first())
1907 .is_some_and(|v: &String| v == "15")
1908 && s.elements
1909 .get(2)
1910 .and_then(|e: &Vec<String>| e.first())
1911 .is_some_and(|v: &String| v == "Z21")
1912 });
1913 if has_cci_15_z21 {
1914 let cavs =
1915 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
1916 if cavs.iter().any(|s| {
1917 s.elements
1918 .first()
1919 .and_then(|e: &Vec<String>| e.first())
1920 .is_some_and(|v: &String| CODES.contains(&v.as_str()))
1921 }) {
1922 return ConditionResult::True;
1923 }
1924 }
1925 }
1926 }
1927 ConditionResult::False
1928 }
1929
1930 fn evaluate_48(&self, ctx: &EvaluationContext) -> ConditionResult {
1932 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
1934 let found = sts_segs.iter().any(|s| {
1935 s.elements
1936 .first()
1937 .and_then(|e| e.first())
1938 .is_some_and(|v| v == "E01")
1939 && s.elements
1940 .get(2)
1941 .and_then(|e| e.first())
1942 .is_some_and(|v| ["A99"].contains(&v.as_str()))
1943 });
1944 ConditionResult::from(found)
1945 }
1946
1947 fn evaluate_49(&self, ctx: &EvaluationContext) -> ConditionResult {
1949 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
1951 let found = sts_segs.iter().any(|s| {
1952 s.elements
1953 .first()
1954 .and_then(|e| e.first())
1955 .is_some_and(|v| v == "E01")
1956 && s.elements
1957 .get(2)
1958 .and_then(|e| e.first())
1959 .is_some_and(|v| ["E14"].contains(&v.as_str()))
1960 });
1961 ConditionResult::from(found)
1962 }
1963
1964 fn evaluate_50(&self, ctx: &EvaluationContext) -> ConditionResult {
1967 use std::collections::HashMap;
1968
1969 let seq_quals = ctx.collect_group_values("SEQ", 0, 0, &["SG4", "SG8"]);
1970 let seq_zeitraum = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
1971 let rff_quals = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG8"]);
1972 let rff_ids = ctx.collect_group_values("RFF", 0, 1, &["SG4", "SG8"]);
1973
1974 let mut rff_by_instance: HashMap<usize, Vec<(String, String)>> = HashMap::new();
1976 for ((idx, q), (_, id)) in rff_quals.iter().zip(rff_ids.iter()) {
1977 rff_by_instance
1978 .entry(*idx)
1979 .or_default()
1980 .push((q.clone(), id.clone()));
1981 }
1982
1983 let mut seq_zeitraum_map: HashMap<usize, String> = HashMap::new();
1985 for (idx, z) in &seq_zeitraum {
1986 seq_zeitraum_map.insert(*idx, z.clone());
1987 }
1988
1989 let z98_data: Vec<(String, String)> = seq_quals
1990 .iter()
1991 .filter(|(_, q)| q == "Z98")
1992 .map(|(idx, _)| {
1993 let zeitraum = seq_zeitraum_map.get(idx).cloned().unwrap_or_default();
1994 let marktlok = rff_by_instance
1995 .get(idx)
1996 .and_then(|rffs| rffs.iter().find(|(q, _)| q == "Z18"))
1997 .map(|(_, id)| id.clone())
1998 .unwrap_or_default();
1999 (zeitraum, marktlok)
2000 })
2001 .collect();
2002
2003 if z98_data.is_empty() {
2004 return ConditionResult::Unknown;
2005 }
2006
2007 let ze7_data: Vec<(String, String)> = seq_quals
2008 .iter()
2009 .filter(|(_, q)| q == "ZE7")
2010 .map(|(idx, _)| {
2011 let zeitraum = seq_zeitraum_map.get(idx).cloned().unwrap_or_default();
2012 let marktlok = rff_by_instance
2013 .get(idx)
2014 .and_then(|rffs| rffs.iter().find(|(q, _)| q == "Z18"))
2015 .map(|(_, id)| id.clone())
2016 .unwrap_or_default();
2017 (zeitraum, marktlok)
2018 })
2019 .collect();
2020
2021 ConditionResult::from(z98_data.iter().any(|(z98_zeit, z98_lok)| {
2022 !ze7_data
2023 .iter()
2024 .any(|(ze7_zeit, ze7_lok)| ze7_zeit == z98_zeit && ze7_lok == z98_lok)
2025 }))
2026 }
2027
2028 fn evaluate_51(&self, ctx: &EvaluationContext) -> ConditionResult {
2031 let nav = match ctx.navigator() {
2032 Some(n) => n,
2033 None => return ConditionResult::Unknown,
2034 };
2035 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
2036 let pauschal_id = "9992000000018";
2037 let mut pauschal_zeitraum_ids: Vec<String> = Vec::new();
2039 for i in 0..sg8_count {
2040 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
2041 let has_z78 = seqs.iter().any(|s| {
2042 s.elements
2043 .first()
2044 .and_then(|e| e.first())
2045 .is_some_and(|v| v == "Z78")
2046 });
2047 if !has_z78 {
2048 continue;
2049 }
2050 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
2051 let has_pauschal = rffs.iter().any(|s| {
2052 s.elements
2053 .first()
2054 .and_then(|e| e.first())
2055 .is_some_and(|v| v == "Z31")
2056 && s.elements
2057 .first()
2058 .and_then(|e| e.get(1))
2059 .is_some_and(|v| v.replace(' ', "") == pauschal_id)
2060 });
2061 if has_pauschal {
2062 for seq in &seqs {
2063 if seq
2064 .elements
2065 .first()
2066 .and_then(|e| e.first())
2067 .is_some_and(|v| v == "Z78")
2068 {
2069 if let Some(zid) = seq.elements.get(1).and_then(|e| e.first()) {
2070 if !zid.is_empty() {
2071 pauschal_zeitraum_ids.push(zid.clone());
2072 }
2073 }
2074 }
2075 }
2076 }
2077 }
2078 for i in 0..sg8_count {
2080 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
2081 for seq in &seqs {
2082 if seq
2083 .elements
2084 .first()
2085 .and_then(|e| e.first())
2086 .is_some_and(|v| v == "Z98")
2087 {
2088 let zid = seq
2089 .elements
2090 .get(1)
2091 .and_then(|e| e.first())
2092 .map(|s| s.as_str())
2093 .unwrap_or("");
2094 if !zid.is_empty() && pauschal_zeitraum_ids.iter().any(|z| z == zid) {
2095 return ConditionResult::False;
2097 }
2098 }
2099 }
2100 }
2101 ConditionResult::True
2103 }
2104
2105 fn evaluate_52(&self, ctx: &EvaluationContext) -> ConditionResult {
2107 let cci_segs = ctx.find_segments("CCI");
2108 let found = cci_segs.iter().any(|s| {
2109 s.elements
2110 .first()
2111 .and_then(|e| e.first())
2112 .is_some_and(|v| v == "Z07")
2113 && s.elements
2114 .get(2)
2115 .and_then(|e| e.first())
2116 .is_some_and(|v| ["Z55", "Z56"].contains(&v.as_str()))
2117 });
2118 ConditionResult::from(found)
2119 }
2120
2121 fn evaluate_53(&self, _ctx: &EvaluationContext) -> ConditionResult {
2123 ConditionResult::Unknown
2125 }
2126
2127 fn evaluate_54(&self, ctx: &EvaluationContext) -> ConditionResult {
2129 let seq_segs = ctx.find_segments("SEQ");
2130 let found = seq_segs.iter().any(|s| {
2131 s.elements
2132 .first()
2133 .and_then(|e| e.first())
2134 .is_some_and(|v| ["Z01"].contains(&v.as_str()))
2135 });
2136 ConditionResult::from(found)
2137 }
2138
2139 fn evaluate_55(&self, ctx: &EvaluationContext) -> ConditionResult {
2141 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
2143 let found = sts_segs.iter().any(|s| {
2144 s.elements
2145 .first()
2146 .and_then(|e| e.first())
2147 .is_some_and(|v| v == "E01")
2148 && s.elements
2149 .get(2)
2150 .and_then(|e| e.first())
2151 .is_some_and(|v| ["A06", "A99"].contains(&v.as_str()))
2152 });
2153 ConditionResult::from(found)
2154 }
2155
2156 fn evaluate_56(&self, ctx: &EvaluationContext) -> ConditionResult {
2158 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
2161 let found = sts_segs.iter().any(|s| {
2162 s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| {
2163 [
2164 "A01", "A02", "A03", "A04", "A05", "A06", "A07", "A08", "A09", "A10", "A11",
2165 "A12", "A13", "A14", "A15", "A16", "A17", "A25",
2166 ]
2167 .contains(&v.as_str())
2168 })
2169 });
2170 ConditionResult::from(found)
2171 }
2172
2173 fn evaluate_57(&self, ctx: &EvaluationContext) -> ConditionResult {
2175 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
2177 let found = cci_segs.iter().any(|s| {
2178 s.elements
2179 .first()
2180 .and_then(|e| e.first())
2181 .is_some_and(|v| v == "Z45")
2182 && s.elements
2183 .get(2)
2184 .and_then(|e| e.first())
2185 .is_some_and(|v| v == "ZD9")
2186 });
2187 ConditionResult::from(found)
2188 }
2189
2190 fn evaluate_58(&self, ctx: &EvaluationContext) -> ConditionResult {
2192 let cci_segs = ctx.find_segments("CCI");
2193 let found = cci_segs
2194 .iter()
2195 .any(|s| s.elements.iter().any(|e| e.iter().any(|v| v == "293")));
2196 ConditionResult::from(found)
2197 }
2198
2199 fn evaluate_60(&self, ctx: &EvaluationContext) -> ConditionResult {
2201 let bgm_segs = ctx.find_segments("BGM");
2202 let found = bgm_segs.iter().any(|s| {
2203 s.elements
2204 .first()
2205 .and_then(|e| e.first())
2206 .is_some_and(|v| v == "Z90")
2207 });
2208 ConditionResult::from(found)
2209 }
2210
2211 fn evaluate_61(&self, ctx: &EvaluationContext) -> ConditionResult {
2213 let bgm_segs = ctx.find_segments("BGM");
2214 let found = bgm_segs.iter().any(|s| {
2215 s.elements
2216 .first()
2217 .and_then(|e| e.first())
2218 .is_some_and(|v| v == "Z89")
2219 });
2220 ConditionResult::from(found)
2221 }
2222
2223 fn evaluate_62(&self, ctx: &EvaluationContext) -> ConditionResult {
2226 let nav = match ctx.navigator {
2227 Some(n) => n,
2228 None => return ConditionResult::Unknown,
2229 };
2230 use std::collections::HashMap;
2231 let mut count_by_zid: HashMap<String, u32> = HashMap::new();
2232 let sg4_count = nav.group_instance_count(&["SG4"]);
2233 for sg4_idx in 0..sg4_count {
2234 let sg8_count = nav.child_group_instance_count(&["SG4"], sg4_idx, "SG8");
2235 for sg8_idx in 0..sg8_count {
2236 let seqs =
2237 nav.find_segments_in_child_group("SEQ", &["SG4"], sg4_idx, "SG8", sg8_idx);
2238 let zeitraum_opt = seqs
2239 .iter()
2240 .filter(|s| {
2241 s.elements
2242 .first()
2243 .and_then(|e: &Vec<String>| e.first())
2244 .is_some_and(|v: &String| v == "Z45")
2245 })
2246 .filter_map(|s| {
2247 s.elements
2248 .get(1)
2249 .and_then(|e: &Vec<String>| e.first())
2250 .filter(|v| !v.is_empty())
2251 .cloned()
2252 })
2253 .next();
2254 let Some(zid) = zeitraum_opt else { continue };
2255 let pias =
2256 nav.find_segments_in_child_group("PIA", &["SG4"], sg4_idx, "SG8", sg8_idx);
2257 let has_qualifying_pia = pias.iter().any(|s| {
2258 s.elements
2259 .first()
2260 .and_then(|e: &Vec<String>| e.first())
2261 .is_some_and(|v: &String| v == "Z02")
2262 && s.elements
2263 .get(1)
2264 .and_then(|e: &Vec<String>| e.first())
2265 .map(|code| {
2266 code.starts_with("1-08-1")
2267 || code.starts_with("1-08-2")
2268 || code.starts_with("1-08-3")
2269 || code.starts_with("1-08-4")
2270 || code.starts_with("1-08-5")
2271 })
2272 .unwrap_or(false)
2273 });
2274 if has_qualifying_pia {
2275 *count_by_zid.entry(zid).or_insert(0) += 1;
2276 }
2277 }
2278 }
2279 ConditionResult::from(count_by_zid.values().any(|&c| c > 1))
2280 }
2281
2282 fn evaluate_63(&self, ctx: &EvaluationContext) -> ConditionResult {
2284 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
2286 let found = sts_segs.iter().any(|s| {
2287 s.elements
2288 .first()
2289 .and_then(|e| e.first())
2290 .is_some_and(|v| v == "E01")
2291 && s.elements
2292 .get(2)
2293 .and_then(|e| e.first())
2294 .is_some_and(|v| ["A15", "A99"].contains(&v.as_str()))
2295 });
2296 ConditionResult::from(found)
2297 }
2298
2299 fn evaluate_64(&self, ctx: &EvaluationContext) -> ConditionResult {
2301 let pia_segs = ctx.find_segments("PIA");
2303 let count = pia_segs
2304 .iter()
2305 .filter(|s| {
2306 s.elements
2307 .first()
2308 .and_then(|e| e.first())
2309 .is_some_and(|v| v == "Z02")
2310 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
2311 ["1-08-1", "1-08-2", "1-08-3", "1-08-4", "1-08-5"]
2312 .iter()
2313 .any(|p| v.starts_with(p))
2314 })
2315 })
2316 .count();
2317 ConditionResult::from(count > 1)
2318 }
2319
2320 fn evaluate_65(&self, ctx: &EvaluationContext) -> ConditionResult {
2322 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
2325 let found = pia_segs.iter().any(|s| {
2326 s.elements
2327 .first()
2328 .and_then(|e| e.first())
2329 .is_some_and(|v| v == "Z02")
2330 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
2331 ["1-08-1", "1-08-2", "1-08-3", "1-08-4", "1-08-5"]
2332 .iter()
2333 .any(|p| v.starts_with(p))
2334 })
2335 });
2336 ConditionResult::from(found)
2337 }
2338
2339 fn evaluate_66(&self, ctx: &EvaluationContext) -> ConditionResult {
2341 let seq_segs = ctx.find_segments("SEQ");
2342 let count = seq_segs
2343 .iter()
2344 .filter(|s| {
2345 s.elements
2346 .first()
2347 .and_then(|e| e.first())
2348 .is_some_and(|v| v == "ZH0")
2349 })
2350 .count();
2351 ConditionResult::from(count > 1)
2352 }
2353
2354 fn evaluate_67(&self, ctx: &EvaluationContext) -> ConditionResult {
2356 let cav_segs = ctx.find_segments("CAV");
2358 let found = cav_segs.iter().any(|s| {
2359 s.elements
2360 .first()
2361 .and_then(|e| e.first())
2362 .is_some_and(|v| v == "ZH9")
2363 && s.elements
2364 .first()
2365 .and_then(|e| e.get(1))
2366 .is_some_and(|v| v == "9991000002933")
2367 });
2368 ConditionResult::from(!found)
2369 }
2370
2371 fn evaluate_68(&self, ctx: &EvaluationContext) -> ConditionResult {
2373 let seq_segs = ctx.find_segments("SEQ");
2374 let count = seq_segs
2375 .iter()
2376 .filter(|s| {
2377 s.elements
2378 .first()
2379 .and_then(|e| e.first())
2380 .is_some_and(|v| v == "ZH0")
2381 })
2382 .count();
2383 ConditionResult::from(count > 2)
2384 }
2385
2386 fn evaluate_69(&self, ctx: &EvaluationContext) -> ConditionResult {
2388 let seq_segs = ctx.find_segments("SEQ");
2389 let count = seq_segs
2390 .iter()
2391 .filter(|s| {
2392 s.elements
2393 .first()
2394 .and_then(|e| e.first())
2395 .is_some_and(|v| v == "ZH0")
2396 })
2397 .count();
2398 ConditionResult::from(count > 3)
2399 }
2400
2401 fn evaluate_70(&self, ctx: &EvaluationContext) -> ConditionResult {
2403 let seq_segs = ctx.find_segments("SEQ");
2404 let count = seq_segs
2405 .iter()
2406 .filter(|s| {
2407 s.elements
2408 .first()
2409 .and_then(|e| e.first())
2410 .is_some_and(|v| v == "ZH0")
2411 })
2412 .count();
2413 ConditionResult::from(count == 5)
2414 }
2415
2416 fn evaluate_71(&self, ctx: &EvaluationContext) -> ConditionResult {
2418 ctx.external.evaluate("assignment_response")
2420 }
2421
2422 fn evaluate_72(&self, ctx: &EvaluationContext) -> ConditionResult {
2424 ctx.external.evaluate("assignment_end_response")
2426 }
2427
2428 fn evaluate_73(&self, ctx: &EvaluationContext) -> ConditionResult {
2434 use crate::eval::CodelistColumn;
2443 let any_match = ctx.scoped_find_segments_in("SG8", "PIA").iter().any(|s| {
2444 let is_z02 = s
2445 .elements
2446 .first()
2447 .and_then(|e| e.first())
2448 .is_some_and(|v| v == "Z02");
2449 if !is_z02 {
2450 return false;
2451 }
2452 let code = match s.elements.get(1).and_then(|e| e.first()) {
2453 Some(c) if !c.is_empty() => c,
2454 _ => return false,
2455 };
2456 ctx.codelist
2457 .flag(code, CodelistColumn::UtilmdPreisangabe)
2458 .unwrap_or(false)
2459 });
2460 ConditionResult::from(any_match)
2461 }
2462
2463 fn evaluate_74(&self, ctx: &EvaluationContext) -> ConditionResult {
2465 let seq_segs = ctx.find_segments("SEQ");
2466 let has_seq = seq_segs.iter().any(|s| {
2467 s.elements
2468 .first()
2469 .and_then(|e| e.first())
2470 .is_some_and(|v| v == "Z59")
2471 });
2472 let pia_segs = ctx.find_segments("PIA");
2473 let has_pia = pia_segs.iter().any(|s| {
2474 s.elements
2475 .first()
2476 .and_then(|e| e.first())
2477 .is_some_and(|v| v == "5")
2478 });
2479 ConditionResult::from(has_seq && has_pia)
2480 }
2481
2482 fn evaluate_75(&self, ctx: &EvaluationContext) -> ConditionResult {
2484 ctx.external.evaluate("code_list_membership_check")
2485 }
2486
2487 fn evaluate_76(&self, ctx: &EvaluationContext) -> ConditionResult {
2490 ctx.has_qualifier("SEQ", 0, "Z49")
2491 }
2492
2493 fn evaluate_77(&self, ctx: &EvaluationContext) -> ConditionResult {
2495 let seq_segs = ctx.find_segments("SEQ");
2496 let found = seq_segs.iter().any(|s| {
2497 s.elements
2498 .first()
2499 .and_then(|e| e.first())
2500 .is_some_and(|v| ["Z03"].contains(&v.as_str()))
2501 });
2502 ConditionResult::from(!found)
2503 }
2504
2505 fn evaluate_78(&self, ctx: &EvaluationContext) -> ConditionResult {
2507 let sts_segs = ctx.find_segments("STS");
2508 let found = sts_segs.iter().any(|s| {
2509 s.elements
2510 .first()
2511 .and_then(|e| e.first())
2512 .is_some_and(|v| v == "7")
2513 && s.elements
2514 .get(2)
2515 .and_then(|e| e.first())
2516 .is_some_and(|v| ["E02"].contains(&v.as_str()))
2517 });
2518 ConditionResult::from(!found)
2519 }
2520
2521 fn evaluate_83(&self, ctx: &EvaluationContext) -> ConditionResult {
2523 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
2525 let found = sts_segs.iter().any(|s| {
2526 s.elements
2527 .first()
2528 .and_then(|e| e.first())
2529 .is_some_and(|v| v == "E01")
2530 && s.elements
2531 .get(2)
2532 .and_then(|e| e.first())
2533 .is_some_and(|v| ["A08", "A16", "A99"].contains(&v.as_str()))
2534 });
2535 ConditionResult::from(found)
2536 }
2537
2538 fn evaluate_84(&self, ctx: &EvaluationContext) -> ConditionResult {
2540 let sts_segs = ctx.find_segments("STS");
2541 let found = sts_segs.iter().any(|s| {
2542 s.elements
2543 .first()
2544 .and_then(|e| e.first())
2545 .is_some_and(|v| v == "E01")
2546 && s.elements
2547 .get(2)
2548 .and_then(|e| e.first())
2549 .is_some_and(|v| ["A57"].contains(&v.as_str()))
2550 });
2551 ConditionResult::from(found)
2552 }
2553
2554 fn evaluate_85(&self, ctx: &EvaluationContext) -> ConditionResult {
2556 let dtm_segs = ctx.find_segments("DTM");
2557 let found = dtm_segs.iter().any(|s| {
2558 s.elements
2559 .first()
2560 .and_then(|e| e.first())
2561 .is_some_and(|v| v == "Z01")
2562 && s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| {
2563 v.chars()
2564 .nth(3)
2565 .is_some_and(|c| ['M', 'Q', 'H', 'J'].contains(&c))
2566 })
2567 });
2568 ConditionResult::from(found)
2569 }
2570
2571 fn evaluate_86(&self, ctx: &EvaluationContext) -> ConditionResult {
2573 ctx.groups_share_qualified_value(
2575 "RFF",
2576 0,
2577 "Z50",
2578 0,
2579 2,
2580 &["SG4", "SG6"],
2581 "RFF",
2582 0,
2583 2,
2584 &["SG4", "SG8"],
2585 )
2586 }
2587
2588 fn evaluate_87(&self, ctx: &EvaluationContext) -> ConditionResult {
2590 let dtm_segs = ctx.find_segments("DTM");
2592 let found = dtm_segs.iter().any(|s| {
2593 s.elements.first().and_then(|e| e.get(1)).is_some_and(|v| {
2594 v.len() >= 12
2595 && &v[6..8] == "01" && &v[8..12] == "0000" })
2598 });
2599 if !found {
2600 if dtm_segs.is_empty() {
2602 return ConditionResult::Unknown;
2603 }
2604 }
2605 ConditionResult::from(found)
2606 }
2607
2608 fn evaluate_88(&self, ctx: &EvaluationContext) -> ConditionResult {
2610 let dtm157 = ctx.find_segments_with_qualifier("DTM", 0, "157");
2612 if dtm157.is_empty() {
2613 return ConditionResult::Unknown;
2614 }
2615 ConditionResult::True
2617 }
2618
2619 fn evaluate_89(&self, ctx: &EvaluationContext) -> ConditionResult {
2622 let nav = match ctx.navigator {
2623 Some(n) => n,
2624 None => {
2625 return ctx.filtered_parent_child_has_qualifier(
2626 &["SG4", "SG8"],
2627 "SEQ",
2628 0,
2629 "Z01",
2630 "SG10",
2631 "CCI",
2632 2,
2633 "ZA6",
2634 )
2635 }
2636 };
2637 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
2638 for i in 0..sg8_count {
2639 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
2640 for j in 0..sg10_count {
2641 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
2642 let has_cci_za6 = ccis.iter().any(|s| {
2643 s.elements
2644 .get(2)
2645 .and_then(|e: &Vec<String>| e.first())
2646 .is_some_and(|v: &String| v == "ZA6")
2647 });
2648 if !has_cci_za6 {
2649 continue;
2650 }
2651 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
2652 if cavs.iter().any(|s| {
2653 s.elements
2654 .first()
2655 .and_then(|e: &Vec<String>| e.first())
2656 .is_some_and(|v: &String| v == "E14")
2657 }) {
2658 return ConditionResult::True;
2659 }
2660 }
2661 }
2662 ConditionResult::False
2663 }
2664
2665 fn evaluate_90(&self, ctx: &EvaluationContext) -> ConditionResult {
2668 let nav = match ctx.navigator {
2669 Some(n) => n,
2670 None => return ConditionResult::Unknown,
2671 };
2672 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
2673 for i in 0..sg8_count {
2674 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
2675 let mut has_za6_e14 = false;
2676 let mut has_za6_e02 = false;
2677 for j in 0..sg10_count {
2678 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
2679 let has_cci_za6 = ccis.iter().any(|s| {
2680 s.elements
2681 .get(2)
2682 .and_then(|e: &Vec<String>| e.first())
2683 .is_some_and(|v: &String| v == "ZA6")
2684 });
2685 if !has_cci_za6 {
2686 continue;
2687 }
2688 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
2689 for cav in &cavs {
2690 if let Some(code) = cav.elements.first().and_then(|e: &Vec<String>| e.first()) {
2691 if code == "E14" {
2692 has_za6_e14 = true;
2693 }
2694 if code == "E02" {
2695 has_za6_e02 = true;
2696 }
2697 }
2698 }
2699 }
2700 if has_za6_e14 && has_za6_e02 {
2701 return ConditionResult::True;
2702 }
2703 }
2704 ConditionResult::False
2705 }
2706
2707 fn evaluate_91(&self, ctx: &EvaluationContext) -> ConditionResult {
2710 match self.evaluate_90(ctx) {
2711 ConditionResult::True => ConditionResult::False,
2712 ConditionResult::False => ConditionResult::True,
2713 ConditionResult::Unknown => ConditionResult::Unknown,
2714 }
2715 }
2716
2717 fn evaluate_92(&self, _ctx: &EvaluationContext) -> ConditionResult {
2719 ConditionResult::Unknown
2721 }
2722
2723 fn evaluate_93(&self, _ctx: &EvaluationContext) -> ConditionResult {
2725 ConditionResult::Unknown
2727 }
2728
2729 fn evaluate_94(&self, _ctx: &EvaluationContext) -> ConditionResult {
2731 ConditionResult::True
2733 }
2734
2735 fn evaluate_95(&self, ctx: &EvaluationContext) -> ConditionResult {
2737 let cci_segs = ctx.scoped_find_segments_in("SG10", "CCI");
2739 let has_cci = cci_segs.iter().any(|s| {
2740 s.elements
2741 .first()
2742 .and_then(|e| e.first())
2743 .is_some_and(|v| v == "Z17")
2744 });
2745 let cav_segs = ctx.scoped_find_segments_in("SG10", "CAV");
2746 let has_cav = cav_segs.iter().any(|s| {
2747 s.elements
2748 .first()
2749 .and_then(|e| e.first())
2750 .is_some_and(|v| ["ZE5"].contains(&v.as_str()))
2751 });
2752 ConditionResult::from(has_cci && has_cav)
2753 }
2754
2755 fn evaluate_96(&self, ctx: &EvaluationContext) -> ConditionResult {
2757 let sts_segs = ctx.find_segments("STS");
2758 let found = sts_segs.iter().any(|s| {
2759 s.elements
2760 .first()
2761 .and_then(|e| e.first())
2762 .is_some_and(|v| v == "7")
2763 && s.elements
2764 .get(3)
2765 .and_then(|e| e.first())
2766 .is_some_and(|v| ["ZAP"].contains(&v.as_str()))
2767 });
2768 ConditionResult::from(found)
2769 }
2770
2771 fn evaluate_97(&self, ctx: &EvaluationContext) -> ConditionResult {
2773 let cav_segs = ctx.find_segments("CAV");
2775 let found = cav_segs.iter().any(|s| {
2776 s.elements
2777 .first()
2778 .and_then(|e| e.first())
2779 .is_some_and(|v| v == "ZH9")
2780 && s.elements
2781 .first()
2782 .and_then(|e| e.get(1))
2783 .is_some_and(|v| v == "9991000002420")
2784 });
2785 ConditionResult::from(found)
2786 }
2787
2788 fn evaluate_98(&self, ctx: &EvaluationContext) -> ConditionResult {
2790 ctx.external.evaluate("sender_role_check")
2791 }
2792
2793 fn evaluate_99(&self, ctx: &EvaluationContext) -> ConditionResult {
2795 ctx.external.evaluate("sender_role_check")
2796 }
2797
2798 fn evaluate_100(&self, ctx: &EvaluationContext) -> ConditionResult {
2800 let cav_segs = ctx.find_segments("CAV");
2801 let found = cav_segs.iter().any(|s| {
2802 s.elements.first().and_then(|e| e.first()).is_some_and(|v| {
2803 [
2804 "TLS", "TES", "BIT", "GET", "GAT", "SOT", "WNT", "WFT", "WAT",
2805 ]
2806 .contains(&v.as_str())
2807 })
2808 });
2809 ConditionResult::from(found)
2810 }
2811
2812 fn evaluate_101(&self, ctx: &EvaluationContext) -> ConditionResult {
2814 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
2816 let found = cci_segs.iter().any(|s| {
2817 s.elements
2818 .get(2)
2819 .and_then(|e| e.first())
2820 .is_some_and(|v| v == "ZA6")
2821 });
2822 ConditionResult::from(found)
2823 }
2824
2825 fn evaluate_102(&self, ctx: &EvaluationContext) -> ConditionResult {
2827 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
2829 let found = cci_segs.iter().any(|s| {
2830 s.elements
2831 .get(2)
2832 .and_then(|e| e.first())
2833 .is_some_and(|v| v == "ZA6")
2834 });
2835 ConditionResult::from(found)
2836 }
2837
2838 fn evaluate_103(&self, ctx: &EvaluationContext) -> ConditionResult {
2840 let qty_segs = ctx.scoped_find_segments_in("SG8", "QTY");
2842 let found = qty_segs.iter().any(|s| {
2843 s.elements
2844 .first()
2845 .and_then(|e| e.first())
2846 .is_some_and(|v| v == "265")
2847 });
2848 ConditionResult::from(found)
2849 }
2850
2851 fn evaluate_104(&self, ctx: &EvaluationContext) -> ConditionResult {
2853 let qty_segs = ctx.scoped_find_segments_in("SG8", "QTY");
2855 let found = qty_segs.iter().any(|s| {
2856 s.elements
2857 .first()
2858 .and_then(|e| e.first())
2859 .is_some_and(|v| v == "Z08")
2860 });
2861 ConditionResult::from(found)
2862 }
2863
2864 fn evaluate_105(&self, ctx: &EvaluationContext) -> ConditionResult {
2866 let qty_segs = ctx.scoped_find_segments_in("SG8", "QTY");
2868 let found = qty_segs.iter().any(|s| {
2869 s.elements
2870 .first()
2871 .and_then(|e| e.first())
2872 .is_some_and(|v| v == "Z10")
2873 });
2874 ConditionResult::from(found)
2875 }
2876
2877 fn evaluate_106(&self, ctx: &EvaluationContext) -> ConditionResult {
2879 ctx.filtered_parent_child_has_qualifier(
2881 &["SG4", "SG8"],
2882 "SEQ",
2883 0,
2884 "Z01",
2885 "SG10",
2886 "CAV",
2887 0,
2888 "E02",
2889 )
2890 }
2891
2892 fn evaluate_107(&self, ctx: &EvaluationContext) -> ConditionResult {
2894 let cav_segs = ctx.scoped_find_segments_in("SG8", "CAV");
2896 let found = cav_segs.iter().any(|s| {
2897 s.elements.first().and_then(|e| e.first()).is_some_and(|v| {
2898 [
2899 "SLS", "SES", "BIP", "GEP", "GAP", "SOP", "WNP", "WFP", "WAP",
2900 ]
2901 .contains(&v.as_str())
2902 })
2903 });
2904 ConditionResult::from(found)
2905 }
2906
2907 fn evaluate_108(&self, ctx: &EvaluationContext) -> ConditionResult {
2915 const PREFIXES: &[&str] = &["1-08-1", "1-08-2", "1-08-3", "1-08-4", "1-08-5"];
2919 let found = ctx
2920 .scoped_find_segments_in("SG8", "PIA")
2921 .iter()
2922 .filter(|s| {
2923 s.elements
2924 .first()
2925 .and_then(|e| e.first())
2926 .is_some_and(|q| q == "Z02")
2927 })
2928 .any(|s| {
2929 s.elements
2930 .get(1)
2931 .and_then(|e| e.first())
2932 .is_some_and(|v| PREFIXES.iter().any(|p| v.starts_with(p)))
2933 });
2934 ConditionResult::from(found)
2935 }
2936
2937 fn evaluate_110(&self, ctx: &EvaluationContext) -> ConditionResult {
2939 let cav_segs = ctx.find_segments("CAV");
2940 let found = cav_segs.iter().any(|s| {
2941 s.elements.first().and_then(|e| e.first()).is_some_and(|v| {
2942 [
2943 "LGS", "EGS", "BIL", "GEL", "GAL", "SOL", "WNL", "WFL", "WAL",
2944 ]
2945 .contains(&v.as_str())
2946 })
2947 });
2948 ConditionResult::from(found)
2949 }
2950
2951 fn evaluate_111(&self, ctx: &EvaluationContext) -> ConditionResult {
2953 ctx.any_group_has_qualifier_without("SEQ", 0, "Z59", "PIA", 0, "5", &["SG4", "SG8"])
2954 }
2955
2956 fn evaluate_112(&self, ctx: &EvaluationContext) -> ConditionResult {
2958 let result = ctx.filtered_parent_child_has_qualifier(
2959 &["SG4", "SG8"],
2960 "SEQ",
2961 0,
2962 "Z59",
2963 "SG10",
2964 "CCI",
2965 0,
2966 "11",
2967 );
2968 match result {
2969 ConditionResult::True => ConditionResult::False,
2970 ConditionResult::False => ConditionResult::True,
2971 ConditionResult::Unknown => ConditionResult::Unknown,
2972 }
2973 }
2974
2975 fn evaluate_113(&self, ctx: &EvaluationContext) -> ConditionResult {
2977 ctx.external.evaluate("counting_time_order_response")
2979 }
2980
2981 fn evaluate_114(&self, ctx: &EvaluationContext) -> ConditionResult {
2984 let nav = match ctx.navigator {
2985 Some(n) => n,
2986 None => {
2987 return match (
2988 ctx.has_qualifier("CCI", 0, "E03"),
2989 ctx.has_qualifier("CAV", 0, "E06"),
2990 ) {
2991 (ConditionResult::True, ConditionResult::True) => ConditionResult::True,
2992 (ConditionResult::False, _) | (_, ConditionResult::False) => {
2993 ConditionResult::False
2994 }
2995 _ => ConditionResult::Unknown,
2996 };
2997 }
2998 };
2999 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
3000 for i in 0..sg8_count {
3001 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
3002 for j in 0..sg10_count {
3003 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
3004 let has_cci_e03 = ccis.iter().any(|s| {
3005 s.elements
3006 .first()
3007 .and_then(|e: &Vec<String>| e.first())
3008 .is_some_and(|v: &String| v == "E03")
3009 });
3010 if has_cci_e03 {
3011 let cavs =
3012 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
3013 if cavs.iter().any(|s| {
3014 s.elements
3015 .first()
3016 .and_then(|e: &Vec<String>| e.first())
3017 .is_some_and(|v: &String| v == "E06")
3018 }) {
3019 return ConditionResult::True;
3020 }
3021 }
3022 }
3023 }
3024 ConditionResult::False
3025 }
3026
3027 fn evaluate_115(&self, ctx: &EvaluationContext) -> ConditionResult {
3029 let cci_segs = ctx.find_segments("CCI");
3030 let has_cci = cci_segs.iter().any(|s| {
3031 s.elements
3032 .first()
3033 .and_then(|e| e.first())
3034 .is_some_and(|v| v == "E03")
3035 });
3036 let cav_segs = ctx.find_segments("CAV");
3037 let has_cav = cav_segs.iter().any(|s| {
3038 s.elements
3039 .first()
3040 .and_then(|e| e.first())
3041 .is_some_and(|v| v == "E05")
3042 });
3043 ConditionResult::from(has_cci && has_cav)
3044 }
3045
3046 fn evaluate_116(&self, ctx: &EvaluationContext) -> ConditionResult {
3048 let cci_segs = ctx.find_segments("CCI");
3049 let has_cci = cci_segs.iter().any(|s| {
3050 s.elements
3051 .first()
3052 .and_then(|e| e.first())
3053 .is_some_and(|v| v == "E03")
3054 });
3055 let cav_segs = ctx.find_segments("CAV");
3056 let has_cav = cav_segs.iter().any(|s| {
3057 s.elements
3058 .first()
3059 .and_then(|e| e.first())
3060 .is_some_and(|v| v == "E04")
3061 });
3062 ConditionResult::from(has_cci && has_cav)
3063 }
3064
3065 fn evaluate_117(&self, ctx: &EvaluationContext) -> ConditionResult {
3068 let nav = match ctx.navigator {
3069 Some(n) => n,
3070 None => return ConditionResult::Unknown,
3071 };
3072 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
3073 for i in 0..sg8_count {
3074 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
3075 for j in 0..sg10_count {
3076 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
3077 let has_cci_za6 = ccis.iter().any(|s| {
3078 s.elements
3079 .get(2)
3080 .and_then(|e: &Vec<String>| e.first())
3081 .is_some_and(|v: &String| v == "ZA6")
3082 });
3083 if has_cci_za6 {
3084 let cavs =
3085 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
3086 if cavs.iter().any(|s| {
3087 s.elements
3088 .first()
3089 .and_then(|e: &Vec<String>| e.first())
3090 .is_some_and(|v: &String| v == "E14")
3091 }) {
3092 return ConditionResult::True;
3093 }
3094 }
3095 }
3096 }
3097 ConditionResult::False
3098 }
3099
3100 fn evaluate_118(&self, ctx: &EvaluationContext) -> ConditionResult {
3102 let has_cci = ctx.filtered_parent_child_has_qualifier(
3103 &["SG4", "SG8"],
3104 "SEQ",
3105 0,
3106 "Z98",
3107 "SG10",
3108 "CCI",
3109 2,
3110 "ZA6",
3111 );
3112 if has_cci != ConditionResult::True {
3113 return has_cci;
3114 }
3115 ctx.filtered_parent_child_has_qualifier(
3116 &["SG4", "SG8"],
3117 "SEQ",
3118 0,
3119 "Z98",
3120 "SG10",
3121 "CAV",
3122 0,
3123 "E02",
3124 )
3125 }
3126
3127 fn evaluate_119(&self, ctx: &EvaluationContext) -> ConditionResult {
3129 let r1 = ctx.filtered_parent_child_has_qualifier(
3131 &["SG4", "SG8"],
3132 "SEQ",
3133 0,
3134 "Z01",
3135 "SG10",
3136 "CAV",
3137 0,
3138 "E02",
3139 );
3140 if r1 == ConditionResult::True {
3141 return ConditionResult::True;
3142 }
3143 ctx.filtered_parent_child_has_qualifier(
3144 &["SG4", "SG8"],
3145 "SEQ",
3146 0,
3147 "Z98",
3148 "SG10",
3149 "CAV",
3150 0,
3151 "E02",
3152 )
3153 }
3154
3155 fn evaluate_120(&self, _ctx: &EvaluationContext) -> ConditionResult {
3157 ConditionResult::Unknown
3159 }
3160
3161 fn evaluate_121(&self, ctx: &EvaluationContext) -> ConditionResult {
3163 let z03 =
3164 ctx.any_group_has_qualifier_without("SEQ", 0, "Z03", "RFF", 0, "Z14", &["SG4", "SG8"]);
3165 if z03 == ConditionResult::True {
3166 return ConditionResult::True;
3167 }
3168 ctx.any_group_has_qualifier_without("SEQ", 0, "ZF5", "RFF", 0, "Z14", &["SG4", "SG8"])
3169 }
3170
3171 fn evaluate_122(&self, ctx: &EvaluationContext) -> ConditionResult {
3174 let has_cci_e03 = ctx.filtered_parent_child_has_qualifier(
3176 &["SG4", "SG8"],
3177 "SEQ",
3178 0,
3179 "Z98",
3180 "SG10",
3181 "CCI",
3182 2,
3183 "E03",
3184 );
3185 if has_cci_e03 != ConditionResult::True {
3186 return has_cci_e03;
3187 }
3188 ctx.any_group_has_qualifier("CAV", 0, "E06", &["SG4", "SG8"])
3190 }
3191
3192 fn evaluate_123(&self, ctx: &EvaluationContext) -> ConditionResult {
3195 struct Sg8Z20Entry {
3196 mg_id: Option<String>,
3197 }
3198 let mut entries: Vec<Sg8Z20Entry> = Vec::new();
3199 let mut current: Option<Sg8Z20Entry> = None;
3200 for seg in ctx.segments {
3201 match seg.id.as_str() {
3202 "SEQ" => {
3203 if let Some(entry) = current.take() {
3204 entries.push(entry);
3205 }
3206 if seg
3207 .elements
3208 .first()
3209 .and_then(|e: &Vec<String>| e.first())
3210 .is_some_and(|v: &String| v == "Z20")
3211 {
3212 current = Some(Sg8Z20Entry { mg_id: None });
3213 }
3214 }
3215 "RFF" if current.is_some() => {
3216 if seg
3217 .elements
3218 .first()
3219 .and_then(|e: &Vec<String>| e.first())
3220 .is_some_and(|v: &String| v == "MG")
3221 {
3222 if let Some(ref mut entry) = current {
3223 if entry.mg_id.is_none() {
3224 entry.mg_id = seg.elements.first().and_then(|e| e.get(1)).cloned();
3225 }
3226 }
3227 }
3228 }
3229 _ => {}
3230 }
3231 }
3232 if let Some(entry) = current {
3233 entries.push(entry);
3234 }
3235 let ids: Vec<&str> = entries
3236 .iter()
3237 .filter_map(|e| e.mg_id.as_deref().filter(|s| !s.is_empty()))
3238 .collect();
3239 for i in 0..ids.len() {
3240 for j in (i + 1)..ids.len() {
3241 if ids[i] == ids[j] {
3242 return ConditionResult::True;
3243 }
3244 }
3245 }
3246 ConditionResult::False
3247 }
3248
3249 fn evaluate_124(&self, ctx: &EvaluationContext) -> ConditionResult {
3252 struct Sg8Z20Entry {
3253 zeitraum_id: String,
3254 mg_id: Option<String>,
3255 }
3256 let mut entries: Vec<Sg8Z20Entry> = Vec::new();
3257 let mut current: Option<Sg8Z20Entry> = None;
3258 for seg in ctx.segments {
3259 match seg.id.as_str() {
3260 "SEQ" => {
3261 if let Some(entry) = current.take() {
3262 entries.push(entry);
3263 }
3264 if seg
3265 .elements
3266 .first()
3267 .and_then(|e: &Vec<String>| e.first())
3268 .is_some_and(|v: &String| v == "Z20")
3269 {
3270 let zeitraum_id = seg
3271 .elements
3272 .get(1)
3273 .and_then(|e: &Vec<String>| e.first())
3274 .cloned()
3275 .unwrap_or_default();
3276 current = Some(Sg8Z20Entry {
3277 zeitraum_id,
3278 mg_id: None,
3279 });
3280 }
3281 }
3282 "RFF" if current.is_some() => {
3283 if seg
3284 .elements
3285 .first()
3286 .and_then(|e: &Vec<String>| e.first())
3287 .is_some_and(|v: &String| v == "MG")
3288 {
3289 if let Some(ref mut entry) = current {
3290 if entry.mg_id.is_none() {
3291 entry.mg_id = seg.elements.first().and_then(|e| e.get(1)).cloned();
3292 }
3293 }
3294 }
3295 }
3296 _ => {}
3297 }
3298 }
3299 if let Some(entry) = current {
3300 entries.push(entry);
3301 }
3302 for i in 0..entries.len() {
3303 for j in (i + 1)..entries.len() {
3304 let ei = &entries[i];
3305 let ej = &entries[j];
3306 if !ei.zeitraum_id.is_empty()
3307 && ei.zeitraum_id == ej.zeitraum_id
3308 && ei.mg_id.is_some()
3309 && !ei.mg_id.as_deref().unwrap_or("").is_empty()
3310 && ei.mg_id == ej.mg_id
3311 {
3312 return ConditionResult::True;
3313 }
3314 }
3315 }
3316 ConditionResult::False
3317 }
3318
3319 fn evaluate_125(&self, ctx: &EvaluationContext) -> ConditionResult {
3321 let seq_segs = ctx.scoped_find_segments_in("SG8", "SEQ");
3323 let found = seq_segs.iter().any(|s| {
3324 s.elements
3325 .first()
3326 .and_then(|e| e.first())
3327 .is_some_and(|v| ["Z76", "ZC5", "ZC6"].contains(&v.as_str()))
3328 });
3329 ConditionResult::from(found)
3330 }
3331
3332 fn evaluate_126(&self, ctx: &EvaluationContext) -> ConditionResult {
3334 let count = ctx.find_segments_with_qualifier("RFF", 0, "Z49").len()
3337 + ctx.find_segments_with_qualifier("RFF", 0, "Z53").len();
3338 ConditionResult::from(count > 0)
3339 }
3340
3341 fn evaluate_127(&self, ctx: &EvaluationContext) -> ConditionResult {
3343 let count = ctx.find_segments_with_qualifier("RFF", 0, "Z48").len()
3345 + ctx.find_segments_with_qualifier("RFF", 0, "Z55").len();
3346 ConditionResult::from(count > 0)
3347 }
3348
3349 fn evaluate_128(&self, ctx: &EvaluationContext) -> ConditionResult {
3351 let count = ctx.find_segments_with_qualifier("RFF", 0, "Z47").len()
3353 + ctx.find_segments_with_qualifier("RFF", 0, "Z54").len();
3354 ConditionResult::from(count > 0)
3355 }
3356
3357 fn evaluate_129(&self, ctx: &EvaluationContext) -> ConditionResult {
3359 let loc_segs = ctx.find_segments_with_qualifier("LOC", 0, "Z16");
3361 if loc_segs.len() <= 1 {
3362 return ConditionResult::True;
3363 }
3364 let first_val = loc_segs[0].elements.get(1).and_then(|e| e.first());
3365 let all_same = loc_segs
3366 .iter()
3367 .all(|s| s.elements.get(1).and_then(|e| e.first()) == first_val);
3368 ConditionResult::from(all_same)
3369 }
3370
3371 fn evaluate_130(&self, _ctx: &EvaluationContext) -> ConditionResult {
3373 ConditionResult::Unknown
3375 }
3376
3377 fn evaluate_131(&self, ctx: &EvaluationContext) -> ConditionResult {
3379 let has_zeitraum_id_1 = ctx.find_segments("RFF").iter().any(|s| {
3381 s.elements
3382 .first()
3383 .and_then(|e| e.get(2))
3384 .is_some_and(|v| v == "1")
3385 });
3386 ConditionResult::from(has_zeitraum_id_1)
3387 }
3388
3389 fn evaluate_132(&self, ctx: &EvaluationContext) -> ConditionResult {
3392 let has_zeitraum_id_1 = ctx.find_segments("RFF").iter().any(|s| {
3394 s.elements
3395 .first()
3396 .and_then(|e| e.get(2))
3397 .is_some_and(|v: &String| v == "1")
3398 });
3399 if !has_zeitraum_id_1 {
3400 return ConditionResult::False;
3401 }
3402 let msg_date_str = match ctx
3404 .find_segments_with_qualifier("DTM", 0, "137")
3405 .into_iter()
3406 .next()
3407 {
3408 Some(seg) => match seg.elements.first().and_then(|e| e.get(1)) {
3409 Some(v) if v.len() >= 8 => v.clone(),
3410 _ => return ConditionResult::Unknown,
3411 },
3412 None => return ConditionResult::Unknown,
3413 };
3414 let usage_date_str = match ctx
3416 .find_segments_with_qualifier("DTM", 0, "Z25")
3417 .into_iter()
3418 .next()
3419 {
3420 Some(seg) => match seg.elements.first().and_then(|e| e.get(1)) {
3421 Some(v) if v.len() >= 12 => v.clone(),
3422 _ => return ConditionResult::Unknown,
3423 },
3424 None => return ConditionResult::Unknown,
3425 };
3426 let year: u32 = match msg_date_str[..4].parse() {
3428 Ok(v) => v,
3429 Err(_) => return ConditionResult::Unknown,
3430 };
3431 let month: u32 = match msg_date_str[4..6].parse() {
3432 Ok(v) => v,
3433 Err(_) => return ConditionResult::Unknown,
3434 };
3435 let day: u32 = match msg_date_str[6..8].parse() {
3436 Ok(v) => v,
3437 Err(_) => return ConditionResult::Unknown,
3438 };
3439 let days_in_month: u32 = match month {
3440 1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
3441 4 | 6 | 9 | 11 => 30,
3442 2 => {
3443 if year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) {
3444 29
3445 } else {
3446 28
3447 }
3448 }
3449 _ => return ConditionResult::Unknown,
3450 };
3451 let (next_year, next_month, next_day): (u32, u32, u32) = if day >= days_in_month {
3452 if month == 12 {
3453 (year + 1, 1, 1)
3454 } else {
3455 (year, month + 1, 1)
3456 }
3457 } else {
3458 (year, month, day + 1)
3459 };
3460 let expected_prefix = format!("{:04}{:02}{:02}0000", next_year, next_month, next_day);
3462 let actual_len = usage_date_str.len().min(12);
3463 let actual_prefix = &usage_date_str[..actual_len];
3464 ConditionResult::from(actual_prefix == expected_prefix.as_str())
3465 }
3466
3467 fn evaluate_133(&self, _ctx: &EvaluationContext) -> ConditionResult {
3469 ConditionResult::Unknown
3471 }
3472
3473 fn evaluate_134(&self, ctx: &EvaluationContext) -> ConditionResult {
3476 let nav = match ctx.navigator() {
3477 Some(n) => n,
3478 None => return ConditionResult::Unknown,
3479 };
3480 let sg6_count = nav.group_instance_count(&["SG4", "SG6"]);
3481 let mut slices: Vec<(u32, Option<String>, Option<String>)> = Vec::new();
3483 for i in 0..sg6_count {
3484 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG6"], i);
3485 let maybe_zid = rffs.iter().find_map(|s| {
3487 let qual = s
3488 .elements
3489 .first()
3490 .and_then(|e| e.first())
3491 .map(|v| v.as_str())?;
3492 if qual == "Z48" || qual == "Z55" {
3493 s.elements
3494 .first()
3495 .and_then(|e| e.get(2))
3496 .and_then(|v| v.parse::<u32>().ok())
3497 } else {
3498 None
3499 }
3500 });
3501 if let Some(zid) = maybe_zid {
3502 let dtms = nav.find_segments_in_group("DTM", &["SG4", "SG6"], i);
3503 let z25 = dtms.iter().find_map(|s| {
3504 if s.elements
3505 .first()
3506 .and_then(|e| e.first())
3507 .map(|v| v.as_str())
3508 == Some("Z25")
3509 {
3510 s.elements.first().and_then(|e| e.get(1)).cloned()
3511 } else {
3512 None
3513 }
3514 });
3515 let z26 = dtms.iter().find_map(|s| {
3516 if s.elements
3517 .first()
3518 .and_then(|e| e.first())
3519 .map(|v| v.as_str())
3520 == Some("Z26")
3521 {
3522 s.elements.first().and_then(|e| e.get(1)).cloned()
3523 } else {
3524 None
3525 }
3526 });
3527 slices.push((zid, z25, z26));
3528 }
3529 }
3530 if slices.is_empty() {
3531 return ConditionResult::Unknown;
3532 }
3533 for i in 0..slices.len() {
3535 let (zid, ref z25, _) = slices[i];
3536 if zid <= 1 {
3537 continue;
3538 }
3539 let prev_id = zid - 1;
3540 match slices.iter().find(|(id, _, _)| *id == prev_id) {
3541 Some((_, _, prev_z26)) => match (z25, prev_z26) {
3542 (Some(curr), Some(prev_end)) => {
3543 if curr != prev_end {
3544 return ConditionResult::False;
3545 }
3546 }
3547 _ => return ConditionResult::Unknown,
3548 },
3549 None => return ConditionResult::Unknown,
3550 }
3551 }
3552 ConditionResult::True
3553 }
3554
3555 fn evaluate_135(&self, ctx: &EvaluationContext) -> ConditionResult {
3558 let nav = match ctx.navigator() {
3559 Some(n) => n,
3560 None => return ConditionResult::Unknown,
3561 };
3562 let sg6_count = nav.group_instance_count(&["SG4", "SG6"]);
3563 let mut slices: Vec<(u32, Option<String>, Option<String>)> = Vec::new();
3565 for i in 0..sg6_count {
3566 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG6"], i);
3567 let maybe_zid = rffs.iter().find_map(|s| {
3569 let qual = s
3570 .elements
3571 .first()
3572 .and_then(|e| e.first())
3573 .map(|v| v.as_str())?;
3574 if qual == "Z47" || qual == "Z54" {
3575 s.elements
3576 .first()
3577 .and_then(|e| e.get(2))
3578 .and_then(|v| v.parse::<u32>().ok())
3579 } else {
3580 None
3581 }
3582 });
3583 if let Some(zid) = maybe_zid {
3584 let dtms = nav.find_segments_in_group("DTM", &["SG4", "SG6"], i);
3585 let z25 = dtms.iter().find_map(|s| {
3586 if s.elements
3587 .first()
3588 .and_then(|e| e.first())
3589 .map(|v| v.as_str())
3590 == Some("Z25")
3591 {
3592 s.elements.first().and_then(|e| e.get(1)).cloned()
3593 } else {
3594 None
3595 }
3596 });
3597 let z26 = dtms.iter().find_map(|s| {
3598 if s.elements
3599 .first()
3600 .and_then(|e| e.first())
3601 .map(|v| v.as_str())
3602 == Some("Z26")
3603 {
3604 s.elements.first().and_then(|e| e.get(1)).cloned()
3605 } else {
3606 None
3607 }
3608 });
3609 slices.push((zid, z25, z26));
3610 }
3611 }
3612 if slices.is_empty() {
3613 return ConditionResult::Unknown;
3614 }
3615 for i in 0..slices.len() {
3617 let (zid, ref z25, _) = slices[i];
3618 if zid <= 1 {
3619 continue;
3620 }
3621 let prev_id = zid - 1;
3622 match slices.iter().find(|(id, _, _)| *id == prev_id) {
3623 Some((_, _, prev_z26)) => match (z25, prev_z26) {
3624 (Some(curr), Some(prev_end)) => {
3625 if curr != prev_end {
3626 return ConditionResult::False;
3627 }
3628 }
3629 _ => return ConditionResult::Unknown,
3630 },
3631 None => return ConditionResult::Unknown,
3632 }
3633 }
3634 ConditionResult::True
3635 }
3636
3637 fn evaluate_136(&self, ctx: &EvaluationContext) -> ConditionResult {
3639 let cci_segs = ctx.find_segments("CCI");
3640 let found = cci_segs.iter().any(|s| {
3641 s.elements
3642 .get(2)
3643 .and_then(|e| e.first())
3644 .is_some_and(|v| v == "E13")
3645 });
3646 ConditionResult::from(found)
3647 }
3648
3649 fn evaluate_137(&self, ctx: &EvaluationContext) -> ConditionResult {
3651 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "7");
3654 let is_neuanlage = sts_segs.iter().any(|s| {
3655 s.elements
3656 .get(2)
3657 .and_then(|e| e.first())
3658 .is_some_and(|v| v == "E01" || v == "E03")
3659 });
3660 ConditionResult::from(!is_neuanlage)
3661 }
3662
3663 fn evaluate_138(&self, ctx: &EvaluationContext) -> ConditionResult {
3665 let qty_segs = ctx.find_segments("QTY");
3666 let found = qty_segs.iter().any(|s| {
3667 s.elements
3668 .first()
3669 .and_then(|e| e.first())
3670 .is_some_and(|v| ["Z35"].contains(&v.as_str()))
3671 });
3672 ConditionResult::from(found)
3673 }
3674
3675 fn evaluate_139(&self, ctx: &EvaluationContext) -> ConditionResult {
3678 let nav = match ctx.navigator {
3679 Some(n) => n,
3680 None => return ctx.lacks_qualifier("CAV", 0, "IVA"),
3681 };
3682 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
3683 for i in 0..sg8_count {
3684 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
3685 for j in 0..sg10_count {
3686 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
3687 if cavs.iter().any(|s| {
3688 s.elements
3689 .first()
3690 .and_then(|e: &Vec<String>| e.first())
3691 .is_some_and(|v: &String| v == "IVA")
3692 }) {
3693 return ConditionResult::False;
3694 }
3695 }
3696 }
3697 ConditionResult::True
3698 }
3699
3700 fn evaluate_140(&self, ctx: &EvaluationContext) -> ConditionResult {
3702 let qty_segs = ctx.find_segments("QTY");
3703 let found = qty_segs.iter().any(|s| {
3704 s.elements
3705 .first()
3706 .and_then(|e| e.first())
3707 .is_some_and(|v| ["Z34", "Z35"].contains(&v.as_str()))
3708 });
3709 ConditionResult::from(found)
3710 }
3711
3712 fn evaluate_141(&self, ctx: &EvaluationContext) -> ConditionResult {
3714 let cav_segs = ctx.find_segments("CAV");
3715 let found = cav_segs.iter().any(|s| {
3716 s.elements
3717 .first()
3718 .and_then(|e| e.first())
3719 .is_some_and(|v| ["MIW", "MPW", "MBW"].contains(&v.as_str()))
3720 });
3721 ConditionResult::from(found)
3722 }
3723
3724 fn evaluate_142(&self, ctx: &EvaluationContext) -> ConditionResult {
3726 let pia_segs = ctx.find_segments("PIA");
3727 let found = pia_segs.iter().any(|s| {
3728 s.elements
3729 .first()
3730 .and_then(|e| e.first())
3731 .is_some_and(|v| v == "Z01")
3732 && s.elements
3733 .get(1)
3734 .and_then(|e| e.get(1))
3735 .is_some_and(|v| ["Z04", "Z05"].contains(&v.as_str()))
3736 });
3737 ConditionResult::from(found)
3738 }
3739
3740 fn evaluate_143(&self, ctx: &EvaluationContext) -> ConditionResult {
3742 let sts_segs = ctx.find_segments("STS");
3743 let found = sts_segs.iter().any(|s| {
3744 s.elements
3745 .first()
3746 .and_then(|e| e.first())
3747 .is_some_and(|v| v == "7")
3748 && s.elements
3749 .get(2)
3750 .and_then(|e| e.first())
3751 .is_some_and(|v| v == "ZX3")
3752 });
3753 ConditionResult::from(found)
3754 }
3755
3756 fn evaluate_144(&self, ctx: &EvaluationContext) -> ConditionResult {
3758 let sts_segs = ctx.find_segments("STS");
3759 let found = sts_segs.iter().any(|s| {
3760 s.elements
3761 .first()
3762 .and_then(|e| e.first())
3763 .is_some_and(|v| v == "7")
3764 && s.elements
3765 .get(2)
3766 .and_then(|e| e.first())
3767 .is_some_and(|v| v == "ZAN")
3768 });
3769 ConditionResult::from(found)
3770 }
3771
3772 fn evaluate_145(&self, ctx: &EvaluationContext) -> ConditionResult {
3774 let sts_segs = ctx.find_segments("STS");
3775 let found = sts_segs.iter().any(|s| {
3776 s.elements
3777 .first()
3778 .and_then(|e| e.first())
3779 .is_some_and(|v| v == "7")
3780 && s.elements
3781 .get(2)
3782 .and_then(|e| e.first())
3783 .is_some_and(|v| v == "ZX2")
3784 });
3785 ConditionResult::from(found)
3786 }
3787
3788 fn evaluate_146(&self, ctx: &EvaluationContext) -> ConditionResult {
3790 let sts_segs = ctx.find_segments("STS");
3791 let found = sts_segs.iter().any(|s| {
3792 s.elements
3793 .first()
3794 .and_then(|e| e.first())
3795 .is_some_and(|v| v == "7")
3796 && s.elements
3797 .get(2)
3798 .and_then(|e| e.first())
3799 .is_some_and(|v| v == "ZA0")
3800 });
3801 ConditionResult::from(found)
3802 }
3803
3804 fn evaluate_147(&self, _ctx: &EvaluationContext) -> ConditionResult {
3806 ConditionResult::Unknown
3808 }
3809
3810 fn evaluate_148(&self, ctx: &EvaluationContext) -> ConditionResult {
3812 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
3814 let found = pia_segs.iter().any(|s| {
3815 s.elements
3816 .first()
3817 .and_then(|e| e.first())
3818 .is_some_and(|v| v == "Z02")
3819 && s.elements
3820 .get(1)
3821 .and_then(|e| e.first())
3822 .is_some_and(|v| ["1-02-0-017", "1-02-0-018"].contains(&v.as_str()))
3823 });
3824 ConditionResult::from(found)
3825 }
3826
3827 fn evaluate_149(&self, ctx: &EvaluationContext) -> ConditionResult {
3830 use std::collections::{HashMap, HashSet};
3831 let seq_quals = ctx.collect_group_values("SEQ", 0, 0, &["SG4", "SG8"]);
3832 let seq_zeitraum = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
3833 let pia_quals = ctx.collect_group_values("PIA", 0, 0, &["SG4", "SG8"]);
3834 let pia_prods = ctx.collect_group_values("PIA", 1, 0, &["SG4", "SG8"]);
3835 let mut idx_to_zeitraum: HashMap<usize, String> = HashMap::new();
3837 for ((gi, q), (_, zid)) in seq_quals.iter().zip(seq_zeitraum.iter()) {
3838 if q == "Z45" && !zid.is_empty() {
3839 idx_to_zeitraum.insert(*gi, zid.clone());
3840 }
3841 }
3842 if idx_to_zeitraum.is_empty() {
3843 return ConditionResult::False;
3844 }
3845 let mut zeitraum_products: HashMap<String, HashSet<String>> = HashMap::new();
3847 for (i, (gi, qual)) in pia_quals.iter().enumerate() {
3848 if qual == "Z02" {
3849 if let Some(zid) = idx_to_zeitraum.get(gi) {
3850 if let Some((_, prod)) = pia_prods.get(i) {
3851 if !prod.is_empty() {
3852 zeitraum_products
3853 .entry(zid.clone())
3854 .or_default()
3855 .insert(prod.clone());
3856 }
3857 }
3858 }
3859 }
3860 }
3861 ConditionResult::from(
3862 zeitraum_products
3863 .values()
3864 .any(|codes| codes.contains("1-02-0-017") && codes.contains("1-02-0-018")),
3865 )
3866 }
3867
3868 fn evaluate_150(&self, ctx: &EvaluationContext) -> ConditionResult {
3870 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
3872 let found = pia_segs.iter().any(|s| {
3873 s.elements
3874 .first()
3875 .and_then(|e| e.first())
3876 .is_some_and(|v| v == "Z02")
3877 && s.elements
3878 .get(1)
3879 .and_then(|e| e.first())
3880 .is_some_and(|v| ["1-02-0-002"].contains(&v.as_str()))
3881 });
3882 ConditionResult::from(found)
3883 }
3884
3885 fn evaluate_151(&self, ctx: &EvaluationContext) -> ConditionResult {
3887 ctx.external.evaluate("code_list_membership_check")
3888 }
3889
3890 fn evaluate_152(&self, ctx: &EvaluationContext) -> ConditionResult {
3892 let ftx_segs = ctx.find_segments("FTX");
3893 let found = ftx_segs.iter().any(|s| {
3894 s.elements
3895 .first()
3896 .and_then(|e| e.first())
3897 .is_some_and(|v| v == "Z28")
3898 });
3899 ConditionResult::from(!found)
3900 }
3901
3902 fn evaluate_153(&self, ctx: &EvaluationContext) -> ConditionResult {
3904 let ftx_segs = ctx.find_segments("FTX");
3905 let found = ftx_segs.iter().any(|s| {
3906 s.elements
3907 .first()
3908 .and_then(|e| e.first())
3909 .is_some_and(|v| v == "Z27")
3910 });
3911 ConditionResult::from(!found)
3912 }
3913
3914 fn evaluate_156(&self, ctx: &EvaluationContext) -> ConditionResult {
3916 let ftx_segs = ctx.find_segments("FTX");
3917 let found = ftx_segs.iter().any(|s| {
3918 s.elements
3919 .first()
3920 .and_then(|e| e.first())
3921 .is_some_and(|v| v == "Z17")
3922 });
3923 ConditionResult::from(found)
3924 }
3925
3926 fn evaluate_161(&self, ctx: &EvaluationContext) -> ConditionResult {
3928 let sts_segs = ctx.find_segments("STS");
3929 let found = sts_segs.iter().any(|s| {
3930 s.elements
3931 .first()
3932 .and_then(|e| e.first())
3933 .is_some_and(|v| v == "7")
3934 && s.elements
3935 .get(2)
3936 .and_then(|e| e.first())
3937 .is_some_and(|v| v == "E03")
3938 && s.elements
3939 .get(3)
3940 .and_then(|e| e.first())
3941 .is_some_and(|v| v == "ZW8")
3942 });
3943 ConditionResult::from(found)
3944 }
3945
3946 fn evaluate_162(&self, ctx: &EvaluationContext) -> ConditionResult {
3948 let sts_segs = ctx.find_segments("STS");
3949 let found = sts_segs.iter().any(|s| {
3950 s.elements
3951 .first()
3952 .and_then(|e| e.first())
3953 .is_some_and(|v| v == "7")
3954 && s.elements
3955 .get(2)
3956 .and_then(|e| e.first())
3957 .is_some_and(|v| v == "E03")
3958 && s.elements
3959 .get(3)
3960 .and_then(|e| e.first())
3961 .is_some_and(|v| v == "ZW9")
3962 });
3963 ConditionResult::from(found)
3964 }
3965
3966 fn evaluate_163(&self, ctx: &EvaluationContext) -> ConditionResult {
3968 let sts_segs = ctx.find_segments("STS");
3969 let found = sts_segs.iter().any(|s| {
3970 s.elements
3971 .first()
3972 .and_then(|e| e.first())
3973 .is_some_and(|v| v == "7")
3974 && s.elements
3975 .get(2)
3976 .and_then(|e| e.first())
3977 .is_some_and(|v| v == "E03")
3978 && s.elements
3979 .get(3)
3980 .and_then(|e| e.first())
3981 .is_some_and(|v| v == "ZX0")
3982 });
3983 ConditionResult::from(found)
3984 }
3985
3986 fn evaluate_164(&self, ctx: &EvaluationContext) -> ConditionResult {
3988 let sts_segs = ctx.find_segments("STS");
3989 let found = sts_segs.iter().any(|s| {
3990 s.elements
3991 .first()
3992 .and_then(|e| e.first())
3993 .is_some_and(|v| v == "7")
3994 && s.elements
3995 .get(2)
3996 .and_then(|e| e.first())
3997 .is_some_and(|v| v == "E03")
3998 && s.elements
3999 .get(3)
4000 .and_then(|e| e.first())
4001 .is_some_and(|v| v == "ZX1")
4002 });
4003 ConditionResult::from(found)
4004 }
4005
4006 fn evaluate_165(&self, _ctx: &EvaluationContext) -> ConditionResult {
4008 ConditionResult::Unknown
4010 }
4011
4012 fn evaluate_166(&self, _ctx: &EvaluationContext) -> ConditionResult {
4014 ConditionResult::True
4016 }
4017
4018 fn evaluate_167(&self, ctx: &EvaluationContext) -> ConditionResult {
4020 let loc_segs = ctx.find_segments("LOC");
4021 let found = loc_segs.iter().any(|s| {
4022 s.elements
4023 .first()
4024 .and_then(|e| e.first())
4025 .is_some_and(|v| v == "Z21")
4026 });
4027 ConditionResult::from(found)
4028 }
4029
4030 fn evaluate_170(&self, _ctx: &EvaluationContext) -> ConditionResult {
4032 ConditionResult::Unknown
4034 }
4035
4036 fn evaluate_172(&self, ctx: &EvaluationContext) -> ConditionResult {
4038 let qty_segs = ctx.find_segments("QTY");
4039 let found = qty_segs.iter().any(|s| {
4040 s.elements
4041 .first()
4042 .and_then(|e| e.first())
4043 .is_some_and(|v| ["Z37"].contains(&v.as_str()))
4044 });
4045 ConditionResult::from(found)
4046 }
4047
4048 fn evaluate_173(&self, ctx: &EvaluationContext) -> ConditionResult {
4051 use std::collections::HashSet;
4052 let seq_quals = ctx.collect_group_values("SEQ", 0, 0, &["SG4", "SG8"]);
4053 let target_indices: HashSet<usize> = seq_quals
4054 .iter()
4055 .filter(|(_, q)| matches!(q.as_str(), "Z58" | "ZC9" | "ZD0" | "ZD6"))
4056 .map(|(i, _)| *i)
4057 .collect();
4058 if target_indices.is_empty() {
4059 return ConditionResult::Unknown;
4060 }
4061 let rff_quals = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG8"]);
4063 let rff_de1156 = ctx.collect_group_values("RFF", 0, 2, &["SG4", "SG8"]);
4064 let mut found_rff_z33 = false;
4065 for (i, (gi, qual)) in rff_quals.iter().enumerate() {
4066 if qual == "Z33" && target_indices.contains(gi) {
4067 found_rff_z33 = true;
4068 let de1156_empty = rff_de1156.get(i).map(|(_, v)| v.is_empty()).unwrap_or(true);
4069 if de1156_empty {
4070 return ConditionResult::True;
4071 }
4072 }
4073 }
4074 if found_rff_z33 {
4075 ConditionResult::False
4076 } else {
4077 ConditionResult::Unknown
4078 }
4079 }
4080
4081 fn evaluate_174(&self, ctx: &EvaluationContext) -> ConditionResult {
4083 let rff_z33 = ctx.scoped_find_segments_in_with_qualifier("SG8", "RFF", 0, "Z33");
4086 let found = rff_z33.iter().any(|s| {
4087 s.elements
4088 .first()
4089 .and_then(|e| e.get(2))
4090 .is_some_and(|v| !v.is_empty())
4091 });
4092 ConditionResult::from(found)
4093 }
4094
4095 fn evaluate_175(&self, ctx: &EvaluationContext) -> ConditionResult {
4098 let nav = match ctx.navigator {
4099 Some(n) => n,
4100 None => return ConditionResult::Unknown,
4101 };
4102 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
4103 let mut entries: Vec<(usize, String, String)> = Vec::new();
4104 for i in 0..sg8_count {
4105 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
4106 if !seqs.iter().any(|s| {
4107 s.elements
4108 .first()
4109 .and_then(|e: &Vec<String>| e.first())
4110 .is_some_and(|v: &String| v == "Z58")
4111 }) {
4112 continue;
4113 }
4114 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
4115 for rff in &rffs {
4116 let elems = match rff.elements.first() {
4117 Some(e) => e,
4118 None => continue,
4119 };
4120 if elems.first().map(|s| s.as_str()) != Some("Z33") {
4121 continue;
4122 }
4123 let objektcode = elems.get(1).cloned().unwrap_or_default();
4124 let fort_nr = elems.get(2).cloned().unwrap_or_default();
4125 if !objektcode.is_empty() {
4126 entries.push((i, objektcode, fort_nr));
4127 }
4128 }
4129 }
4130 for a in 0..entries.len() {
4131 for b in (a + 1)..entries.len() {
4132 if entries[a].0 != entries[b].0
4133 && entries[a].1 == entries[b].1
4134 && entries[a].2 == entries[b].2
4135 {
4136 return ConditionResult::True;
4137 }
4138 }
4139 }
4140 ConditionResult::False
4141 }
4142
4143 fn evaluate_176(&self, ctx: &EvaluationContext) -> ConditionResult {
4145 ConditionResult::from(ctx.self_segment_value_equals("RFF", 0, 0, "Z34"))
4146 }
4147
4148 fn evaluate_177(&self, ctx: &EvaluationContext) -> ConditionResult {
4150 ConditionResult::from(ctx.self_segment_value_equals("RFF", 0, 0, "Z35"))
4151 }
4152
4153 fn evaluate_178(&self, ctx: &EvaluationContext) -> ConditionResult {
4155 let loc_segs = ctx.find_segments("LOC");
4156 let found = loc_segs.iter().any(|s| {
4157 s.elements
4158 .first()
4159 .and_then(|e| e.first())
4160 .is_some_and(|v| v == "Z18")
4161 });
4162 ConditionResult::from(found)
4163 }
4164
4165 fn evaluate_179(&self, ctx: &EvaluationContext) -> ConditionResult {
4167 const KINDS: [&str; 4] = ["Z58", "ZC9", "ZD0", "ZD6"];
4171 let Some(siblings) = ctx.sibling_scopes("SG8") else {
4172 return ConditionResult::Unknown;
4173 };
4174 let seq_of = |segs: &[OwnedSegment]| {
4175 segs.iter()
4176 .find(|s| s.id == "SEQ")
4177 .map(|s| s.get_element(0).to_string())
4178 };
4179 let objektcodes = |segs: &[OwnedSegment]| -> Vec<String> {
4180 segs.iter()
4181 .filter(|s| s.id == "RFF" && s.get_element(0) == "Z33")
4182 .map(|s| s.get_component(0, 1).to_string())
4183 .filter(|v| !v.is_empty())
4184 .collect()
4185 };
4186 let own_seq = seq_of(&ctx.scoped_find_segments_in("SG8", "SEQ"));
4187 let Some(own_seq) = own_seq.filter(|q| KINDS.contains(&q.as_str())) else {
4188 return ConditionResult::False;
4189 };
4190 let own = objektcodes(&ctx.scoped_find_segments_in("SG8", "RFF"));
4191 if own.is_empty() {
4192 return ConditionResult::False;
4193 }
4194 let found = siblings.iter().any(|path| {
4195 seq_of(&ctx.find_segments_at(path, "SEQ")).as_deref() == Some(own_seq.as_str())
4196 && objektcodes(&ctx.find_segments_at(path, "RFF"))
4197 .iter()
4198 .any(|code| own.contains(code))
4199 });
4200 ConditionResult::from(found)
4201 }
4202
4203 fn evaluate_180(&self, ctx: &EvaluationContext) -> ConditionResult {
4205 let qty_segs = ctx.find_segments("QTY");
4206 let found = qty_segs.iter().any(|s| {
4207 s.elements
4208 .first()
4209 .and_then(|e| e.first())
4210 .is_some_and(|v| ["Z46"].contains(&v.as_str()))
4211 });
4212 ConditionResult::from(found)
4213 }
4214
4215 fn evaluate_184(&self, ctx: &EvaluationContext) -> ConditionResult {
4217 let seq_segs = ctx.scoped_find_segments_in("SG8", "SEQ");
4219 let found = seq_segs.iter().any(|s| {
4220 s.elements
4221 .first()
4222 .and_then(|e| e.first())
4223 .is_some_and(|v| ["Z18"].contains(&v.as_str()))
4224 });
4225 ConditionResult::from(found)
4226 }
4227
4228 fn evaluate_190(&self, ctx: &EvaluationContext) -> ConditionResult {
4230 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
4233 let found = pia_segs.iter().any(|s| {
4234 s.elements
4235 .first()
4236 .and_then(|e| e.first())
4237 .is_some_and(|v| v == "5")
4238 && s.elements
4239 .get(1)
4240 .and_then(|e| e.first())
4241 .is_some_and(|v| v == "9991000000721")
4242 });
4243 ConditionResult::from(found)
4244 }
4245
4246 fn evaluate_191(&self, ctx: &EvaluationContext) -> ConditionResult {
4248 let sts_segs = ctx.find_segments("STS");
4249 let found = sts_segs.iter().any(|s| {
4250 s.elements
4251 .first()
4252 .and_then(|e| e.first())
4253 .is_some_and(|v| v == "E01")
4254 });
4255 ConditionResult::from(!found)
4256 }
4257
4258 fn evaluate_192(&self, ctx: &EvaluationContext) -> ConditionResult {
4260 let sts_segs = ctx.find_segments("STS");
4261 let found = sts_segs.iter().any(|s| {
4262 s.elements
4263 .first()
4264 .and_then(|e| e.first())
4265 .is_some_and(|v| v == "7")
4266 && s.elements
4267 .get(3)
4268 .and_then(|e| e.first())
4269 .is_some_and(|v| ["ZW4", "ZAP"].contains(&v.as_str()))
4270 });
4271 ConditionResult::from(found)
4272 }
4273
4274 fn evaluate_193(&self, ctx: &EvaluationContext) -> ConditionResult {
4276 let nav = match ctx.navigator {
4277 Some(n) => n,
4278 None => {
4279 let cavs = ctx.find_segments("CAV");
4280 return ConditionResult::from(cavs.iter().any(|s| {
4281 s.elements
4282 .first()
4283 .and_then(|e: &Vec<String>| e.first())
4284 .is_some_and(|v: &String| v == "E06")
4285 }));
4286 }
4287 };
4288 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
4289 for i in 0..sg8_count {
4290 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
4291 for j in 0..sg10_count {
4292 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
4293 let has_cci_zb5 = ccis.iter().any(|s| {
4294 s.elements
4295 .get(2)
4296 .and_then(|e: &Vec<String>| e.first())
4297 .is_some_and(|v: &String| v == "ZB5")
4298 });
4299 if !has_cci_zb5 {
4300 continue;
4301 }
4302 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
4303 if cavs.iter().any(|s| {
4304 s.elements
4305 .first()
4306 .and_then(|e: &Vec<String>| e.first())
4307 .is_some_and(|v: &String| v == "E06")
4308 }) {
4309 return ConditionResult::True;
4310 }
4311 }
4312 }
4313 ConditionResult::False
4314 }
4315
4316 fn evaluate_194(&self, ctx: &EvaluationContext) -> ConditionResult {
4318 let cci_segs = ctx.find_segments("CCI");
4319 let has_cci = cci_segs.iter().any(|s| {
4320 s.elements
4321 .iter()
4322 .any(|e| e.first().is_some_and(|v| v == "ZB5"))
4323 });
4324 let cav_segs = ctx.find_segments("CAV");
4325 let has_cav = cav_segs.iter().any(|s| {
4326 s.elements
4327 .first()
4328 .and_then(|e| e.first())
4329 .is_some_and(|v| v == "E05")
4330 });
4331 ConditionResult::from(has_cci && has_cav)
4332 }
4333
4334 fn evaluate_195(&self, ctx: &EvaluationContext) -> ConditionResult {
4336 let cci_segs = ctx.find_segments("CCI");
4337 let has_cci = cci_segs.iter().any(|s| {
4338 s.elements
4339 .iter()
4340 .any(|e| e.first().is_some_and(|v| v == "ZB5"))
4341 });
4342 let cav_segs = ctx.find_segments("CAV");
4343 let has_cav = cav_segs.iter().any(|s| {
4344 s.elements
4345 .first()
4346 .and_then(|e| e.first())
4347 .is_some_and(|v| v == "E04")
4348 });
4349 ConditionResult::from(has_cci && has_cav)
4350 }
4351
4352 fn evaluate_196(&self, ctx: &EvaluationContext) -> ConditionResult {
4355 let nav = match ctx.navigator {
4356 Some(n) => n,
4357 None => return ConditionResult::Unknown,
4358 };
4359 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
4360 let mut entries: Vec<(usize, String, String, String, String)> = Vec::new();
4361 for i in 0..sg8_count {
4362 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
4363 let seq_opt = seqs.iter().find(|s| {
4364 s.elements
4365 .first()
4366 .and_then(|e: &Vec<String>| e.first())
4367 .is_some_and(|v: &String| matches!(v.as_str(), "Z58" | "ZC9" | "ZD0"))
4368 });
4369 let seq = match seq_opt {
4370 Some(s) => s,
4371 None => continue,
4372 };
4373 let seq_code = seq
4374 .elements
4375 .first()
4376 .and_then(|e: &Vec<String>| e.first())
4377 .cloned()
4378 .unwrap_or_default();
4379 let zeitraum_id = seq
4380 .elements
4381 .get(1)
4382 .and_then(|e: &Vec<String>| e.first())
4383 .cloned()
4384 .unwrap_or_default();
4385 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
4386 for rff in &rffs {
4387 let elems = match rff.elements.first() {
4388 Some(e) => e,
4389 None => continue,
4390 };
4391 if elems.first().map(|s| s.as_str()) != Some("Z33") {
4392 continue;
4393 }
4394 let objektcode = elems.get(1).cloned().unwrap_or_default();
4395 let fort_nr = elems.get(2).cloned().unwrap_or_default();
4396 if !objektcode.is_empty() {
4397 entries.push((
4398 i,
4399 seq_code.clone(),
4400 zeitraum_id.clone(),
4401 objektcode,
4402 fort_nr,
4403 ));
4404 }
4405 }
4406 }
4407 for a in 0..entries.len() {
4408 for b in (a + 1)..entries.len() {
4409 if entries[a].0 != entries[b].0
4410 && entries[a].1 == entries[b].1
4411 && entries[a].2 == entries[b].2
4412 && entries[a].3 == entries[b].3
4413 && entries[a].4 == entries[b].4
4414 {
4415 return ConditionResult::True;
4416 }
4417 }
4418 }
4419 ConditionResult::False
4420 }
4421
4422 fn evaluate_197(&self, ctx: &EvaluationContext) -> ConditionResult {
4425 let nav = match ctx.navigator {
4426 Some(n) => n,
4427 None => return ConditionResult::Unknown,
4428 };
4429 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
4430 let mut qualifying_malo_ids: Vec<String> = Vec::new();
4431 for i in 0..sg8_count {
4432 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
4433 if !seqs.iter().any(|s| {
4434 s.elements
4435 .first()
4436 .and_then(|e: &Vec<String>| e.first())
4437 .is_some_and(|v: &String| v == "Z01")
4438 }) {
4439 continue;
4440 }
4441 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
4442 let has_prog = (0..sg10_count).any(|j| {
4443 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
4444 let has_za6 = ccis.iter().any(|s| {
4445 s.elements
4446 .get(2)
4447 .and_then(|e: &Vec<String>| e.first())
4448 .is_some_and(|v: &String| v == "ZA6")
4449 });
4450 if !has_za6 {
4451 return false;
4452 }
4453 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
4454 cavs.iter().any(|s| {
4455 s.elements
4456 .first()
4457 .and_then(|e: &Vec<String>| e.first())
4458 .is_some_and(|v: &String| v == "E02")
4459 })
4460 });
4461 if !has_prog {
4462 continue;
4463 }
4464 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
4465 for rff in &rffs {
4466 let elems = match rff.elements.first() {
4467 Some(e) => e,
4468 None => continue,
4469 };
4470 if elems.first().map(|s| s.as_str()) != Some("Z18") {
4471 continue;
4472 }
4473 if let Some(malo_id) = elems.get(1) {
4474 if !malo_id.is_empty() {
4475 qualifying_malo_ids.push(malo_id.clone());
4476 }
4477 }
4478 }
4479 }
4480 if qualifying_malo_ids.is_empty() {
4481 return ConditionResult::False;
4482 }
4483 for i in 0..sg8_count {
4484 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
4485 for rff in &rffs {
4486 let elems = match rff.elements.first() {
4487 Some(e) => e,
4488 None => continue,
4489 };
4490 if elems.first().map(|s| s.as_str()) != Some("Z18") {
4491 continue;
4492 }
4493 if let Some(malo_id) = elems.get(1) {
4494 if qualifying_malo_ids.contains(malo_id) {
4495 return ConditionResult::True;
4496 }
4497 }
4498 }
4499 }
4500 ConditionResult::False
4501 }
4502
4503 fn evaluate_198(&self, ctx: &EvaluationContext) -> ConditionResult {
4505 let sts_segs = ctx.find_segments("STS");
4506 let found = sts_segs.iter().any(|s| {
4507 s.elements
4508 .first()
4509 .and_then(|e| e.first())
4510 .is_some_and(|v| v == "7")
4511 && s.elements
4512 .get(2)
4513 .and_then(|e| e.first())
4514 .is_some_and(|v| ["E03"].contains(&v.as_str()))
4515 });
4516 ConditionResult::from(found)
4517 }
4518
4519 fn evaluate_199(&self, ctx: &EvaluationContext) -> ConditionResult {
4522 let nav = match ctx.navigator {
4523 Some(n) => n,
4524 None => {
4525 return ctx.filtered_parent_child_has_qualifier(
4526 &["SG4", "SG8"],
4527 "SEQ",
4528 0,
4529 "Z01",
4530 "SG10",
4531 "CCI",
4532 2,
4533 "ZA6",
4534 )
4535 }
4536 };
4537 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
4538 for i in 0..sg8_count {
4539 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
4540 if !seqs.iter().any(|s| {
4541 s.elements
4542 .first()
4543 .and_then(|e: &Vec<String>| e.first())
4544 .is_some_and(|v: &String| v == "Z01")
4545 }) {
4546 continue;
4547 }
4548 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
4549 for j in 0..sg10_count {
4550 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
4551 if !ccis.iter().any(|s| {
4552 s.elements
4553 .get(2)
4554 .and_then(|e: &Vec<String>| e.first())
4555 .is_some_and(|v: &String| v == "ZA6")
4556 }) {
4557 continue;
4558 }
4559 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
4560 if cavs.iter().any(|s| {
4561 s.elements
4562 .first()
4563 .and_then(|e: &Vec<String>| e.first())
4564 .is_some_and(|v: &String| v == "E02")
4565 }) {
4566 return ConditionResult::True;
4567 }
4568 }
4569 }
4570 ConditionResult::False
4571 }
4572
4573 fn evaluate_201(&self, _ctx: &EvaluationContext) -> ConditionResult {
4575 ConditionResult::Unknown
4577 }
4578
4579 fn evaluate_202(&self, ctx: &EvaluationContext) -> ConditionResult {
4582 use std::collections::HashSet;
4583 let loc_zeitraum_ids: HashSet<String> = ctx
4585 .find_segments("LOC")
4586 .into_iter()
4587 .filter_map(|s| s.elements.get(1)?.get(3).cloned())
4588 .filter(|v| !v.is_empty())
4589 .collect();
4590 if loc_zeitraum_ids.is_empty() {
4591 return ConditionResult::False;
4592 }
4593 let matching_seq = ctx
4595 .find_segments_with_qualifier("SEQ", 0, "Z78")
4596 .into_iter()
4597 .any(|s| {
4598 s.elements
4599 .get(1)
4600 .and_then(|e: &Vec<String>| e.first())
4601 .is_some_and(|v: &String| {
4602 !v.is_empty() && loc_zeitraum_ids.contains(v.as_str())
4603 })
4604 });
4605 if !matching_seq {
4606 return ConditionResult::False;
4607 }
4608 ctx.has_qualifier("RFF", 0, "Z39")
4610 }
4611
4612 fn evaluate_203(&self, ctx: &EvaluationContext) -> ConditionResult {
4614 let sts_segs = ctx.find_segments("STS");
4615 let found = sts_segs.iter().any(|s| {
4616 s.elements
4617 .first()
4618 .and_then(|e| e.first())
4619 .is_some_and(|v| v == "7")
4620 && s.elements.get(2).and_then(|e| e.first()).is_some_and(|v| {
4621 ["E06", "Z39", "ZC6", "ZC7", "ZT6", "ZT7"].contains(&v.as_str())
4622 })
4623 });
4624 ConditionResult::from(found)
4625 }
4626
4627 fn evaluate_204(&self, ctx: &EvaluationContext) -> ConditionResult {
4630 for qual in &["Z03", "ZA3", "ZA4"] {
4632 if matches!(
4633 ctx.any_group_has_qualifier_without(
4634 "SEQ",
4635 0,
4636 qual,
4637 "RFF",
4638 0,
4639 "Z14",
4640 &["SG4", "SG8"]
4641 ),
4642 ConditionResult::True
4643 ) {
4644 return ConditionResult::True;
4645 }
4646 }
4647 ConditionResult::False
4648 }
4649
4650 fn evaluate_205(&self, ctx: &EvaluationContext) -> ConditionResult {
4652 let loc_segs = ctx.find_segments("LOC");
4653 let found = loc_segs.iter().any(|s| {
4654 s.elements
4655 .first()
4656 .and_then(|e| e.first())
4657 .is_some_and(|v| v == "Z19")
4658 });
4659 ConditionResult::from(found)
4660 }
4661
4662 fn evaluate_206(&self, ctx: &EvaluationContext) -> ConditionResult {
4664 let sts_segs = ctx.find_segments("STS");
4665 let found = sts_segs.iter().any(|s| {
4666 s.elements
4667 .first()
4668 .and_then(|e| e.first())
4669 .is_some_and(|v| v == "7")
4670 && s.elements
4671 .get(2)
4672 .and_then(|e| e.first())
4673 .is_some_and(|v| ["ZG5"].contains(&v.as_str()))
4674 });
4675 ConditionResult::from(!found)
4676 }
4677
4678 fn evaluate_209(&self, ctx: &EvaluationContext) -> ConditionResult {
4680 ConditionResult::from(ctx.self_segment_value_equals("DTM", 0, 2, "303"))
4681 }
4682
4683 fn evaluate_210(&self, ctx: &EvaluationContext) -> ConditionResult {
4685 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
4687 let found = cci_segs.iter().any(|s| {
4688 s.elements
4689 .get(2)
4690 .and_then(|e| e.first())
4691 .is_some_and(|v| v == "ZA6")
4692 });
4693 ConditionResult::from(found)
4694 }
4695
4696 fn evaluate_212(&self, ctx: &EvaluationContext) -> ConditionResult {
4698 let nad_segs = ctx.find_segments("NAD");
4699 let found = nad_segs.iter().any(|s| {
4700 s.elements
4701 .get(3)
4702 .and_then(|e| e.first())
4703 .is_some_and(|v| !v.is_empty())
4704 });
4705 ConditionResult::from(!found)
4706 }
4707
4708 fn evaluate_213(&self, ctx: &EvaluationContext) -> ConditionResult {
4710 let nad_segs = ctx.find_segments("NAD");
4711 let found = nad_segs.iter().any(|s| {
4712 s.elements
4713 .first()
4714 .and_then(|e| e.first())
4715 .is_some_and(|v| v == "Z09")
4716 });
4717 ConditionResult::from(found)
4718 }
4719
4720 fn evaluate_215(&self, ctx: &EvaluationContext) -> ConditionResult {
4722 let has_cci_e13 = ctx.scoped_find_segments_in("SG8", "CCI").iter().any(|s| {
4726 s.elements
4727 .get(2)
4728 .and_then(|e| e.first())
4729 .is_some_and(|v| v == "E13")
4730 });
4731 let has_cav_mme = ctx.scoped_find_segments_in("SG8", "CAV").iter().any(|s| {
4732 s.elements
4733 .first()
4734 .and_then(|e| e.first())
4735 .is_some_and(|v| v == "MME")
4736 });
4737 ConditionResult::from(has_cci_e13 && has_cav_mme)
4738 }
4739
4740 fn evaluate_216(&self, ctx: &EvaluationContext) -> ConditionResult {
4742 let cci_segs = ctx.find_segments("CCI");
4743 let found = cci_segs.iter().any(|s| {
4744 s.elements
4745 .get(2)
4746 .and_then(|e| e.first())
4747 .is_some_and(|v| v == "Z88")
4748 });
4749 ConditionResult::from(found)
4750 }
4751
4752 fn evaluate_217(&self, ctx: &EvaluationContext) -> ConditionResult {
4754 let rff_segs = ctx.find_segments("RFF");
4755 let found = rff_segs.iter().any(|s| {
4756 s.elements
4757 .first()
4758 .and_then(|e| e.first())
4759 .is_some_and(|v| v == "Z49")
4760 });
4761 ConditionResult::from(found)
4762 }
4763
4764 fn evaluate_219(&self, ctx: &EvaluationContext) -> ConditionResult {
4766 let nad_segs = ctx.find_segments("NAD");
4767 let found = nad_segs.iter().any(|s| {
4768 s.elements
4769 .first()
4770 .and_then(|e| e.first())
4771 .is_some_and(|v| v == "Z65")
4772 });
4773 ConditionResult::from(found)
4774 }
4775
4776 fn evaluate_220(&self, ctx: &EvaluationContext) -> ConditionResult {
4778 let seq_segs = ctx.scoped_find_segments_in("SG8", "SEQ");
4780 let has_seq = seq_segs.iter().any(|s| {
4781 s.elements
4782 .first()
4783 .and_then(|e| e.first())
4784 .is_some_and(|v| ["Z01", "Z98"].contains(&v.as_str()))
4785 });
4786 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
4787 let has_cci = cci_segs.iter().any(|s| {
4788 s.elements
4789 .first()
4790 .and_then(|e| e.first())
4791 .is_some_and(|v| v == "Z30")
4792 && s.elements
4793 .get(2)
4794 .and_then(|e| e.first())
4795 .is_some_and(|v| v == "Z06")
4796 });
4797 ConditionResult::from(has_seq && has_cci)
4798 }
4799
4800 fn evaluate_221(&self, ctx: &EvaluationContext) -> ConditionResult {
4802 let has_seq_z15 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z15").is_empty();
4804 if !has_seq_z15 {
4805 return ConditionResult::True;
4806 }
4807 ctx.any_group_has_qualifier_without("SEQ", 0, "Z15", "RFF", 0, "Z18", &["SG4", "SG8"])
4809 }
4810
4811 fn evaluate_223(&self, ctx: &EvaluationContext) -> ConditionResult {
4818 let Some(blocks) = sg8_blocks(ctx) else {
4819 return ConditionResult::Unknown;
4820 };
4821 let loc_ids: Vec<String> = ctx
4822 .find_segments_with_qualifier("LOC", 0, "Z16")
4823 .iter()
4824 .filter_map(|s| s.elements.get(1).and_then(|e| e.first()).cloned())
4825 .collect();
4826 let malo_refs = |b: &Sg8Block| -> Vec<String> {
4827 b.malo_refs
4828 .iter()
4829 .filter(|id| loc_ids.contains(id))
4830 .cloned()
4831 .collect()
4832 };
4833 let erzeugung: Vec<String> = blocks
4835 .iter()
4836 .filter(|b| b.seq == "Z01")
4837 .filter(|b| {
4838 b.sg10.iter().any(|(ccis, _)| {
4839 ccis.iter().any(|c| {
4840 component(c, 0, 0) == Some("Z30") && component(c, 2, 0) == Some("Z06")
4841 })
4842 })
4843 })
4844 .flat_map(|b| malo_refs(b))
4845 .collect();
4846 let referenced = blocks
4847 .iter()
4848 .filter(|b| b.seq != "Z01")
4849 .any(|b| malo_refs(b).iter().any(|id| erzeugung.contains(id)));
4850 ConditionResult::from(referenced)
4851 }
4852
4853 fn evaluate_224(&self, ctx: &EvaluationContext) -> ConditionResult {
4855 let has_seq_ze7 = !ctx.find_segments_with_qualifier("SEQ", 0, "ZE7").is_empty();
4857 if !has_seq_ze7 {
4858 return ConditionResult::True;
4859 }
4860 ctx.any_group_has_qualifier_without("SEQ", 0, "ZE7", "RFF", 0, "Z18", &["SG4", "SG8"])
4861 }
4862
4863 fn evaluate_227(&self, ctx: &EvaluationContext) -> ConditionResult {
4865 let r1 = ctx.filtered_parent_child_has_qualifier(
4867 &["SG4", "SG8"],
4868 "SEQ",
4869 0,
4870 "Z98",
4871 "SG10",
4872 "CAV",
4873 0,
4874 "E14",
4875 );
4876 if r1 == ConditionResult::True {
4877 return ConditionResult::True;
4878 }
4879 ctx.filtered_parent_child_has_qualifier(
4880 &["SG4", "SG8"],
4881 "SEQ",
4882 0,
4883 "Z98",
4884 "SG10",
4885 "CAV",
4886 0,
4887 "ETK",
4888 )
4889 }
4890
4891 fn evaluate_229(&self, ctx: &EvaluationContext) -> ConditionResult {
4894 use std::collections::HashSet;
4895 let target_quals: HashSet<&str> = ["Z58", "ZC9", "ZD0", "ZD6"].iter().cloned().collect();
4896 let seq_quals = ctx.collect_group_values("SEQ", 0, 0, &["SG4", "SG8"]);
4898 let seq_zeitraums = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
4899 let rff_quals = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG8"]);
4901 let rff_codes = ctx.collect_group_values("RFF", 0, 1, &["SG4", "SG8"]);
4902 let mut seen: HashSet<(String, String, String)> = HashSet::new();
4904 for (idx, seq_qual) in &seq_quals {
4905 if seq_qual.is_empty() || !target_quals.contains(seq_qual.as_str()) {
4906 continue;
4907 }
4908 let zeitraum_id = seq_zeitraums
4909 .iter()
4910 .find(|(i, _)| i == idx)
4911 .map(|(_, v)| v.as_str())
4912 .unwrap_or("");
4913 for (ridx, rff_qual) in rff_quals.iter() {
4915 if ridx != idx || rff_qual != "Z33" {
4916 continue;
4917 }
4918 if let Some((_, obj_code)) = rff_codes.iter().find(|(i, _)| i == ridx) {
4919 if obj_code.is_empty() {
4920 continue;
4921 }
4922 let key = (seq_qual.clone(), zeitraum_id.to_string(), obj_code.clone());
4923 if seen.contains(&key) {
4924 return ConditionResult::True;
4925 }
4926 seen.insert(key);
4927 }
4928 }
4929 }
4930 ConditionResult::False
4931 }
4932
4933 fn evaluate_232(&self, ctx: &EvaluationContext) -> ConditionResult {
4935 let cci_segs = ctx.find_segments("CCI");
4936 let found = cci_segs.iter().any(|s| {
4937 s.elements
4938 .get(2)
4939 .and_then(|e| e.first())
4940 .is_some_and(|v| v == "Z83")
4941 });
4942 ConditionResult::from(found)
4943 }
4944
4945 fn evaluate_233(&self, ctx: &EvaluationContext) -> ConditionResult {
4947 ctx.external.evaluate("recipient_role_check")
4948 }
4949
4950 fn evaluate_234(&self, ctx: &EvaluationContext) -> ConditionResult {
4952 let cci_segs = ctx.find_segments("CCI");
4953 let found = cci_segs.iter().any(|s| {
4954 s.elements
4955 .get(2)
4956 .and_then(|e| e.first())
4957 .is_some_and(|v| v == "Z83")
4958 });
4959 ConditionResult::from(found)
4960 }
4961
4962 fn evaluate_237(&self, ctx: &EvaluationContext) -> ConditionResult {
4964 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
4967 let found = pia_segs.iter().any(|s| {
4968 s.elements
4969 .first()
4970 .and_then(|e| e.first())
4971 .is_some_and(|v| v == "Z02")
4972 && s.elements
4973 .get(1)
4974 .and_then(|e| e.first())
4975 .is_some_and(|v| v.starts_with("1-08") && v.contains("AGS"))
4976 });
4977 ConditionResult::from(found)
4978 }
4979
4980 fn evaluate_238(&self, ctx: &EvaluationContext) -> ConditionResult {
4982 let ide_segs = ctx.find_segments("IDE");
4983 let found = ide_segs.iter().any(|s| {
4984 s.elements
4985 .first()
4986 .and_then(|e| e.first())
4987 .is_some_and(|v| v == "24")
4988 });
4989 ConditionResult::from(!found)
4990 }
4991
4992 fn evaluate_239(&self, ctx: &EvaluationContext) -> ConditionResult {
4994 let cci_segs = ctx.scoped_find_segments_in("SG10", "CCI");
4996 let found = cci_segs.iter().any(|s| {
4997 s.elements
4998 .first()
4999 .and_then(|e| e.first())
5000 .is_some_and(|v| v == "Z17")
5001 });
5002 ConditionResult::from(found)
5003 }
5004
5005 fn evaluate_240(&self, ctx: &EvaluationContext) -> ConditionResult {
5007 let seq_segs = ctx.find_segments("SEQ");
5008 let found = seq_segs.iter().any(|s| {
5009 s.elements
5010 .first()
5011 .and_then(|e| e.first())
5012 .is_some_and(|v| ["Z01"].contains(&v.as_str()))
5013 });
5014 ConditionResult::from(found)
5015 }
5016
5017 fn evaluate_241(&self, ctx: &EvaluationContext) -> ConditionResult {
5019 ctx.external.evaluate("recipient_role_check")
5020 }
5021
5022 fn evaluate_243(&self, ctx: &EvaluationContext) -> ConditionResult {
5024 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
5026 let found = cci_segs.iter().any(|s| {
5027 s.elements
5028 .first()
5029 .and_then(|e| e.first())
5030 .is_some_and(|v| v == "6")
5031 && s.elements
5032 .get(2)
5033 .and_then(|e| e.first())
5034 .is_some_and(|v| v == "ZA8")
5035 });
5036 ConditionResult::from(found)
5037 }
5038
5039 fn evaluate_244(&self, ctx: &EvaluationContext) -> ConditionResult {
5041 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
5043 let found = cci_segs.iter().any(|s| {
5044 s.elements
5045 .first()
5046 .and_then(|e| e.first())
5047 .is_some_and(|v| v == "6")
5048 && s.elements
5049 .get(2)
5050 .and_then(|e| e.first())
5051 .is_some_and(|v| v == "ZA9")
5052 });
5053 ConditionResult::from(found)
5054 }
5055
5056 fn evaluate_248(&self, _ctx: &EvaluationContext) -> ConditionResult {
5058 ConditionResult::Unknown
5060 }
5061
5062 fn evaluate_249(&self, ctx: &EvaluationContext) -> ConditionResult {
5064 let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
5066 if sts_segs.len() <= 1 {
5067 return ConditionResult::True;
5068 }
5069 let first_val = sts_segs[0].elements.first().and_then(|e| e.get(1));
5070 let all_same = sts_segs
5071 .iter()
5072 .all(|s| s.elements.first().and_then(|e| e.get(1)) == first_val);
5073 ConditionResult::from(all_same)
5074 }
5075
5076 fn evaluate_251(&self, ctx: &EvaluationContext) -> ConditionResult {
5078 ctx.external.evaluate("sender_role_check")
5079 }
5080
5081 fn evaluate_252(&self, ctx: &EvaluationContext) -> ConditionResult {
5083 let unb_segs = ctx.find_segments("UNB");
5084 let found = unb_segs.iter().any(|s| {
5085 s.elements
5086 .get(4)
5087 .and_then(|e| e.first())
5088 .is_some_and(|v| !v.is_empty())
5089 });
5090 ConditionResult::from(found)
5091 }
5092
5093 fn evaluate_254(&self, _ctx: &EvaluationContext) -> ConditionResult {
5095 ConditionResult::True }
5098
5099 fn evaluate_255(&self, _ctx: &EvaluationContext) -> ConditionResult {
5101 ConditionResult::Unknown
5103 }
5104
5105 fn evaluate_256(&self, ctx: &EvaluationContext) -> ConditionResult {
5107 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
5110 let found = pia_segs.iter().any(|s| {
5111 s.elements
5112 .first()
5113 .and_then(|e| e.first())
5114 .is_some_and(|v| v == "5")
5115 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5116 (v.contains(":1.8.") || v.contains(":2.8.")) && v.starts_with("1-")
5117 })
5118 });
5119 ConditionResult::from(found)
5120 }
5121
5122 fn evaluate_257(&self, ctx: &EvaluationContext) -> ConditionResult {
5124 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
5127 let found = pia_segs.iter().any(|s| {
5128 s.elements
5129 .first()
5130 .and_then(|e| e.first())
5131 .is_some_and(|v| v == "5")
5132 && s.elements
5133 .get(1)
5134 .and_then(|e| e.first())
5135 .is_some_and(|v| v.contains(":1.9.") && v.starts_with("1-"))
5136 });
5137 ConditionResult::from(found)
5138 }
5139
5140 fn evaluate_259(&self, ctx: &EvaluationContext) -> ConditionResult {
5142 let pia_segs = ctx.find_segments("PIA");
5143 let found = pia_segs.iter().any(|s| {
5144 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5145 let prefixes = ["1-01", "1-03", "1-05"];
5146 prefixes.iter().any(|p| v.starts_with(p))
5147 })
5148 });
5149 ConditionResult::from(found)
5150 }
5151
5152 fn evaluate_261(&self, ctx: &EvaluationContext) -> ConditionResult {
5154 let pia_segs = ctx.find_segments("PIA");
5155 let found = pia_segs.iter().any(|s| {
5156 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5157 let prefixes = [
5158 "1-07-1", "2", "1-10-1", "2", "4", "5", "6", "7", "8", "9", "1-11-1",
5159 ];
5160 prefixes.iter().any(|p| v.starts_with(p))
5161 })
5162 });
5163 ConditionResult::from(found)
5164 }
5165
5166 fn evaluate_262(&self, _ctx: &EvaluationContext) -> ConditionResult {
5168 ConditionResult::Unknown
5170 }
5171
5172 fn evaluate_265(&self, ctx: &EvaluationContext) -> ConditionResult {
5177 let Some(blocks) = sg8_blocks(ctx) else {
5178 return ConditionResult::Unknown;
5179 };
5180 let found = blocks
5181 .iter()
5182 .filter(|b| b.seq == "Z01" || b.seq == "Z98")
5183 .any(|b| {
5184 b.sg10.iter().any(|(ccis, cavs)| {
5185 ccis.iter().any(|c| component(c, 2, 0) == Some("ZA6"))
5186 && cavs.iter().any(|c| component(c, 0, 0) == Some("Z36"))
5187 })
5188 });
5189 ConditionResult::from(found)
5190 }
5191
5192 fn evaluate_266(&self, ctx: &EvaluationContext) -> ConditionResult {
5195 let nav = match ctx.navigator {
5196 Some(n) => n,
5197 None => {
5198 return ctx.filtered_parent_child_has_qualifier(
5200 &["SG4", "SG8"],
5201 "SEQ",
5202 0,
5203 "Z01",
5204 "SG10",
5205 "CAV",
5206 0,
5207 "Z36",
5208 );
5209 }
5210 };
5211 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
5212 for i in 0..sg8_count {
5213 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
5214 for j in 0..sg10_count {
5215 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
5217 let has_cci_za6 = ccis.iter().any(|s| {
5218 s.elements
5219 .get(2)
5220 .and_then(|e: &Vec<String>| e.first())
5221 .is_some_and(|v: &String| v == "ZA6")
5222 });
5223 if has_cci_za6 {
5224 let cavs =
5225 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
5226 if cavs.iter().any(|s| {
5227 s.elements
5228 .first()
5229 .and_then(|e: &Vec<String>| e.first())
5230 .is_some_and(|v: &String| v == "Z36")
5231 }) {
5232 return ConditionResult::True;
5233 }
5234 }
5235 }
5236 }
5237 ConditionResult::False
5238 }
5239
5240 fn evaluate_267(&self, ctx: &EvaluationContext) -> ConditionResult {
5242 let seq_segs = ctx.find_segments("SEQ");
5243 let found = seq_segs.iter().any(|s| {
5244 s.elements
5245 .first()
5246 .and_then(|e| e.first())
5247 .is_some_and(|v| ["Z38"].contains(&v.as_str()))
5248 });
5249 ConditionResult::from(!found)
5250 }
5251
5252 fn evaluate_268(&self, _ctx: &EvaluationContext) -> ConditionResult {
5254 ConditionResult::True
5256 }
5257
5258 fn evaluate_269(&self, _ctx: &EvaluationContext) -> ConditionResult {
5260 ConditionResult::Unknown
5262 }
5263
5264 fn evaluate_270(&self, ctx: &EvaluationContext) -> ConditionResult {
5266 let pia_segs = ctx.find_segments("PIA");
5267 let found = pia_segs.iter().any(|s| {
5268 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5269 let prefixes = ["1-02", "1-04", "1-06", "1-09"];
5270 prefixes.iter().any(|p| v.starts_with(p))
5271 })
5272 });
5273 ConditionResult::from(found)
5274 }
5275
5276 fn evaluate_273(&self, ctx: &EvaluationContext) -> ConditionResult {
5278 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
5281 let found = pia_segs.iter().any(|s| {
5282 s.elements
5283 .first()
5284 .and_then(|e| e.first())
5285 .is_some_and(|v| v == "5")
5286 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5287 v.starts_with("1-")
5288 && (v.contains(":1.8.") || v.contains(":2.8.") || v.contains(":1.29."))
5289 })
5290 });
5291 ConditionResult::from(found)
5292 }
5293
5294 fn evaluate_279(&self, ctx: &EvaluationContext) -> ConditionResult {
5296 let sts_segs = ctx.find_segments("STS");
5297 let found = sts_segs.iter().any(|s| {
5298 s.elements
5299 .first()
5300 .and_then(|e| e.first())
5301 .is_some_and(|v| v == "7")
5302 && s.elements
5303 .get(3)
5304 .and_then(|e| e.first())
5305 .is_some_and(|v| ["ZW4", "ZAP"].contains(&v.as_str()))
5306 });
5307 ConditionResult::from(found)
5308 }
5309
5310 fn evaluate_280(&self, ctx: &EvaluationContext) -> ConditionResult {
5312 ctx.external.evaluate("sector_check")
5315 }
5316
5317 fn evaluate_282(&self, ctx: &EvaluationContext) -> ConditionResult {
5319 let pia_segs = ctx.find_segments("PIA");
5321 let found = pia_segs.iter().any(|s| {
5322 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5323 v.starts_with("1-01-6-005")
5324 || v.starts_with("1-01-9-001")
5325 || v.starts_with("1-01-9-002")
5326 || v.starts_with("1-07-3-001")
5327 || v.starts_with("1-08-1-001")
5328 || v.starts_with("1-08-3-001")
5329 || v.starts_with("1-08-4-001")
5330 || v.starts_with("1-08-4-002")
5331 || v.starts_with("1-08-4-003")
5332 || v.starts_with("1-08-5")
5333 })
5334 });
5335 ConditionResult::from(found)
5336 }
5337
5338 fn evaluate_284(&self, ctx: &EvaluationContext) -> ConditionResult {
5344 use crate::eval::CodelistColumn;
5352 let any_match = ctx.scoped_find_segments("PIA").iter().any(|s| {
5353 let is_z02 = s
5354 .elements
5355 .first()
5356 .and_then(|e| e.first())
5357 .is_some_and(|v| v == "Z02");
5358 if !is_z02 {
5359 return false;
5360 }
5361 let code = match s.elements.get(1).and_then(|e| e.first()) {
5362 Some(c) if !c.is_empty() => c,
5363 _ => return false,
5364 };
5365 ctx.codelist
5366 .flag(code, CodelistColumn::UtilmdCodeverwendung)
5367 .unwrap_or(false)
5368 });
5369 ConditionResult::from(any_match)
5370 }
5371
5372 fn evaluate_285(&self, ctx: &EvaluationContext) -> ConditionResult {
5374 let pia_segs = ctx.find_segments("PIA");
5376 let found = pia_segs.iter().any(|s| {
5377 s.elements
5378 .get(1)
5379 .and_then(|e| e.first())
5380 .is_some_and(|v| v.contains("1-08-3") && v.contains("AGS"))
5381 });
5382 ConditionResult::from(found)
5383 }
5384
5385 fn evaluate_286(&self, ctx: &EvaluationContext) -> ConditionResult {
5387 let pia_segs = ctx.find_segments("PIA");
5389 let found = pia_segs.iter().any(|s| {
5390 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
5391 (v.starts_with("1-08-1")
5392 || v.starts_with("1-08-2")
5393 || v.starts_with("1-08-4")
5394 || v.starts_with("1-08-5"))
5395 && v.contains("AGS")
5396 && v.contains("KG")
5397 })
5398 });
5399 ConditionResult::from(found)
5400 }
5401
5402 fn evaluate_287(&self, _ctx: &EvaluationContext) -> ConditionResult {
5404 ConditionResult::Unknown
5406 }
5407
5408 fn evaluate_288(&self, ctx: &EvaluationContext) -> ConditionResult {
5410 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
5413 let found = pia_segs.iter().any(|s| {
5414 s.elements
5415 .first()
5416 .and_then(|e| e.first())
5417 .is_some_and(|v| v == "5")
5418 && s.elements
5419 .get(1)
5420 .and_then(|e| e.first())
5421 .is_some_and(|v| v.contains(":2.9.") && v.starts_with("1-"))
5422 });
5423 ConditionResult::from(found)
5424 }
5425
5426 fn evaluate_291(&self, ctx: &EvaluationContext) -> ConditionResult {
5428 let rff_segs = ctx.scoped_find_segments_in("SG8", "RFF");
5430 let found = rff_segs.iter().any(|s| {
5431 s.elements
5432 .first()
5433 .and_then(|e| e.first())
5434 .is_some_and(|v| v == "Z37")
5435 });
5436 ConditionResult::from(found)
5437 }
5438
5439 fn evaluate_292(&self, ctx: &EvaluationContext) -> ConditionResult {
5441 ctx.external.evaluate("code_list_membership_check")
5442 }
5443
5444 fn evaluate_293(&self, ctx: &EvaluationContext) -> ConditionResult {
5446 let loc_segs = ctx.find_segments("LOC");
5447 let found = loc_segs.iter().any(|s| {
5448 s.elements
5449 .first()
5450 .and_then(|e| e.first())
5451 .is_some_and(|v| v == "Z22")
5452 });
5453 ConditionResult::from(found)
5454 }
5455
5456 fn evaluate_294(&self, ctx: &EvaluationContext) -> ConditionResult {
5458 let loc_segs = ctx.find_segments("LOC");
5459 let found = loc_segs.iter().any(|s| {
5460 s.elements
5461 .first()
5462 .and_then(|e| e.first())
5463 .is_some_and(|v| v == "Z18")
5464 });
5465 ConditionResult::from(found)
5466 }
5467
5468 fn evaluate_295(&self, ctx: &EvaluationContext) -> ConditionResult {
5470 let loc_segs = ctx.find_segments("LOC");
5471 let found = loc_segs.iter().any(|s| {
5472 s.elements
5473 .first()
5474 .and_then(|e| e.first())
5475 .is_some_and(|v| v == "Z15")
5476 });
5477 ConditionResult::from(!found)
5478 }
5479
5480 fn evaluate_296(&self, ctx: &EvaluationContext) -> ConditionResult {
5482 let loc_segs = ctx.find_segments("LOC");
5483 let found = loc_segs.iter().any(|s| {
5484 s.elements
5485 .first()
5486 .and_then(|e| e.first())
5487 .is_some_and(|v| v == "Z20")
5488 });
5489 ConditionResult::from(found)
5490 }
5491
5492 fn evaluate_297(&self, ctx: &EvaluationContext) -> ConditionResult {
5494 let loc_segs = ctx.find_segments("LOC");
5495 let found = loc_segs.iter().any(|s| {
5496 s.elements
5497 .first()
5498 .and_then(|e| e.first())
5499 .is_some_and(|v| v == "Z18")
5500 });
5501 ConditionResult::from(!found)
5502 }
5503
5504 fn evaluate_298(&self, ctx: &EvaluationContext) -> ConditionResult {
5506 let loc_segs = ctx.find_segments("LOC");
5507 let found = loc_segs.iter().any(|s| {
5508 s.elements
5509 .first()
5510 .and_then(|e| e.first())
5511 .is_some_and(|v| v == "Z20")
5512 });
5513 ConditionResult::from(!found)
5514 }
5515
5516 fn evaluate_299(&self, ctx: &EvaluationContext) -> ConditionResult {
5518 let loc_segs = ctx.find_segments("LOC");
5519 let found = loc_segs.iter().any(|s| {
5520 s.elements
5521 .first()
5522 .and_then(|e| e.first())
5523 .is_some_and(|v| v == "Z19")
5524 });
5525 ConditionResult::from(!found)
5526 }
5527
5528 fn evaluate_300(&self, ctx: &EvaluationContext) -> ConditionResult {
5530 let seq_segs = ctx.find_segments("SEQ");
5531 let found = seq_segs.iter().any(|s| {
5532 s.elements
5533 .first()
5534 .and_then(|e| e.first())
5535 .is_some_and(|v| ["Z15", "ZE7"].contains(&v.as_str()))
5536 });
5537 ConditionResult::from(!found)
5538 }
5539
5540 fn evaluate_301(&self, ctx: &EvaluationContext) -> ConditionResult {
5542 let bgm_segs = ctx.find_segments("BGM");
5543 let found = bgm_segs.iter().any(|s| {
5544 s.elements
5545 .first()
5546 .and_then(|e| e.first())
5547 .is_some_and(|v| v == "E03")
5548 });
5549 ConditionResult::from(found)
5550 }
5551
5552 fn evaluate_302(&self, ctx: &EvaluationContext) -> ConditionResult {
5554 let seq_segs = ctx.find_segments("SEQ");
5555 let found = seq_segs.iter().any(|s| {
5556 s.elements
5557 .first()
5558 .and_then(|e| e.first())
5559 .is_some_and(|v| ["Z08"].contains(&v.as_str()))
5560 });
5561 ConditionResult::from(!found)
5562 }
5563
5564 fn evaluate_303(&self, ctx: &EvaluationContext) -> ConditionResult {
5566 let seq_segs = ctx.find_segments("SEQ");
5567 let found = seq_segs.iter().any(|s| {
5568 s.elements
5569 .first()
5570 .and_then(|e| e.first())
5571 .is_some_and(|v| ["Z21"].contains(&v.as_str()))
5572 });
5573 ConditionResult::from(!found)
5574 }
5575
5576 fn evaluate_304(&self, ctx: &EvaluationContext) -> ConditionResult {
5578 let seq_segs = ctx.find_segments("SEQ");
5579 let found = seq_segs.iter().any(|s| {
5580 s.elements
5581 .first()
5582 .and_then(|e| e.first())
5583 .is_some_and(|v| ["Z22"].contains(&v.as_str()))
5584 });
5585 ConditionResult::from(found)
5586 }
5587
5588 fn evaluate_305(&self, ctx: &EvaluationContext) -> ConditionResult {
5590 let seq_segs = ctx.find_segments("SEQ");
5591 let found = seq_segs.iter().any(|s| {
5592 s.elements
5593 .first()
5594 .and_then(|e| e.first())
5595 .is_some_and(|v| ["Z24"].contains(&v.as_str()))
5596 });
5597 ConditionResult::from(found)
5598 }
5599
5600 fn evaluate_306(&self, ctx: &EvaluationContext) -> ConditionResult {
5602 use std::collections::HashSet;
5603 let loc_z22_ids: HashSet<String> = ctx
5605 .find_segments_with_qualifier("LOC", 0, "Z22")
5606 .into_iter()
5607 .filter_map(|s| s.elements.get(1)?.get(3).cloned())
5608 .filter(|v| !v.is_empty())
5609 .collect();
5610 if loc_z22_ids.is_empty() {
5611 return ConditionResult::False;
5612 }
5613 let has_match = ctx
5615 .find_segments_with_qualifier("SEQ", 0, "Z58")
5616 .iter()
5617 .any(|s| {
5618 s.elements
5619 .get(1)
5620 .and_then(|e: &Vec<String>| e.first())
5621 .is_some_and(|v: &String| !v.is_empty() && loc_z22_ids.contains(v.as_str()))
5622 });
5623 ConditionResult::from(has_match)
5624 }
5625
5626 fn evaluate_307(&self, ctx: &EvaluationContext) -> ConditionResult {
5629 let seq_segs = ctx.find_segments_with_qualifier("SEQ", 0, "Z58");
5630 if seq_segs.is_empty() {
5631 return ConditionResult::Unknown;
5632 }
5633 let loc_segs = ctx.find_segments_with_qualifier("LOC", 0, "Z22");
5634 let loc_z22_zeitraum_ids: Vec<&str> = loc_segs
5635 .iter()
5636 .filter_map(|s| s.elements.get(1).and_then(|e| e.get(3)).map(|v| v.as_str()))
5637 .filter(|v| !v.is_empty())
5638 .collect();
5639 ConditionResult::from(seq_segs.iter().any(|seq| {
5640 let zid = seq
5641 .elements
5642 .get(1)
5643 .and_then(|e: &Vec<String>| e.first())
5644 .map(|v| v.as_str())
5645 .unwrap_or("");
5646 !zid.is_empty() && !loc_z22_zeitraum_ids.contains(&zid)
5647 }))
5648 }
5649
5650 fn evaluate_309(&self, ctx: &EvaluationContext) -> ConditionResult {
5652 let loc_segs = ctx.find_segments("LOC");
5653 let found = loc_segs.iter().any(|s| {
5654 s.elements
5655 .first()
5656 .and_then(|e| e.first())
5657 .is_some_and(|v| v == "Z22")
5658 });
5659 ConditionResult::from(!found)
5660 }
5661
5662 fn evaluate_314(&self, ctx: &EvaluationContext) -> ConditionResult {
5664 ctx.external.evaluate("code_list_membership_check")
5665 }
5666
5667 fn evaluate_315(&self, ctx: &EvaluationContext) -> ConditionResult {
5669 ctx.external.evaluate("data_clearing_required")
5670 }
5671
5672 fn evaluate_316(&self, ctx: &EvaluationContext) -> ConditionResult {
5674 ctx.any_group_has_qualifier_without("SEQ", 0, "Z03", "RFF", 0, "Z14", &["SG4", "SG8"])
5675 }
5676
5677 fn evaluate_317(&self, ctx: &EvaluationContext) -> ConditionResult {
5679 let found = !ctx.find_segments_with_qualifier("DTM", 0, "92").is_empty();
5681 if found {
5682 ConditionResult::True
5683 } else {
5684 ConditionResult::Unknown
5685 }
5686 }
5687
5688 fn evaluate_318(&self, ctx: &EvaluationContext) -> ConditionResult {
5690 let found = !ctx.find_segments_with_qualifier("DTM", 0, "93").is_empty();
5692 if found {
5693 ConditionResult::True
5694 } else {
5695 ConditionResult::Unknown
5696 }
5697 }
5698
5699 fn evaluate_321(&self, ctx: &EvaluationContext) -> ConditionResult {
5701 let com_segs = ctx.find_segments("COM");
5702 let has_em = com_segs.iter().any(|s| {
5703 s.elements
5704 .first()
5705 .and_then(|e| e.get(1))
5706 .is_some_and(|v| v == "EM")
5707 });
5708 ConditionResult::from(has_em)
5709 }
5710
5711 fn evaluate_322(&self, ctx: &EvaluationContext) -> ConditionResult {
5713 let com_segs = ctx.find_segments("COM");
5714 let has_phone = com_segs.iter().any(|s| {
5715 s.elements
5716 .first()
5717 .and_then(|e| e.get(1))
5718 .is_some_and(|v| matches!(v.as_str(), "TE" | "FX" | "AJ" | "AL"))
5719 });
5720 ConditionResult::from(has_phone)
5721 }
5722
5723 fn evaluate_323(&self, ctx: &EvaluationContext) -> ConditionResult {
5725 ctx.external.evaluate("code_list_membership_check")
5726 }
5727
5728 fn evaluate_327(&self, ctx: &EvaluationContext) -> ConditionResult {
5731 const THRESHOLD: &str = "202212312300+00";
5732 let seq_zeitraum_ids: Vec<String> = ctx
5733 .find_segments("SEQ")
5734 .iter()
5735 .filter_map(|s| {
5736 s.elements
5737 .get(1)
5738 .and_then(|e: &Vec<String>| e.first())
5739 .cloned()
5740 })
5741 .filter(|v| !v.is_empty())
5742 .collect();
5743 if seq_zeitraum_ids.is_empty() {
5744 return ConditionResult::Unknown;
5745 }
5746 let rff_segs = ctx.find_segments("RFF");
5747 let matching_rff = rff_segs.iter().any(|rff| {
5748 let qual = rff
5749 .elements
5750 .first()
5751 .and_then(|e: &Vec<String>| e.first())
5752 .map(|v| v.as_str())
5753 .unwrap_or("");
5754 if !["Z47", "Z48", "Z49"].contains(&qual) {
5755 return false;
5756 }
5757 let zid = rff
5758 .elements
5759 .first()
5760 .and_then(|e| e.get(2))
5761 .map(|v| v.as_str())
5762 .unwrap_or("");
5763 !zid.is_empty() && seq_zeitraum_ids.iter().any(|id| id.as_str() == zid)
5764 });
5765 if !matching_rff {
5766 return ConditionResult::False;
5767 }
5768 for dtm in ctx.find_segments_with_qualifier("DTM", 0, "Z25") {
5769 let val = dtm
5770 .elements
5771 .first()
5772 .and_then(|e| e.get(1))
5773 .map(|v| v.replace("?+", "+"))
5774 .unwrap_or_default();
5775 if !val.is_empty() && val.as_str() >= THRESHOLD {
5776 return ConditionResult::True;
5777 }
5778 }
5779 ConditionResult::False
5780 }
5781
5782 fn evaluate_329(&self, ctx: &EvaluationContext) -> ConditionResult {
5784 let sts_segs = ctx.scoped_find_segments_in_with_qualifier("SG4", "STS", 0, "E01");
5787 let has_a03_e0096 = sts_segs.iter().any(|s| {
5788 s.elements
5789 .get(2)
5790 .and_then(|e| e.first())
5791 .is_some_and(|v| v == "A03")
5792 && s.elements
5793 .get(2)
5794 .and_then(|e| e.get(1))
5795 .is_some_and(|v| v == "E_0096")
5796 });
5797 let has_a04_e0097 = sts_segs.iter().any(|s| {
5798 s.elements
5799 .get(2)
5800 .and_then(|e| e.first())
5801 .is_some_and(|v| v == "A04")
5802 && s.elements
5803 .get(2)
5804 .and_then(|e| e.get(1))
5805 .is_some_and(|v| v == "E_0097")
5806 });
5807 ConditionResult::from(!has_a03_e0096 && !has_a04_e0097)
5808 }
5809
5810 fn evaluate_331(&self, ctx: &EvaluationContext) -> ConditionResult {
5812 let seq_segs = ctx.find_segments("SEQ");
5813 let has_seq = seq_segs.iter().any(|s| {
5814 s.elements
5815 .first()
5816 .and_then(|e| e.first())
5817 .is_some_and(|v| v == "Z98")
5818 });
5819 let cci_segs = ctx.find_segments("CCI");
5820 let has_cci = cci_segs.iter().any(|s| {
5821 s.elements
5822 .first()
5823 .and_then(|e| e.first())
5824 .is_some_and(|v| v == "6")
5825 && s.elements
5826 .get(2)
5827 .and_then(|e| e.first())
5828 .is_some_and(|v| v == "ZA9")
5829 });
5830 ConditionResult::from(!(has_seq && has_cci))
5831 }
5832
5833 fn evaluate_332(&self, ctx: &EvaluationContext) -> ConditionResult {
5836 let nav = match ctx.navigator {
5837 Some(n) => n,
5838 None => {
5839 if ctx.find_segments_with_qualifier("SEQ", 0, "Z01").is_empty() {
5840 return ConditionResult::Unknown;
5841 }
5842 let has_cci_za9 = ctx
5843 .find_segments_with_qualifier("CCI", 0, "6")
5844 .iter()
5845 .any(|s| {
5846 s.elements
5847 .get(2)
5848 .and_then(|e: &Vec<String>| e.first())
5849 .map(|v| v.as_str())
5850 == Some("ZA9")
5851 });
5852 return ConditionResult::from(!has_cci_za9);
5853 }
5854 };
5855 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
5856 if sg8_count == 0 {
5857 return ConditionResult::Unknown;
5858 }
5859 for sg8_idx in 0..sg8_count {
5860 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], sg8_idx, "SG10");
5861 let mut has_cci_za9 = false;
5862 for sg10_idx in 0..sg10_count {
5863 let ccis = nav.find_segments_in_child_group(
5864 "CCI",
5865 &["SG4", "SG8"],
5866 sg8_idx,
5867 "SG10",
5868 sg10_idx,
5869 );
5870 if ccis.iter().any(|s| {
5871 s.elements
5872 .first()
5873 .and_then(|e: &Vec<String>| e.first())
5874 .map(|v| v.as_str())
5875 == Some("6")
5876 && s.elements
5877 .get(2)
5878 .and_then(|e: &Vec<String>| e.first())
5879 .map(|v| v.as_str())
5880 == Some("ZA9")
5881 }) {
5882 has_cci_za9 = true;
5883 break;
5884 }
5885 }
5886 if !has_cci_za9 {
5887 return ConditionResult::True;
5888 }
5889 }
5890 ConditionResult::False
5891 }
5892
5893 fn evaluate_333(&self, ctx: &EvaluationContext) -> ConditionResult {
5895 let rff_segs = ctx.find_segments("RFF");
5896 let found = rff_segs.iter().any(|s| {
5897 s.elements
5898 .first()
5899 .and_then(|e| e.first())
5900 .is_some_and(|v| v == "Z31")
5901 });
5902 ConditionResult::from(found)
5903 }
5904
5905 fn evaluate_334(&self, ctx: &EvaluationContext) -> ConditionResult {
5907 ctx.external.evaluate("sector_check")
5909 }
5910
5911 fn evaluate_335(&self, ctx: &EvaluationContext) -> ConditionResult {
5914 let z58_ids: Vec<String> = ctx
5917 .scoped_find_segments_in_with_qualifier("SG8", "SEQ", 0, "Z58")
5918 .iter()
5919 .filter_map(|s| s.elements.get(1).and_then(|e| e.first()).cloned())
5920 .filter(|v| !v.is_empty())
5921 .collect();
5922 if z58_ids.is_empty() {
5923 return ConditionResult::Unknown;
5924 }
5925 if ctx.find_segments_with_qualifier("SEQ", 0, "Z78").is_empty() {
5926 return ConditionResult::False;
5927 }
5928 let rff_z31_ids: Vec<String> = ctx
5929 .find_segments_with_qualifier("RFF", 0, "Z31")
5930 .iter()
5931 .filter_map(|rff| rff.elements.first().and_then(|e| e.get(1)).cloned())
5932 .filter(|v| !v.is_empty())
5933 .collect();
5934 ConditionResult::from(z58_ids.iter().any(|id| rff_z31_ids.contains(id)))
5935 }
5936
5937 fn evaluate_336(&self, _ctx: &EvaluationContext) -> ConditionResult {
5939 ConditionResult::Unknown
5941 }
5942
5943 fn evaluate_337(&self, ctx: &EvaluationContext) -> ConditionResult {
5945 let cci_segs = ctx.find_segments("CCI");
5946 let has_cci = cci_segs.iter().any(|s| {
5947 s.elements
5948 .get(2)
5949 .and_then(|e| e.first())
5950 .is_some_and(|v| v == "ZB4")
5951 });
5952 let cav_segs = ctx.find_segments("CAV");
5953 let has_cav = cav_segs.iter().any(|s| {
5954 s.elements
5955 .first()
5956 .and_then(|e| e.first())
5957 .is_some_and(|v| ["Z95", "Z96"].contains(&v.as_str()))
5958 });
5959 ConditionResult::from(has_cci && has_cav)
5960 }
5961
5962 fn evaluate_338(&self, ctx: &EvaluationContext) -> ConditionResult {
5964 let cci_segs = ctx.find_segments("CCI");
5965 let has_cci = cci_segs.iter().any(|s| {
5966 s.elements
5967 .get(2)
5968 .and_then(|e| e.first())
5969 .is_some_and(|v| v == "ZB4")
5970 });
5971 let cav_segs = ctx.find_segments("CAV");
5972 let has_cav = cav_segs.iter().any(|s| {
5973 s.elements.first().and_then(|e| e.first()).is_some_and(|v| {
5974 ["Z95", "Z96", "Z97", "Z99", "ZA1", "ZA3", "ZA4", "ZG7"].contains(&v.as_str())
5975 })
5976 });
5977 ConditionResult::from(has_cci && has_cav)
5978 }
5979
5980 fn evaluate_339(&self, ctx: &EvaluationContext) -> ConditionResult {
5982 let cci_segs = ctx.find_segments("CCI");
5983 let has_cci = cci_segs.iter().any(|s| {
5984 s.elements
5985 .get(2)
5986 .and_then(|e| e.first())
5987 .is_some_and(|v| v == "ZB4")
5988 });
5989 let cav_segs = ctx.find_segments("CAV");
5990 let has_cav = cav_segs.iter().any(|s| {
5991 s.elements.first().and_then(|e| e.first()).is_some_and(|v| {
5992 [
5993 "Z97", "Z98", "Z99", "ZA0", "ZA1", "ZA2", "ZA3", "ZA6", "ZG7",
5994 ]
5995 .contains(&v.as_str())
5996 })
5997 });
5998 ConditionResult::from(has_cci && has_cav)
5999 }
6000
6001 fn evaluate_340(&self, ctx: &EvaluationContext) -> ConditionResult {
6003 let cci_segs = ctx.find_segments("CCI");
6004 let has_cci = cci_segs.iter().any(|s| {
6005 s.elements
6006 .get(2)
6007 .and_then(|e| e.first())
6008 .is_some_and(|v| v == "ZB4")
6009 });
6010 let cav_segs = ctx.find_segments("CAV");
6011 let has_cav = cav_segs.iter().any(|s| {
6012 s.elements.first().and_then(|e| e.first()).is_some_and(|v| {
6013 [
6014 "Z95", "Z97", "Z98", "Z99", "ZA1", "ZA2", "ZA3", "ZA4", "ZA5", "ZA6",
6015 ]
6016 .contains(&v.as_str())
6017 })
6018 });
6019 ConditionResult::from(has_cci && has_cav)
6020 }
6021
6022 fn evaluate_341(&self, ctx: &EvaluationContext) -> ConditionResult {
6024 let cci_segs = ctx.find_segments("CCI");
6025 let has_cci = cci_segs.iter().any(|s| {
6026 s.elements
6027 .get(2)
6028 .and_then(|e| e.first())
6029 .is_some_and(|v| v == "ZB4")
6030 });
6031 let cav_segs = ctx.find_segments("CAV");
6032 let has_cav = cav_segs.iter().any(|s| {
6033 s.elements
6034 .first()
6035 .and_then(|e| e.first())
6036 .is_some_and(|v| ["Z96", "ZA0", "ZG7"].contains(&v.as_str()))
6037 });
6038 ConditionResult::from(has_cci && has_cav)
6039 }
6040
6041 fn evaluate_342(&self, _ctx: &EvaluationContext) -> ConditionResult {
6043 ConditionResult::Unknown
6045 }
6046
6047 fn evaluate_344(&self, ctx: &EvaluationContext) -> ConditionResult {
6049 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
6051 let has_cci = cci_segs.iter().any(|s| {
6052 s.elements
6053 .get(2)
6054 .and_then(|e| e.first())
6055 .is_some_and(|v| v == "ZB4")
6056 });
6057 let cav_segs = ctx.scoped_find_segments_in("SG8", "CAV");
6058 let has_cav = cav_segs.iter().any(|s| {
6059 s.elements
6060 .first()
6061 .and_then(|e| e.first())
6062 .is_some_and(|v| ["ZF1"].contains(&v.as_str()))
6063 });
6064 ConditionResult::from(has_cci && has_cav)
6065 }
6066
6067 fn evaluate_345(&self, ctx: &EvaluationContext) -> ConditionResult {
6069 let loc_segs = ctx.find_segments("LOC");
6070 let found = loc_segs.iter().any(|s| {
6071 s.elements
6072 .first()
6073 .and_then(|e| e.first())
6074 .is_some_and(|v| v == "Z17")
6075 });
6076 ConditionResult::from(found)
6077 }
6078
6079 fn evaluate_346(&self, ctx: &EvaluationContext) -> ConditionResult {
6081 let cci_segs = ctx.find_segments("CCI");
6082 let found = cci_segs.iter().any(|s| {
6083 s.elements
6084 .get(2)
6085 .and_then(|e| e.first())
6086 .is_some_and(|v| v == "E13")
6087 });
6088 ConditionResult::from(found)
6089 }
6090
6091 fn evaluate_347(&self, ctx: &EvaluationContext) -> ConditionResult {
6093 let loc_segs = ctx.find_segments("LOC");
6094 let found = loc_segs.iter().any(|s| {
6095 s.elements
6096 .first()
6097 .and_then(|e| e.first())
6098 .is_some_and(|v| v == "Z16")
6099 });
6100 ConditionResult::from(!found)
6101 }
6102
6103 fn evaluate_348(&self, ctx: &EvaluationContext) -> ConditionResult {
6105 let loc_segs = ctx.find_segments("LOC");
6106 let found = loc_segs.iter().any(|s| {
6107 s.elements
6108 .first()
6109 .and_then(|e| e.first())
6110 .is_some_and(|v| v == "Z21")
6111 });
6112 ConditionResult::from(!found)
6113 }
6114
6115 fn evaluate_349(&self, ctx: &EvaluationContext) -> ConditionResult {
6117 let loc_segs = ctx.find_segments("LOC");
6118 let found = loc_segs.iter().any(|s| {
6119 s.elements
6120 .first()
6121 .and_then(|e| e.first())
6122 .is_some_and(|v| v == "Z17")
6123 });
6124 ConditionResult::from(!found)
6125 }
6126
6127 fn evaluate_350(&self, ctx: &EvaluationContext) -> ConditionResult {
6129 let seq_segs = ctx.find_segments("SEQ");
6130 let has_seq = seq_segs.iter().any(|s| {
6131 s.elements
6132 .first()
6133 .and_then(|e| e.first())
6134 .is_some_and(|v| ["Z78", "ZD5"].contains(&v.as_str()))
6135 });
6136 let rff_segs = ctx.find_segments("RFF");
6137 let has_rff = rff_segs.iter().any(|s| {
6138 s.elements
6139 .first()
6140 .and_then(|e| e.first())
6141 .is_some_and(|v| v == "Z31")
6142 });
6143 ConditionResult::from(has_seq && has_rff)
6144 }
6145
6146 fn evaluate_351(&self, ctx: &EvaluationContext) -> ConditionResult {
6148 let sts_segs = ctx.find_segments("STS");
6149 let found = sts_segs.iter().any(|s| {
6150 s.elements
6151 .first()
6152 .and_then(|e| e.first())
6153 .is_some_and(|v| v == "E01")
6154 && s.elements
6155 .get(2)
6156 .and_then(|e| e.first())
6157 .is_some_and(|v| ["A04", "A05", "A13", "A14"].contains(&v.as_str()))
6158 });
6159 ConditionResult::from(found)
6160 }
6161
6162 fn evaluate_352(&self, ctx: &EvaluationContext) -> ConditionResult {
6164 let sts_segs = ctx.find_segments("STS");
6165 let found = sts_segs.iter().any(|s| {
6166 s.elements
6167 .get(1)
6168 .and_then(|e| e.first())
6169 .is_some_and(|v| ["A05", "A06", "A14", "A15"].contains(&v.as_str()))
6170 });
6171 ConditionResult::from(found)
6172 }
6173
6174 fn evaluate_355(&self, ctx: &EvaluationContext) -> ConditionResult {
6176 let sts_segs = ctx.find_segments("STS");
6177 let found = sts_segs.iter().any(|s| {
6178 s.elements
6179 .first()
6180 .and_then(|e| e.first())
6181 .is_some_and(|v| v == "E01")
6182 && s.elements
6183 .get(2)
6184 .and_then(|e| e.first())
6185 .is_some_and(|v| ["A45"].contains(&v.as_str()))
6186 });
6187 ConditionResult::from(found)
6188 }
6189
6190 fn evaluate_356(&self, ctx: &EvaluationContext) -> ConditionResult {
6192 let sts_segs = ctx.find_segments("STS");
6193 let found = sts_segs.iter().any(|s| {
6194 s.elements
6195 .first()
6196 .and_then(|e| e.first())
6197 .is_some_and(|v| v == "E01")
6198 && s.elements
6199 .get(2)
6200 .and_then(|e| e.first())
6201 .is_some_and(|v| ["A50"].contains(&v.as_str()))
6202 });
6203 ConditionResult::from(found)
6204 }
6205
6206 fn evaluate_357(&self, ctx: &EvaluationContext) -> ConditionResult {
6208 let sts_segs = ctx.find_segments("STS");
6209 let found = sts_segs.iter().any(|s| {
6210 s.elements
6211 .first()
6212 .and_then(|e| e.first())
6213 .is_some_and(|v| v == "E01")
6214 && s.elements
6215 .get(2)
6216 .and_then(|e| e.first())
6217 .is_some_and(|v| ["A03", "A09", "A12", "A17"].contains(&v.as_str()))
6218 });
6219 ConditionResult::from(found)
6220 }
6221
6222 fn evaluate_358(&self, ctx: &EvaluationContext) -> ConditionResult {
6224 let sts_segs = ctx.find_segments("STS");
6225 let found = sts_segs.iter().any(|s| {
6226 s.elements
6227 .first()
6228 .and_then(|e| e.first())
6229 .is_some_and(|v| v == "E01")
6230 && s.elements
6231 .get(2)
6232 .and_then(|e| e.first())
6233 .is_some_and(|v| ["A06"].contains(&v.as_str()))
6234 });
6235 ConditionResult::from(found)
6236 }
6237
6238 fn evaluate_359(&self, ctx: &EvaluationContext) -> ConditionResult {
6242 all_sts_e01_in_cluster(ctx, Cluster::is_ablehnung)
6243 }
6244
6245 fn evaluate_360(&self, ctx: &EvaluationContext) -> ConditionResult {
6249 all_sts_e01_in_cluster(ctx, Cluster::is_zustimmung)
6250 }
6251
6252 fn evaluate_363(&self, ctx: &EvaluationContext) -> ConditionResult {
6254 let sts_segs = ctx.find_segments("STS");
6255 let found = sts_segs.iter().any(|s| {
6256 s.elements
6257 .first()
6258 .and_then(|e| e.first())
6259 .is_some_and(|v| v == "E01")
6260 && s.elements
6261 .get(2)
6262 .and_then(|e| e.first())
6263 .is_some_and(|v| ["A50"].contains(&v.as_str()))
6264 });
6265 ConditionResult::from(found)
6266 }
6267
6268 fn evaluate_365(&self, ctx: &EvaluationContext) -> ConditionResult {
6270 let sts_segs = ctx.scoped_find_segments_in_with_qualifier("SG4", "STS", 0, "E01");
6273 let has_excluded = sts_segs.iter().any(|s| {
6274 let code = s
6275 .elements
6276 .get(2)
6277 .and_then(|e| e.first())
6278 .map(|v| v.as_str());
6279 let ebd = s.elements.get(2).and_then(|e| e.get(1)).map(|v| v.as_str());
6280 matches!(
6281 (code, ebd),
6282 (Some("A04"), Some("E_0047"))
6283 | (Some("A04"), Some("E_0014"))
6284 | (Some("A03"), Some("E_0049"))
6285 | (Some("A03"), Some("E_0004"))
6286 )
6287 });
6288 ConditionResult::from(!has_excluded)
6289 }
6290
6291 fn evaluate_366(&self, ctx: &EvaluationContext) -> ConditionResult {
6295 ebd_ablehnung_except(ctx, "E_0624", &["A30"])
6296 }
6297
6298 fn evaluate_367(&self, ctx: &EvaluationContext) -> ConditionResult {
6300 let sts_segs = ctx.find_segments("STS");
6301 let found = sts_segs.iter().any(|s| {
6302 s.elements
6303 .first()
6304 .and_then(|e| e.first())
6305 .is_some_and(|v| v == "E01")
6306 && s.elements
6307 .get(2)
6308 .and_then(|e| e.first())
6309 .is_some_and(|v| ["A05", "A14"].contains(&v.as_str()))
6310 });
6311 ConditionResult::from(found)
6312 }
6313
6314 fn evaluate_368(&self, ctx: &EvaluationContext) -> ConditionResult {
6318 ebd_ablehnung_except(ctx, "E_0624", &["A41"])
6319 }
6320
6321 fn evaluate_370(&self, ctx: &EvaluationContext) -> ConditionResult {
6323 let cav_segs = ctx.find_segments("CAV");
6324 let found = cav_segs.iter().any(|s| {
6325 s.elements.first().and_then(|e| e.first()).is_some_and(|v| {
6326 [
6327 "TLS", "TES", "BIT", "GET", "GAT", "SOT", "WNT", "WFT", "WAT",
6328 ]
6329 .contains(&v.as_str())
6330 })
6331 });
6332 ConditionResult::from(found)
6333 }
6334
6335 fn evaluate_371(&self, ctx: &EvaluationContext) -> ConditionResult {
6337 let seq_segs = ctx.find_segments("SEQ");
6338 let found = seq_segs.iter().any(|s| {
6339 s.elements
6340 .first()
6341 .and_then(|e| e.first())
6342 .is_some_and(|v| ["Z38"].contains(&v.as_str()))
6343 });
6344 ConditionResult::from(!found)
6345 }
6346
6347 fn evaluate_372(&self, ctx: &EvaluationContext) -> ConditionResult {
6349 let cav_segs = ctx.find_segments("CAV");
6350 let found = cav_segs.iter().any(|s| {
6351 s.elements.first().and_then(|e| e.first()).is_some_and(|v| {
6352 ["TES", "BIT", "GET", "GAT", "SOT", "WNT", "WFT", "WAT"].contains(&v.as_str())
6353 })
6354 });
6355 ConditionResult::from(found)
6356 }
6357
6358 fn evaluate_373(&self, _ctx: &EvaluationContext) -> ConditionResult {
6360 ConditionResult::Unknown
6362 }
6363
6364 fn evaluate_375(&self, ctx: &EvaluationContext) -> ConditionResult {
6366 ctx.lacks_qualifier("SEQ", 0, "Z24")
6368 }
6369
6370 fn evaluate_376(&self, ctx: &EvaluationContext) -> ConditionResult {
6372 ctx.lacks_qualifier("SEQ", 0, "Z22")
6374 }
6375
6376 fn evaluate_377(&self, ctx: &EvaluationContext) -> ConditionResult {
6379 let nav = match ctx.navigator {
6380 Some(n) => n,
6381 None => return ctx.has_qualified_value("CAV", 0, "AUS", 0, 0, &["AUS"]),
6382 };
6383 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
6384 for i in 0..sg8_count {
6385 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
6386 for j in 0..sg10_count {
6387 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
6388 let has_cci = ccis.iter().any(|s| {
6389 s.elements
6390 .first()
6391 .and_then(|e: &Vec<String>| e.first())
6392 .is_some_and(|v: &String| v == "15")
6393 && s.elements
6394 .get(2)
6395 .and_then(|e: &Vec<String>| e.first())
6396 .is_some_and(|v: &String| v == "Z21")
6397 });
6398 if has_cci {
6399 let cavs =
6400 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
6401 if cavs.iter().any(|s| {
6402 s.elements
6403 .first()
6404 .and_then(|e: &Vec<String>| e.first())
6405 .is_some_and(|v: &String| v == "AUS")
6406 }) {
6407 return ConditionResult::True;
6408 }
6409 }
6410 }
6411 }
6412 ConditionResult::False
6413 }
6414
6415 fn evaluate_378(&self, ctx: &EvaluationContext) -> ConditionResult {
6418 let nav = match ctx.navigator {
6419 Some(n) => n,
6420 None => {
6421 let r = ctx.has_qualified_value("CAV", 0, "AUS", 0, 0, &["AUS"]);
6422 return match r {
6423 ConditionResult::True => ConditionResult::False,
6424 ConditionResult::False => ConditionResult::True,
6425 ConditionResult::Unknown => ConditionResult::Unknown,
6426 };
6427 }
6428 };
6429 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
6430 for i in 0..sg8_count {
6431 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
6432 for j in 0..sg10_count {
6433 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
6434 let has_cci = ccis.iter().any(|s| {
6435 s.elements
6436 .first()
6437 .and_then(|e: &Vec<String>| e.first())
6438 .is_some_and(|v: &String| v == "15")
6439 && s.elements
6440 .get(2)
6441 .and_then(|e: &Vec<String>| e.first())
6442 .is_some_and(|v: &String| v == "Z21")
6443 });
6444 if has_cci {
6445 let cavs =
6446 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
6447 if cavs.iter().any(|s| {
6448 s.elements
6449 .first()
6450 .and_then(|e: &Vec<String>| e.first())
6451 .is_some_and(|v: &String| v == "AUS")
6452 }) {
6453 return ConditionResult::False;
6454 }
6455 }
6456 }
6457 }
6458 ConditionResult::True
6459 }
6460
6461 fn evaluate_379(&self, ctx: &EvaluationContext) -> ConditionResult {
6463 let cci_segs = ctx.find_segments("CCI");
6464 let found = cci_segs.iter().any(|s| {
6465 s.elements
6466 .first()
6467 .and_then(|e| e.first())
6468 .is_some_and(|v| v == "15")
6469 && s.elements
6470 .get(2)
6471 .and_then(|e| e.first())
6472 .is_some_and(|v| ["Z21"].contains(&v.as_str()))
6473 });
6474 ConditionResult::from(found)
6475 }
6476
6477 fn evaluate_380(&self, ctx: &EvaluationContext) -> ConditionResult {
6480 let nav = match ctx.navigator {
6481 Some(n) => n,
6482 None => {
6483 return ctx.any_group_has_any_qualifier("CAV", 0, &["AUS", "AU1"], &["SG4", "SG8"])
6484 }
6485 };
6486 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
6487 for i in 0..sg8_count {
6488 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
6489 for j in 0..sg10_count {
6490 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
6491 let has_cci = ccis.iter().any(|s| {
6492 s.elements
6493 .first()
6494 .and_then(|e: &Vec<String>| e.first())
6495 .is_some_and(|v: &String| v == "15")
6496 && s.elements
6497 .get(2)
6498 .and_then(|e: &Vec<String>| e.first())
6499 .is_some_and(|v: &String| v == "Z21")
6500 });
6501 if has_cci {
6502 let cavs =
6503 nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
6504 if cavs.iter().any(|s| {
6505 s.elements
6506 .first()
6507 .and_then(|e: &Vec<String>| e.first())
6508 .is_some_and(|v: &String| v == "AUS" || v == "AU1")
6509 }) {
6510 return ConditionResult::True;
6511 }
6512 }
6513 }
6514 }
6515 ConditionResult::False
6516 }
6517
6518 fn evaluate_384(&self, ctx: &EvaluationContext) -> ConditionResult {
6520 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
6522 let found = cci_segs.iter().any(|s| {
6523 s.elements
6524 .first()
6525 .and_then(|e| e.first())
6526 .is_some_and(|v| v == "Z37")
6527 && s.elements
6528 .get(2)
6529 .and_then(|e| e.first())
6530 .is_some_and(|v| v == "ZD1")
6531 });
6532 ConditionResult::from(found)
6533 }
6534
6535 fn evaluate_386(&self, ctx: &EvaluationContext) -> ConditionResult {
6537 let seq_count = ctx
6539 .find_segments("SEQ")
6540 .iter()
6541 .filter(|s| {
6542 s.elements
6543 .first()
6544 .and_then(|e| e.first())
6545 .is_some_and(|v| v == "Z02" || v == "ZE3")
6546 })
6547 .count();
6548 ConditionResult::from(seq_count > 1)
6549 }
6550
6551 fn evaluate_387(&self, ctx: &EvaluationContext) -> ConditionResult {
6553 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
6556 let found = pia_segs.iter().any(|s| {
6557 s.elements
6558 .first()
6559 .and_then(|e| e.first())
6560 .is_some_and(|v| v == "5")
6561 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6562 v.starts_with("1-")
6563 && (v.contains(":1.8.")
6564 || v.contains(":2.8.")
6565 || v.contains(":1.9.")
6566 || v.contains(":2.9."))
6567 })
6568 });
6569 ConditionResult::from(found)
6570 }
6571
6572 fn evaluate_388(&self, ctx: &EvaluationContext) -> ConditionResult {
6574 let found = !ctx.find_segments_with_qualifier("RFF", 0, "Z49").is_empty();
6576 ConditionResult::from(found)
6577 }
6578
6579 fn evaluate_391(&self, ctx: &EvaluationContext) -> ConditionResult {
6581 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
6584 let found = pia_segs.iter().any(|s| {
6585 s.elements
6586 .first()
6587 .and_then(|e| e.first())
6588 .is_some_and(|v| v == "5")
6589 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6590 v.starts_with("1-") && (v.contains(":1.8.") || v.contains(":2.8."))
6591 })
6592 });
6593 ConditionResult::from(found)
6594 }
6595
6596 fn evaluate_392(&self, ctx: &EvaluationContext) -> ConditionResult {
6598 let pia_segs = ctx.find_segments("PIA");
6600 let found = pia_segs.iter().any(|s| {
6601 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6602 let parts: Vec<&str> = v.split('-').collect();
6603 parts.len() == 3
6604 && parts[0].len() == 1
6605 && parts[0].chars().all(|c| c.is_ascii_digit())
6606 && parts[1].len() == 2
6607 && parts[1].chars().all(|c| c.is_ascii_digit())
6608 && parts[2].len() == 1
6609 && parts[2].chars().all(|c| c.is_ascii_digit())
6610 })
6611 });
6612 ConditionResult::from(found)
6613 }
6614
6615 fn evaluate_393(&self, ctx: &EvaluationContext) -> ConditionResult {
6617 let pia_segs = ctx.find_segments("PIA");
6619 let found = pia_segs.iter().any(|s| {
6620 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6621 let parts: Vec<&str> = v.split('-').collect();
6622 parts.len() == 4
6623 && parts[0].len() == 1
6624 && parts[0].chars().all(|c| c.is_ascii_digit())
6625 && parts[1].len() == 2
6626 && parts[1].chars().all(|c| c.is_ascii_digit())
6627 && parts[2].len() == 1
6628 && parts[2].chars().all(|c| c.is_ascii_digit())
6629 && parts[3].len() == 3
6630 && parts[3].chars().all(|c| c.is_ascii_digit())
6631 })
6632 });
6633 ConditionResult::from(found)
6634 }
6635
6636 fn evaluate_394(&self, ctx: &EvaluationContext) -> ConditionResult {
6638 let pia_segs = ctx.find_segments("PIA");
6640 let found = pia_segs.iter().any(|s| {
6641 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6642 let parts: Vec<&str> = v.split('-').collect();
6643 parts.len() == 5
6644 && parts[0].len() == 1
6645 && parts[0].chars().all(|c| c.is_ascii_digit())
6646 && parts[1].len() == 2
6647 && parts[1].chars().all(|c| c.is_ascii_digit())
6648 && parts[2].len() == 1
6649 && parts[2].chars().all(|c| c.is_ascii_digit())
6650 && parts[3].len() == 8
6651 && parts[3].chars().all(|c| c.is_ascii_digit())
6652 && parts[4].len() == 2
6653 && parts[4].chars().all(|c| c.is_ascii_digit())
6654 })
6655 });
6656 ConditionResult::from(found)
6657 }
6658
6659 fn evaluate_395(&self, ctx: &EvaluationContext) -> ConditionResult {
6661 let pia_segs = ctx.find_segments("PIA");
6663 let found = pia_segs.iter().any(|s| {
6664 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6665 let parts: Vec<&str> = v.split('-').collect();
6666 parts.len() == 4
6667 && parts[0].len() == 1
6668 && parts[0].chars().all(|c| c.is_ascii_digit())
6669 && parts[1].len() == 2
6670 && parts[1].chars().all(|c| c.is_ascii_digit())
6671 && parts[2].len() == 1
6672 && parts[2].chars().all(|c| c.is_ascii_digit())
6673 && parts[3].len() == 8
6674 && parts[3].chars().all(|c| c.is_ascii_digit())
6675 })
6676 });
6677 ConditionResult::from(found)
6678 }
6679
6680 fn evaluate_396(&self, ctx: &EvaluationContext) -> ConditionResult {
6682 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
6685 let found = pia_segs.iter().any(|s| {
6686 s.elements
6687 .first()
6688 .and_then(|e| e.first())
6689 .is_some_and(|v| v == "5")
6690 && s.elements
6691 .get(1)
6692 .and_then(|e| e.first())
6693 .is_some_and(|v| v.starts_with("1-") && v.contains(":1.8."))
6694 });
6695 ConditionResult::from(found)
6696 }
6697
6698 fn evaluate_397(&self, ctx: &EvaluationContext) -> ConditionResult {
6700 let pia_segs = ctx.find_segments("PIA");
6701 let found = pia_segs.iter().any(|s| {
6702 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6703 let prefixes = ["1-08-1", "1-08-4"];
6704 prefixes.iter().any(|p| v.starts_with(p))
6705 })
6706 });
6707 ConditionResult::from(found)
6708 }
6709
6710 fn evaluate_398(&self, ctx: &EvaluationContext) -> ConditionResult {
6712 let pia_segs = ctx.find_segments("PIA");
6713 let found = pia_segs.iter().any(|s| {
6714 s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6715 let prefixes = ["1-08-2", "1-08-5"];
6716 prefixes.iter().any(|p| v.starts_with(p))
6717 })
6718 });
6719 ConditionResult::from(found)
6720 }
6721
6722 fn evaluate_399(&self, ctx: &EvaluationContext) -> ConditionResult {
6725 let nav = match ctx.navigator() {
6726 Some(n) => n,
6727 None => return ConditionResult::Unknown,
6728 };
6729 let sg5_count = nav.group_instance_count(&["SG4", "SG5"]);
6732 let mut loc_zeitraum_ids: Vec<String> = Vec::new();
6733 for i in 0..sg5_count {
6734 let locs = nav.find_segments_in_group("LOC", &["SG4", "SG5"], i);
6735 for loc in &locs {
6736 if let Some(zid) = loc.elements.get(1).and_then(|e| e.get(3)) {
6737 if !zid.is_empty() {
6738 loc_zeitraum_ids.push(zid.clone());
6739 }
6740 }
6741 }
6742 }
6743 if loc_zeitraum_ids.is_empty() {
6744 return ConditionResult::Unknown;
6745 }
6746 let pauschal_id = "9992000000018";
6747 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
6748 for i in 0..sg8_count {
6751 let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
6752 for seq in &seqs {
6753 if !seq
6754 .elements
6755 .first()
6756 .and_then(|e| e.first())
6757 .is_some_and(|v| v == "Z78")
6758 {
6759 continue;
6760 }
6761 let zid = seq
6762 .elements
6763 .get(1)
6764 .and_then(|e| e.first())
6765 .map(|s| s.as_str())
6766 .unwrap_or("");
6767 if !loc_zeitraum_ids.iter().any(|z| z == zid) {
6768 continue;
6769 }
6770 let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG8"], i);
6772 for rff in &rffs {
6773 let qual = rff
6774 .elements
6775 .first()
6776 .and_then(|e| e.first())
6777 .map(|v| v.as_str())
6778 .unwrap_or("");
6779 if qual == "Z31" {
6780 let id = rff
6781 .elements
6782 .first()
6783 .and_then(|e| e.get(1))
6784 .map(|v| v.as_str())
6785 .unwrap_or("");
6786 let normalized = id.replace(' ', "");
6787 if !normalized.is_empty() && normalized != pauschal_id {
6788 return ConditionResult::True;
6789 }
6790 }
6791 }
6792 }
6793 }
6794 ConditionResult::False
6795 }
6796
6797 fn evaluate_401(&self, ctx: &EvaluationContext) -> ConditionResult {
6799 let has_z49 = !ctx.find_segments_with_qualifier("RFF", 0, "Z49").is_empty();
6802 let has_z53 = !ctx.find_segments_with_qualifier("RFF", 0, "Z53").is_empty();
6803 ConditionResult::from(!has_z49 && !has_z53)
6804 }
6805
6806 fn evaluate_402(&self, ctx: &EvaluationContext) -> ConditionResult {
6808 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
6811 let found = pia_segs.iter().any(|s| {
6812 s.elements
6813 .first()
6814 .and_then(|e| e.first())
6815 .is_some_and(|v| v == "5")
6816 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6817 v.starts_with("1-") && (v.contains(":1.8.") || v.contains(":2.8."))
6818 })
6819 });
6820 ConditionResult::from(found)
6821 }
6822
6823 fn evaluate_403(&self, ctx: &EvaluationContext) -> ConditionResult {
6826 let sender_mp_id: String = match ctx.find_segments_with_qualifier("NAD", 0, "MS").first() {
6827 Some(nad) => match nad.elements.get(1).and_then(|e: &Vec<String>| e.first()) {
6828 Some(id) if !id.is_empty() => id.clone(),
6829 _ => return ConditionResult::Unknown,
6830 },
6831 None => return ConditionResult::Unknown,
6832 };
6833 let nav = match ctx.navigator {
6834 Some(n) => n,
6835 None => return ConditionResult::Unknown,
6836 };
6837 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
6838 for i in 0..sg8_count {
6839 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
6840 for j in 0..sg10_count {
6841 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
6842 let has_cci_zb3 = ccis.iter().any(|s| {
6843 s.elements
6844 .get(2)
6845 .and_then(|e: &Vec<String>| e.first())
6846 .is_some_and(|v: &String| v == "ZB3")
6847 });
6848 if !has_cci_zb3 {
6849 continue;
6850 }
6851 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
6852 for cav in &cavs {
6853 if cav
6854 .elements
6855 .first()
6856 .and_then(|e: &Vec<String>| e.first())
6857 .is_some_and(|v: &String| v == "Z91")
6858 {
6859 if let Some(msb_id) = cav.elements.first().and_then(|e| e.get(1)) {
6860 if !msb_id.is_empty() {
6861 return ConditionResult::from(
6862 sender_mp_id.as_str() != msb_id.as_str(),
6863 );
6864 }
6865 }
6866 }
6867 }
6868 }
6869 }
6870 ConditionResult::Unknown
6871 }
6872
6873 fn evaluate_404(&self, ctx: &EvaluationContext) -> ConditionResult {
6876 let mr_nads = ctx.find_segments_with_qualifier("NAD", 0, "MR");
6877 let mr_mp_id = match mr_nads.first() {
6878 Some(nad) => nad
6879 .elements
6880 .get(1)
6881 .and_then(|e: &Vec<String>| e.first())
6882 .cloned()
6883 .unwrap_or_default(),
6884 None => return ConditionResult::Unknown,
6885 };
6886 if mr_mp_id.is_empty() {
6887 return ConditionResult::Unknown;
6888 }
6889
6890 let nav = match ctx.navigator {
6891 Some(n) => n,
6892 None => {
6893 let cavs = ctx.find_segments("CAV");
6894 let same_id_exists = cavs.iter().any(|s| {
6895 s.elements
6896 .first()
6897 .and_then(|e: &Vec<String>| e.first())
6898 .is_some_and(|v: &String| v == "Z91")
6899 && s.elements
6900 .first()
6901 .and_then(|e| e.get(1))
6902 .is_some_and(|v: &String| v == &mr_mp_id)
6903 });
6904 return ConditionResult::from(!same_id_exists);
6905 }
6906 };
6907
6908 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
6909 for i in 0..sg8_count {
6910 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
6911 for j in 0..sg10_count {
6912 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
6913 let has_cci_zb3 = ccis.iter().any(|s| {
6914 s.elements
6915 .get(2)
6916 .and_then(|e: &Vec<String>| e.first())
6917 .is_some_and(|v: &String| v == "ZB3")
6918 });
6919 if !has_cci_zb3 {
6920 continue;
6921 }
6922 let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
6923 for cav in &cavs {
6924 if cav
6925 .elements
6926 .first()
6927 .and_then(|e: &Vec<String>| e.first())
6928 .is_some_and(|v: &String| v == "Z91")
6929 {
6930 let cav_mp_id = cav
6931 .elements
6932 .first()
6933 .and_then(|e| e.get(1))
6934 .map(|s| s.as_str())
6935 .unwrap_or("");
6936 if cav_mp_id == mr_mp_id.as_str() {
6937 return ConditionResult::False;
6938 }
6939 }
6940 }
6941 }
6942 }
6943
6944 ConditionResult::True
6945 }
6946
6947 fn evaluate_405(&self, ctx: &EvaluationContext) -> ConditionResult {
6949 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
6952 let found = pia_segs.iter().any(|s| {
6953 s.elements
6954 .first()
6955 .and_then(|e| e.first())
6956 .is_some_and(|v| v == "5")
6957 && s.elements
6958 .get(1)
6959 .and_then(|e| e.first())
6960 .is_some_and(|v| v.starts_with("1-") && v.contains(":1.8."))
6961 });
6962 ConditionResult::from(found)
6963 }
6964
6965 fn evaluate_406(&self, ctx: &EvaluationContext) -> ConditionResult {
6967 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
6970 let found = pia_segs.iter().any(|s| {
6971 s.elements
6972 .first()
6973 .and_then(|e| e.first())
6974 .is_some_and(|v| v == "5")
6975 && s.elements
6976 .get(1)
6977 .and_then(|e| e.first())
6978 .is_some_and(|v| v.starts_with("1-") && v.contains(":1.8."))
6979 });
6980 ConditionResult::from(found)
6981 }
6982
6983 fn evaluate_407(&self, ctx: &EvaluationContext) -> ConditionResult {
6985 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
6988 let found = pia_segs.iter().any(|s| {
6989 s.elements
6990 .first()
6991 .and_then(|e| e.first())
6992 .is_some_and(|v| v == "5")
6993 && s.elements.get(1).and_then(|e| e.first()).is_some_and(|v| {
6994 v.starts_with("1-") && (v.contains(":3.8.") || v.contains(":4.8."))
6995 })
6996 });
6997 ConditionResult::from(found)
6998 }
6999
7000 fn evaluate_408(&self, ctx: &EvaluationContext) -> ConditionResult {
7002 let has_seq_z02 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z02").is_empty();
7004 ConditionResult::from(has_seq_z02)
7005 }
7006
7007 fn evaluate_409(&self, ctx: &EvaluationContext) -> ConditionResult {
7009 let has_seq_z02 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z02").is_empty();
7011 ConditionResult::from(!has_seq_z02)
7012 }
7013
7014 fn evaluate_410(&self, ctx: &EvaluationContext) -> ConditionResult {
7016 let has_seq_z02 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z02").is_empty();
7018 ConditionResult::from(has_seq_z02)
7019 }
7020
7021 fn evaluate_411(&self, ctx: &EvaluationContext) -> ConditionResult {
7023 let has_seq_z02 = !ctx.find_segments_with_qualifier("SEQ", 0, "Z02").is_empty();
7025 ConditionResult::from(!has_seq_z02)
7026 }
7027
7028 fn evaluate_412(&self, ctx: &EvaluationContext) -> ConditionResult {
7030 ctx.external.evaluate("code_list_membership_check")
7031 }
7032
7033 fn evaluate_413(&self, ctx: &EvaluationContext) -> ConditionResult {
7035 let found = ctx.find_segments("SEQ").iter().any(|s| {
7037 s.elements
7038 .first()
7039 .and_then(|e| e.first())
7040 .is_some_and(|v| ["Z02", "ZA1", "ZA2"].contains(&v.as_str()))
7041 });
7042 ConditionResult::from(found)
7043 }
7044
7045 fn evaluate_414(&self, ctx: &EvaluationContext) -> ConditionResult {
7047 let found = ctx.find_segments("SEQ").iter().any(|s| {
7049 s.elements
7050 .first()
7051 .and_then(|e| e.first())
7052 .is_some_and(|v| ["Z02", "ZA1", "ZA2"].contains(&v.as_str()))
7053 });
7054 ConditionResult::from(!found)
7055 }
7056
7057 fn evaluate_415(&self, ctx: &EvaluationContext) -> ConditionResult {
7059 let count = ctx
7061 .find_segments("SEQ")
7062 .iter()
7063 .filter(|s| {
7064 s.elements
7065 .first()
7066 .and_then(|e| e.first())
7067 .is_some_and(|v| ["Z02", "ZA1", "ZA2"].contains(&v.as_str()))
7068 })
7069 .count();
7070 ConditionResult::from(count > 1)
7071 }
7072
7073 fn evaluate_416(&self, ctx: &EvaluationContext) -> ConditionResult {
7075 let count = ctx
7077 .find_segments("SEQ")
7078 .iter()
7079 .filter(|s| {
7080 s.elements
7081 .first()
7082 .and_then(|e| e.first())
7083 .is_some_and(|v| ["Z02", "ZA1", "ZA2"].contains(&v.as_str()))
7084 })
7085 .count();
7086 ConditionResult::from(count <= 1)
7087 }
7088
7089 fn evaluate_417(&self, _ctx: &EvaluationContext) -> ConditionResult {
7091 ConditionResult::Unknown
7093 }
7094
7095 fn evaluate_419(&self, _ctx: &EvaluationContext) -> ConditionResult {
7097 ConditionResult::Unknown
7099 }
7100
7101 fn evaluate_420(&self, ctx: &EvaluationContext) -> ConditionResult {
7103 let rff_segs = ctx.scoped_find_segments_in("SG8", "RFF");
7105 let found = rff_segs.iter().any(|s| {
7106 s.elements
7107 .first()
7108 .and_then(|e| e.first())
7109 .is_some_and(|v| v == "Z14")
7110 });
7111 ConditionResult::from(found)
7112 }
7113
7114 fn evaluate_421(&self, ctx: &EvaluationContext) -> ConditionResult {
7116 ctx.any_group_has_qualifier("CCI", 0, "Z39", &["SG4", "SG8"])
7118 }
7119
7120 fn evaluate_425(&self, ctx: &EvaluationContext) -> ConditionResult {
7122 ctx.external.evaluate("code_list_membership_check")
7123 }
7124
7125 fn evaluate_426(&self, ctx: &EvaluationContext) -> ConditionResult {
7127 ctx.external.evaluate("code_list_membership_check")
7128 }
7129
7130 fn evaluate_427(&self, ctx: &EvaluationContext) -> ConditionResult {
7132 ctx.external.evaluate("code_list_membership_check")
7133 }
7134
7135 fn evaluate_428(&self, ctx: &EvaluationContext) -> ConditionResult {
7137 ctx.external.evaluate("code_list_membership_check")
7138 }
7139
7140 fn evaluate_429(&self, ctx: &EvaluationContext) -> ConditionResult {
7142 ctx.external.evaluate("code_list_membership_check")
7143 }
7144
7145 fn evaluate_430(&self, ctx: &EvaluationContext) -> ConditionResult {
7147 let seq_z27_count = ctx.find_segments_with_qualifier("SEQ", 0, "Z27").len();
7149 ConditionResult::from(seq_z27_count > 1)
7150 }
7151
7152 fn evaluate_431(&self, ctx: &EvaluationContext) -> ConditionResult {
7154 let seq_z27_count = ctx.find_segments_with_qualifier("SEQ", 0, "Z27").len();
7156 ConditionResult::from(seq_z27_count <= 1)
7157 }
7158
7159 fn evaluate_432(&self, ctx: &EvaluationContext) -> ConditionResult {
7161 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
7164 let found = pia_segs.iter().any(|s| {
7165 s.elements
7166 .first()
7167 .and_then(|e| e.first())
7168 .is_some_and(|v| v == "5")
7169 && s.elements
7170 .get(1)
7171 .and_then(|e| e.first())
7172 .is_some_and(|v| v == "9991000000078")
7173 });
7174 ConditionResult::from(found)
7175 }
7176
7177 fn evaluate_433(&self, ctx: &EvaluationContext) -> ConditionResult {
7179 ctx.external.evaluate("code_list_membership_check")
7180 }
7181
7182 fn evaluate_435(&self, ctx: &EvaluationContext) -> ConditionResult {
7184 ctx.external.evaluate("code_list_membership_check")
7185 }
7186
7187 fn evaluate_436(&self, ctx: &EvaluationContext) -> ConditionResult {
7189 let pia_segs = ctx.scoped_find_segments_in("SG8", "PIA");
7192 let found = pia_segs.iter().any(|s| {
7193 s.elements
7194 .first()
7195 .and_then(|e| e.first())
7196 .is_some_and(|v| v == "5")
7197 && s.elements
7198 .get(1)
7199 .and_then(|e| e.first())
7200 .is_some_and(|v| v == "9991000000086")
7201 });
7202 ConditionResult::from(found)
7203 }
7204
7205 fn evaluate_437(&self, ctx: &EvaluationContext) -> ConditionResult {
7207 let sts_segs = ctx.scoped_find_segments_in("SG4", "STS");
7209 let found = sts_segs.iter().any(|s| {
7210 s.elements
7211 .first()
7212 .and_then(|e| e.first())
7213 .is_some_and(|v| v == "E01")
7214 && s.elements
7215 .get(2)
7216 .and_then(|e| e.first())
7217 .is_some_and(|v| ["A04", "A23"].contains(&v.as_str()))
7218 });
7219 ConditionResult::from(found)
7220 }
7221
7222 fn evaluate_438(&self, ctx: &EvaluationContext) -> ConditionResult {
7224 let cci_segs = ctx.find_segments("CCI");
7225 let found = cci_segs.iter().any(|s| {
7226 s.elements
7227 .first()
7228 .and_then(|e| e.first())
7229 .is_some_and(|v| v == "Z39")
7230 });
7231 ConditionResult::from(found)
7232 }
7233
7234 fn evaluate_440(&self, ctx: &EvaluationContext) -> ConditionResult {
7236 ctx.has_qualifier("RFF", 0, "Z35")
7238 }
7239
7240 fn evaluate_441(&self, ctx: &EvaluationContext) -> ConditionResult {
7242 ctx.any_group_has_qualifier_without("SEQ", 0, "Z03", "RFF", 0, "Z14", &["SG4", "SG8"])
7244 }
7245
7246 fn evaluate_442(&self, ctx: &EvaluationContext) -> ConditionResult {
7248 ctx.has_qualifier("RFF", 0, "Z34")
7250 }
7251
7252 fn evaluate_444(&self, ctx: &EvaluationContext) -> ConditionResult {
7255 for code in ["Z60", "ZE0", "ZG8", "ZG9"] {
7256 if matches!(
7257 ctx.any_group_has_qualifier_without("SEQ", 0, code, "PIA", 0, "5", &["SG4", "SG8"]),
7258 ConditionResult::True
7259 ) {
7260 return ConditionResult::True;
7261 }
7262 }
7263 ConditionResult::False
7264 }
7265
7266 fn evaluate_445(&self, ctx: &EvaluationContext) -> ConditionResult {
7269 let nav = match ctx.navigator {
7270 Some(n) => n,
7271 None => {
7272 let has_cci11 = ["Z60", "ZE0", "ZG8", "ZG9"].iter().any(|code| {
7273 matches!(
7274 ctx.filtered_parent_child_has_qualifier(
7275 &["SG4", "SG8"],
7276 "SEQ",
7277 0,
7278 code,
7279 "SG10",
7280 "CCI",
7281 0,
7282 "11",
7283 ),
7284 ConditionResult::True
7285 )
7286 });
7287 return ConditionResult::from(!has_cci11);
7288 }
7289 };
7290
7291 let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
7292 for i in 0..sg8_count {
7293 let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
7294 let has_cci11 = (0..sg10_count).any(|j| {
7295 let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
7296 ccis.iter().any(|s| {
7297 s.elements
7298 .first()
7299 .and_then(|e: &Vec<String>| e.first())
7300 .is_some_and(|v: &String| v == "11")
7301 })
7302 });
7303 if !has_cci11 {
7304 return ConditionResult::True;
7305 }
7306 }
7307 ConditionResult::False
7308 }
7309
7310 fn evaluate_446(&self, ctx: &EvaluationContext) -> ConditionResult {
7312 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
7314 let found = cci_segs.iter().any(|s| {
7315 s.elements
7316 .first()
7317 .and_then(|e| e.first())
7318 .is_some_and(|v| v == "Z17")
7319 });
7320 ConditionResult::from(found)
7321 }
7322
7323 fn evaluate_447(&self, ctx: &EvaluationContext) -> ConditionResult {
7325 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
7327 let found = cci_segs.iter().any(|s| {
7328 s.elements
7329 .first()
7330 .and_then(|e| e.first())
7331 .is_some_and(|v| v == "Z50")
7332 });
7333 ConditionResult::from(found)
7334 }
7335
7336 fn evaluate_448(&self, ctx: &EvaluationContext) -> ConditionResult {
7338 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
7340 let found = cci_segs.iter().any(|s| {
7341 s.elements
7342 .first()
7343 .and_then(|e| e.first())
7344 .is_some_and(|v| v == "Z56")
7345 });
7346 ConditionResult::from(found)
7347 }
7348
7349 fn evaluate_449(&self, ctx: &EvaluationContext) -> ConditionResult {
7351 let cci_segs = ctx.scoped_find_segments_in("SG8", "CCI");
7353 let has_cci = cci_segs.iter().any(|s| {
7354 s.elements
7355 .first()
7356 .and_then(|e| e.first())
7357 .is_some_and(|v| v == "6")
7358 && s.elements
7359 .get(2)
7360 .and_then(|e| e.first())
7361 .is_some_and(|v| v == "ZA9")
7362 });
7363 let cav_segs = ctx.scoped_find_segments_in("SG8", "CAV");
7364 let has_cav = cav_segs.iter().any(|s| {
7365 s.elements
7366 .first()
7367 .and_then(|e| e.first())
7368 .is_some_and(|v| v == "ZG3")
7369 });
7370 ConditionResult::from(has_cci && has_cav)
7371 }
7372
7373 fn evaluate_450(&self, ctx: &EvaluationContext) -> ConditionResult {
7375 ctx.has_qualifier("RFF", 0, "Z32")
7377 }
7378
7379 fn evaluate_451(&self, ctx: &EvaluationContext) -> ConditionResult {
7381 ctx.has_qualifier("RFF", 0, "Z18")
7383 }
7384
7385 fn evaluate_452(&self, ctx: &EvaluationContext) -> ConditionResult {
7387 ctx.has_qualifier("RFF", 0, "Z19")
7389 }
7390
7391 fn evaluate_453(&self, ctx: &EvaluationContext) -> ConditionResult {
7393 ctx.external.evaluate("code_list_membership_check")
7394 }
7395
7396 fn evaluate_454(&self, _ctx: &EvaluationContext) -> ConditionResult {
7398 ConditionResult::True
7400 }
7401
7402 fn evaluate_455(&self, _ctx: &EvaluationContext) -> ConditionResult {
7404 ConditionResult::True
7406 }
7407
7408 fn evaluate_456(&self, ctx: &EvaluationContext) -> ConditionResult {
7410 ctx.has_qualifier("RFF", 0, "Z37")
7412 }
7413
7414 fn evaluate_457(&self, ctx: &EvaluationContext) -> ConditionResult {
7416 let pia_segs = ctx.find_segments("PIA");
7418 let found = pia_segs.iter().any(|s| {
7419 s.elements
7420 .first()
7421 .and_then(|e| e.first())
7422 .is_some_and(|v| v == "5")
7423 && s.elements
7424 .get(1)
7425 .and_then(|e| e.first())
7426 .is_some_and(|v| v == "9991000001498")
7427 });
7428 ConditionResult::from(found)
7429 }
7430
7431 fn evaluate_458(&self, ctx: &EvaluationContext) -> ConditionResult {
7433 let pia_segs = ctx.find_segments("PIA");
7435 let found = pia_segs.iter().any(|s| {
7436 s.elements
7437 .first()
7438 .and_then(|e| e.first())
7439 .is_some_and(|v| v == "5")
7440 && s.elements
7441 .get(1)
7442 .and_then(|e| e.first())
7443 .is_some_and(|v| v == "9991000000739")
7444 });
7445 ConditionResult::from(found)
7446 }
7447
7448 fn evaluate_459(&self, ctx: &EvaluationContext) -> ConditionResult {
7450 ctx.external.evaluate("code_list_membership_check")
7451 }
7452
7453 fn evaluate_460(&self, ctx: &EvaluationContext) -> ConditionResult {
7455 ctx.external.evaluate("code_list_membership_check")
7456 }
7457
7458 fn evaluate_461(&self, ctx: &EvaluationContext) -> ConditionResult {
7460 let cci_segs = ctx.scoped_find_segments_in("SG10", "CCI");
7462 let found = cci_segs.iter().any(|s| {
7463 s.elements
7464 .first()
7465 .and_then(|e| e.first())
7466 .is_some_and(|v| v == "Z17")
7467 });
7468 ConditionResult::from(found)
7469 }
7470
7471 fn evaluate_462(&self, ctx: &EvaluationContext) -> ConditionResult {
7473 let cci_segs = ctx.scoped_find_segments_in("SG10", "CCI");
7475 let found = cci_segs.iter().any(|s| {
7476 s.elements
7477 .first()
7478 .and_then(|e| e.first())
7479 .is_some_and(|v| v == "Z17")
7480 });
7481 ConditionResult::from(found)
7482 }
7483
7484 fn evaluate_463(&self, ctx: &EvaluationContext) -> ConditionResult {
7486 let cci_segs = ctx.scoped_find_segments_in("SG10", "CCI");
7488 let found = cci_segs.iter().any(|s| {
7489 s.elements
7490 .first()
7491 .and_then(|e| e.first())
7492 .is_some_and(|v| v == "Z61")
7493 && s.elements
7494 .get(2)
7495 .and_then(|e| e.first())
7496 .is_some_and(|v| v == "ZF9")
7497 });
7498 ConditionResult::from(found)
7499 }
7500
7501 fn evaluate_465(&self, ctx: &EvaluationContext) -> ConditionResult {
7503 let rff_segs = ctx.scoped_find_segments_in("SG8", "RFF");
7505 let found = rff_segs.iter().any(|s| {
7506 s.elements
7507 .first()
7508 .and_then(|e| e.first())
7509 .is_some_and(|v| v == "Z38")
7510 });
7511 ConditionResult::from(found)
7512 }
7513
7514 fn evaluate_466(&self, ctx: &EvaluationContext) -> ConditionResult {
7516 let rff_segs = ctx.scoped_find_segments_in("SG8", "RFF");
7518 let found = rff_segs.iter().any(|s| {
7519 s.elements
7520 .first()
7521 .and_then(|e| e.first())
7522 .is_some_and(|v| v == "Z32")
7523 });
7524 ConditionResult::from(found)
7525 }
7526
7527 fn evaluate_467(&self, ctx: &EvaluationContext) -> ConditionResult {
7529 let segs = ctx.scoped_find_segments_in("SG8", "CAV");
7531 let found = segs.iter().any(|s| {
7532 s.elements
7533 .first()
7534 .and_then(|e| e.first())
7535 .is_some_and(|v| v == "ZG8")
7536 });
7537 ConditionResult::from(found)
7538 }
7539
7540 fn evaluate_468(&self, ctx: &EvaluationContext) -> ConditionResult {
7542 let segs = ctx.scoped_find_segments_in("SG8", "CAV");
7544 let found = segs.iter().any(|s| {
7545 s.elements
7546 .first()
7547 .and_then(|e| e.first())
7548 .is_some_and(|v| v == "ZH0")
7549 });
7550 ConditionResult::from(found)
7551 }
7552
7553 fn evaluate_469(&self, ctx: &EvaluationContext) -> ConditionResult {
7555 let segs = ctx.scoped_find_segments_in("SG8", "CAV");
7557 let found = segs.iter().any(|s| {
7558 s.elements
7559 .first()
7560 .and_then(|e| e.first())
7561 .is_some_and(|v| v == "ZH1")
7562 });
7563 ConditionResult::from(found)
7564 }
7565
7566 fn evaluate_470(&self, ctx: &EvaluationContext) -> ConditionResult {
7568 let segs = ctx.scoped_find_segments_in("SG8", "CAV");
7570 let found = segs.iter().any(|s| {
7571 s.elements
7572 .first()
7573 .and_then(|e| e.first())
7574 .is_some_and(|v| v == "ZH5")
7575 });
7576 ConditionResult::from(found)
7577 }
7578
7579 fn evaluate_471(&self, ctx: &EvaluationContext) -> ConditionResult {
7581 let found = ctx.find_segments("RFF").iter().any(|s| {
7583 let qual = s
7584 .elements
7585 .first()
7586 .and_then(|e| e.first())
7587 .map(|v| v.as_str());
7588 matches!(qual, Some("Z49") | Some("Z53"))
7589 && s.elements
7590 .first()
7591 .and_then(|e| e.get(2))
7592 .is_some_and(|v| v.parse::<u32>().is_ok_and(|n| n > 1))
7593 });
7594 ConditionResult::from(found)
7595 }
7596
7597 fn evaluate_472(&self, ctx: &EvaluationContext) -> ConditionResult {
7599 let found = ctx.find_segments("RFF").iter().any(|s| {
7601 let qual = s
7602 .elements
7603 .first()
7604 .and_then(|e| e.first())
7605 .map(|v| v.as_str());
7606 matches!(qual, Some("Z48") | Some("Z55"))
7607 && s.elements
7608 .first()
7609 .and_then(|e| e.get(2))
7610 .is_some_and(|v| v.parse::<u32>().is_ok_and(|n| n > 1))
7611 });
7612 ConditionResult::from(found)
7613 }
7614
7615 fn evaluate_473(&self, ctx: &EvaluationContext) -> ConditionResult {
7617 let found = ctx.find_segments("RFF").iter().any(|s| {
7619 let qual = s
7620 .elements
7621 .first()
7622 .and_then(|e| e.first())
7623 .map(|v| v.as_str());
7624 matches!(qual, Some("Z47") | Some("Z54"))
7625 && s.elements
7626 .first()
7627 .and_then(|e| e.get(2))
7628 .is_some_and(|v| v.parse::<u32>().is_ok_and(|n| n > 1))
7629 });
7630 ConditionResult::from(found)
7631 }
7632
7633 fn evaluate_474(&self, ctx: &EvaluationContext) -> ConditionResult {
7635 let sts_segs = ctx.find_segments("STS");
7636 let found = sts_segs.iter().any(|s| {
7637 s.elements
7638 .first()
7639 .and_then(|e| e.first())
7640 .is_some_and(|v| v == "7")
7641 && s.elements
7642 .get(2)
7643 .and_then(|e| e.first())
7644 .is_some_and(|v| ["ZC8"].contains(&v.as_str()))
7645 });
7646 ConditionResult::from(found)
7647 }
7648
7649 fn evaluate_475(&self, ctx: &EvaluationContext) -> ConditionResult {
7651 let sts_segs = ctx.find_segments("STS");
7652 let found = sts_segs.iter().any(|s| {
7653 s.elements
7654 .first()
7655 .and_then(|e| e.first())
7656 .is_some_and(|v| v == "7")
7657 && s.elements
7658 .get(2)
7659 .and_then(|e| e.first())
7660 .is_some_and(|v| ["ZH1"].contains(&v.as_str()))
7661 });
7662 ConditionResult::from(found)
7663 }
7664
7665 fn evaluate_476(&self, ctx: &EvaluationContext) -> ConditionResult {
7667 let sts_segs = ctx.find_segments("STS");
7668 let found = sts_segs.iter().any(|s| {
7669 s.elements
7670 .first()
7671 .and_then(|e| e.first())
7672 .is_some_and(|v| v == "7")
7673 && s.elements
7674 .get(3)
7675 .and_then(|e| e.first())
7676 .is_some_and(|v| ["ZW0"].contains(&v.as_str()))
7677 });
7678 ConditionResult::from(found)
7679 }
7680
7681 fn evaluate_477(&self, ctx: &EvaluationContext) -> ConditionResult {
7683 let sts_segs = ctx.find_segments("STS");
7684 let found = sts_segs.iter().any(|s| {
7685 s.elements
7686 .first()
7687 .and_then(|e| e.first())
7688 .is_some_and(|v| v == "7")
7689 && s.elements
7690 .get(3)
7691 .and_then(|e| e.first())
7692 .is_some_and(|v| ["ZW1"].contains(&v.as_str()))
7693 });
7694 ConditionResult::from(found)
7695 }
7696
7697 fn evaluate_478(&self, ctx: &EvaluationContext) -> ConditionResult {
7699 let sts_segs = ctx.find_segments("STS");
7700 let found = sts_segs.iter().any(|s| {
7701 s.elements
7702 .first()
7703 .and_then(|e| e.first())
7704 .is_some_and(|v| v == "7")
7705 && s.elements
7706 .get(3)
7707 .and_then(|e| e.first())
7708 .is_some_and(|v| ["ZW2"].contains(&v.as_str()))
7709 });
7710 ConditionResult::from(found)
7711 }
7712
7713 fn evaluate_479(&self, ctx: &EvaluationContext) -> ConditionResult {
7715 let sts_segs = ctx.find_segments("STS");
7716 let found = sts_segs.iter().any(|s| {
7717 s.elements
7718 .first()
7719 .and_then(|e| e.first())
7720 .is_some_and(|v| v == "7")
7721 && s.elements
7722 .get(3)
7723 .and_then(|e| e.first())
7724 .is_some_and(|v| ["ZW3"].contains(&v.as_str()))
7725 });
7726 ConditionResult::from(found)
7727 }
7728
7729 fn evaluate_480(&self, ctx: &EvaluationContext) -> ConditionResult {
7731 let sts_segs = ctx.find_segments("STS");
7732 let found = sts_segs.iter().any(|s| {
7733 s.elements
7734 .first()
7735 .and_then(|e| e.first())
7736 .is_some_and(|v| v == "7")
7737 && s.elements
7738 .get(3)
7739 .and_then(|e| e.first())
7740 .is_some_and(|v| ["ZW4"].contains(&v.as_str()))
7741 });
7742 ConditionResult::from(found)
7743 }
7744
7745 fn evaluate_481(&self, ctx: &EvaluationContext) -> ConditionResult {
7747 let sts_segs = ctx.find_segments("STS");
7748 let found = sts_segs.iter().any(|s| {
7749 s.elements
7750 .first()
7751 .and_then(|e| e.first())
7752 .is_some_and(|v| v == "7")
7753 && s.elements
7754 .get(3)
7755 .and_then(|e| e.first())
7756 .is_some_and(|v| ["ZW5"].contains(&v.as_str()))
7757 });
7758 ConditionResult::from(found)
7759 }
7760
7761 fn evaluate_483(&self, ctx: &EvaluationContext) -> ConditionResult {
7763 let sts_segs = ctx.find_segments("STS");
7764 let found = sts_segs.iter().any(|s| {
7765 s.elements
7766 .first()
7767 .and_then(|e| e.first())
7768 .is_some_and(|v| v == "7")
7769 && s.elements
7770 .get(3)
7771 .and_then(|e| e.first())
7772 .is_some_and(|v| ["ZW7"].contains(&v.as_str()))
7773 });
7774 ConditionResult::from(found)
7775 }
7776
7777 fn evaluate_484(&self, ctx: &EvaluationContext) -> ConditionResult {
7779 let sts_segs = ctx.find_segments("STS");
7780 let found = sts_segs.iter().any(|s| {
7781 s.elements
7782 .first()
7783 .and_then(|e| e.first())
7784 .is_some_and(|v| v == "7")
7785 && s.elements
7786 .get(3)
7787 .and_then(|e| e.first())
7788 .is_some_and(|v| ["ZW8"].contains(&v.as_str()))
7789 });
7790 ConditionResult::from(found)
7791 }
7792
7793 fn evaluate_487(&self, ctx: &EvaluationContext) -> ConditionResult {
7795 let sts_segs = ctx.find_segments("STS");
7796 let found = sts_segs.iter().any(|s| {
7797 s.elements
7798 .first()
7799 .and_then(|e| e.first())
7800 .is_some_and(|v| v == "7")
7801 && s.elements
7802 .get(3)
7803 .and_then(|e| e.first())
7804 .is_some_and(|v| ["ZX1"].contains(&v.as_str()))
7805 });
7806 ConditionResult::from(found)
7807 }
7808
7809 fn evaluate_489(&self, ctx: &EvaluationContext) -> ConditionResult {
7811 let rff_z49 = ctx.find_segments_with_qualifier("RFF", 0, "Z49");
7813 if rff_z49.is_empty() {
7814 return ConditionResult::Unknown;
7815 }
7816 ConditionResult::True
7818 }
7819
7820 fn evaluate_490(&self, ctx: &EvaluationContext) -> ConditionResult {
7822 ctx.format_check("DTM", 0, 1, is_mesz_utc)
7823 }
7824
7825 fn evaluate_491(&self, ctx: &EvaluationContext) -> ConditionResult {
7827 ctx.format_check("DTM", 0, 1, is_mez_utc)
7828 }
7829
7830 fn evaluate_494(&self, ctx: &EvaluationContext) -> ConditionResult {
7832 let val = ctx.resolved_value.or_else(|| {
7835 ctx.find_segments_with_qualifier("DTM", 0, "137")
7836 .first()
7837 .and_then(|s| s.elements.first())
7838 .and_then(|e| e.get(1))
7839 .map(|v| v.as_str())
7840 });
7841 let Some(dtm_val) = val else {
7842 return ConditionResult::Unknown;
7843 };
7844 if dtm_val.len() < 12 {
7845 return ConditionResult::Unknown;
7846 }
7847 let now_str = crate::eval::format_validators::utc_now_ccyymmddhhmm();
7848 ConditionResult::from(&dtm_val[..12] <= now_str.as_str())
7849 }
7850
7851 fn evaluate_500(&self, _ctx: &EvaluationContext) -> ConditionResult {
7853 ConditionResult::True
7854 }
7855
7856 fn evaluate_501(&self, _ctx: &EvaluationContext) -> ConditionResult {
7858 ConditionResult::True
7859 }
7860
7861 fn evaluate_502(&self, _ctx: &EvaluationContext) -> ConditionResult {
7863 ConditionResult::True
7864 }
7865
7866 fn evaluate_503(&self, _ctx: &EvaluationContext) -> ConditionResult {
7868 ConditionResult::True
7869 }
7870
7871 fn evaluate_504(&self, _ctx: &EvaluationContext) -> ConditionResult {
7873 ConditionResult::True
7874 }
7875
7876 fn evaluate_505(&self, _ctx: &EvaluationContext) -> ConditionResult {
7878 ConditionResult::True
7879 }
7880
7881 fn evaluate_506(&self, _ctx: &EvaluationContext) -> ConditionResult {
7883 ConditionResult::True
7884 }
7885
7886 fn evaluate_507(&self, _ctx: &EvaluationContext) -> ConditionResult {
7888 ConditionResult::True
7889 }
7890
7891 fn evaluate_508(&self, _ctx: &EvaluationContext) -> ConditionResult {
7893 ConditionResult::True
7894 }
7895
7896 fn evaluate_509(&self, _ctx: &EvaluationContext) -> ConditionResult {
7898 ConditionResult::True
7899 }
7900
7901 fn evaluate_510(&self, _ctx: &EvaluationContext) -> ConditionResult {
7903 ConditionResult::True
7904 }
7905
7906 fn evaluate_511(&self, _ctx: &EvaluationContext) -> ConditionResult {
7908 ConditionResult::True
7909 }
7910
7911 fn evaluate_512(&self, _ctx: &EvaluationContext) -> ConditionResult {
7913 ConditionResult::True
7914 }
7915
7916 fn evaluate_513(&self, _ctx: &EvaluationContext) -> ConditionResult {
7918 ConditionResult::True
7919 }
7920
7921 fn evaluate_514(&self, _ctx: &EvaluationContext) -> ConditionResult {
7923 ConditionResult::True
7924 }
7925
7926 fn evaluate_515(&self, _ctx: &EvaluationContext) -> ConditionResult {
7928 ConditionResult::True
7929 }
7930
7931 fn evaluate_516(&self, _ctx: &EvaluationContext) -> ConditionResult {
7933 ConditionResult::True
7934 }
7935
7936 fn evaluate_517(&self, _ctx: &EvaluationContext) -> ConditionResult {
7938 ConditionResult::True
7939 }
7940
7941 fn evaluate_518(&self, _ctx: &EvaluationContext) -> ConditionResult {
7943 ConditionResult::True
7944 }
7945
7946 fn evaluate_519(&self, _ctx: &EvaluationContext) -> ConditionResult {
7948 ConditionResult::True
7949 }
7950
7951 fn evaluate_520(&self, _ctx: &EvaluationContext) -> ConditionResult {
7953 ConditionResult::True
7954 }
7955
7956 fn evaluate_521(&self, _ctx: &EvaluationContext) -> ConditionResult {
7958 ConditionResult::True
7959 }
7960
7961 fn evaluate_522(&self, _ctx: &EvaluationContext) -> ConditionResult {
7963 ConditionResult::True
7964 }
7965
7966 fn evaluate_523(&self, _ctx: &EvaluationContext) -> ConditionResult {
7968 ConditionResult::True
7969 }
7970
7971 fn evaluate_524(&self, _ctx: &EvaluationContext) -> ConditionResult {
7973 ConditionResult::True
7974 }
7975
7976 fn evaluate_525(&self, _ctx: &EvaluationContext) -> ConditionResult {
7978 ConditionResult::True
7979 }
7980
7981 fn evaluate_526(&self, _ctx: &EvaluationContext) -> ConditionResult {
7983 ConditionResult::True
7984 }
7985
7986 fn evaluate_527(&self, _ctx: &EvaluationContext) -> ConditionResult {
7988 ConditionResult::True
7989 }
7990
7991 fn evaluate_528(&self, _ctx: &EvaluationContext) -> ConditionResult {
7993 ConditionResult::True
7994 }
7995
7996 fn evaluate_529(&self, _ctx: &EvaluationContext) -> ConditionResult {
7998 ConditionResult::True
7999 }
8000
8001 fn evaluate_530(&self, _ctx: &EvaluationContext) -> ConditionResult {
8003 ConditionResult::True
8004 }
8005
8006 fn evaluate_531(&self, _ctx: &EvaluationContext) -> ConditionResult {
8008 ConditionResult::True
8009 }
8010
8011 fn evaluate_532(&self, _ctx: &EvaluationContext) -> ConditionResult {
8013 ConditionResult::True
8014 }
8015
8016 fn evaluate_533(&self, _ctx: &EvaluationContext) -> ConditionResult {
8018 ConditionResult::True
8019 }
8020
8021 fn evaluate_555(&self, _ctx: &EvaluationContext) -> ConditionResult {
8023 ConditionResult::Unknown
8025 }
8026
8027 fn evaluate_556(&self, _ctx: &EvaluationContext) -> ConditionResult {
8029 ConditionResult::True
8030 }
8031
8032 fn evaluate_558(&self, _ctx: &EvaluationContext) -> ConditionResult {
8034 ConditionResult::True
8035 }
8036
8037 fn evaluate_559(&self, _ctx: &EvaluationContext) -> ConditionResult {
8039 ConditionResult::True
8040 }
8041
8042 fn evaluate_563(&self, _ctx: &EvaluationContext) -> ConditionResult {
8044 ConditionResult::True
8045 }
8046
8047 fn evaluate_566(&self, _ctx: &EvaluationContext) -> ConditionResult {
8049 ConditionResult::True
8050 }
8051
8052 fn evaluate_567(&self, _ctx: &EvaluationContext) -> ConditionResult {
8054 ConditionResult::True
8055 }
8056
8057 fn evaluate_568(&self, _ctx: &EvaluationContext) -> ConditionResult {
8059 ConditionResult::True
8060 }
8061
8062 fn evaluate_569(&self, _ctx: &EvaluationContext) -> ConditionResult {
8064 ConditionResult::True
8065 }
8066
8067 fn evaluate_570(&self, _ctx: &EvaluationContext) -> ConditionResult {
8069 ConditionResult::True
8070 }
8071
8072 fn evaluate_572(&self, _ctx: &EvaluationContext) -> ConditionResult {
8074 ConditionResult::True
8075 }
8076
8077 fn evaluate_576(&self, _ctx: &EvaluationContext) -> ConditionResult {
8079 ConditionResult::True
8080 }
8081
8082 fn evaluate_577(&self, _ctx: &EvaluationContext) -> ConditionResult {
8084 ConditionResult::True
8085 }
8086
8087 fn evaluate_579(&self, _ctx: &EvaluationContext) -> ConditionResult {
8089 ConditionResult::True
8090 }
8091
8092 fn evaluate_580(&self, _ctx: &EvaluationContext) -> ConditionResult {
8094 ConditionResult::True
8095 }
8096
8097 fn evaluate_581(&self, _ctx: &EvaluationContext) -> ConditionResult {
8099 ConditionResult::True
8100 }
8101
8102 fn evaluate_586(&self, _ctx: &EvaluationContext) -> ConditionResult {
8104 ConditionResult::True
8105 }
8106
8107 fn evaluate_590(&self, _ctx: &EvaluationContext) -> ConditionResult {
8109 ConditionResult::True
8110 }
8111
8112 fn evaluate_594(&self, _ctx: &EvaluationContext) -> ConditionResult {
8114 ConditionResult::True
8115 }
8116
8117 fn evaluate_599(&self, _ctx: &EvaluationContext) -> ConditionResult {
8119 ConditionResult::True
8120 }
8121
8122 fn evaluate_601(&self, _ctx: &EvaluationContext) -> ConditionResult {
8124 ConditionResult::True
8125 }
8126
8127 fn evaluate_606(&self, _ctx: &EvaluationContext) -> ConditionResult {
8129 ConditionResult::True
8130 }
8131
8132 fn evaluate_609(&self, _ctx: &EvaluationContext) -> ConditionResult {
8134 ConditionResult::True
8135 }
8136
8137 fn evaluate_611(&self, _ctx: &EvaluationContext) -> ConditionResult {
8139 ConditionResult::True
8140 }
8141
8142 fn evaluate_614(&self, _ctx: &EvaluationContext) -> ConditionResult {
8144 ConditionResult::True
8145 }
8146
8147 fn evaluate_617(&self, _ctx: &EvaluationContext) -> ConditionResult {
8149 ConditionResult::True
8150 }
8151
8152 fn evaluate_618(&self, _ctx: &EvaluationContext) -> ConditionResult {
8154 ConditionResult::True
8155 }
8156
8157 fn evaluate_619(&self, _ctx: &EvaluationContext) -> ConditionResult {
8159 ConditionResult::True
8160 }
8161
8162 fn evaluate_621(&self, _ctx: &EvaluationContext) -> ConditionResult {
8164 ConditionResult::True
8165 }
8166
8167 fn evaluate_622(&self, _ctx: &EvaluationContext) -> ConditionResult {
8169 ConditionResult::True
8170 }
8171
8172 fn evaluate_623(&self, _ctx: &EvaluationContext) -> ConditionResult {
8174 ConditionResult::True
8175 }
8176
8177 fn evaluate_630(&self, _ctx: &EvaluationContext) -> ConditionResult {
8179 ConditionResult::True
8180 }
8181
8182 fn evaluate_631(&self, _ctx: &EvaluationContext) -> ConditionResult {
8184 ConditionResult::True
8185 }
8186
8187 fn evaluate_632(&self, _ctx: &EvaluationContext) -> ConditionResult {
8189 ConditionResult::True
8190 }
8191
8192 fn evaluate_637(&self, _ctx: &EvaluationContext) -> ConditionResult {
8194 ConditionResult::True
8195 }
8196
8197 fn evaluate_638(&self, _ctx: &EvaluationContext) -> ConditionResult {
8199 ConditionResult::True
8200 }
8201
8202 fn evaluate_639(&self, _ctx: &EvaluationContext) -> ConditionResult {
8204 ConditionResult::True
8205 }
8206
8207 fn evaluate_640(&self, _ctx: &EvaluationContext) -> ConditionResult {
8209 ConditionResult::True
8210 }
8211
8212 fn evaluate_641(&self, _ctx: &EvaluationContext) -> ConditionResult {
8214 ConditionResult::True
8215 }
8216
8217 fn evaluate_642(&self, _ctx: &EvaluationContext) -> ConditionResult {
8219 ConditionResult::True
8220 }
8221
8222 fn evaluate_643(&self, _ctx: &EvaluationContext) -> ConditionResult {
8224 ConditionResult::True
8225 }
8226
8227 fn evaluate_645(&self, _ctx: &EvaluationContext) -> ConditionResult {
8229 ConditionResult::True
8230 }
8231
8232 fn evaluate_646(&self, _ctx: &EvaluationContext) -> ConditionResult {
8234 ConditionResult::True
8235 }
8236
8237 fn evaluate_647(&self, _ctx: &EvaluationContext) -> ConditionResult {
8239 ConditionResult::True
8240 }
8241
8242 fn evaluate_648(&self, _ctx: &EvaluationContext) -> ConditionResult {
8244 ConditionResult::True
8245 }
8246
8247 fn evaluate_651(&self, _ctx: &EvaluationContext) -> ConditionResult {
8249 ConditionResult::True
8250 }
8251
8252 fn evaluate_653(&self, _ctx: &EvaluationContext) -> ConditionResult {
8254 ConditionResult::True
8255 }
8256
8257 fn evaluate_655(&self, _ctx: &EvaluationContext) -> ConditionResult {
8259 ConditionResult::True
8260 }
8261
8262 fn evaluate_659(&self, _ctx: &EvaluationContext) -> ConditionResult {
8264 ConditionResult::True
8265 }
8266
8267 fn evaluate_660(&self, _ctx: &EvaluationContext) -> ConditionResult {
8269 ConditionResult::True
8270 }
8271
8272 fn evaluate_662(&self, _ctx: &EvaluationContext) -> ConditionResult {
8274 ConditionResult::True
8275 }
8276
8277 fn evaluate_663(&self, _ctx: &EvaluationContext) -> ConditionResult {
8279 ConditionResult::True
8280 }
8281
8282 fn evaluate_664(&self, _ctx: &EvaluationContext) -> ConditionResult {
8284 ConditionResult::True
8285 }
8286
8287 fn evaluate_665(&self, _ctx: &EvaluationContext) -> ConditionResult {
8289 ConditionResult::True
8290 }
8291
8292 fn evaluate_667(&self, _ctx: &EvaluationContext) -> ConditionResult {
8294 ConditionResult::True
8295 }
8296
8297 fn evaluate_668(&self, _ctx: &EvaluationContext) -> ConditionResult {
8299 ConditionResult::True
8300 }
8301
8302 fn evaluate_670(&self, _ctx: &EvaluationContext) -> ConditionResult {
8304 ConditionResult::True
8305 }
8306
8307 fn evaluate_671(&self, _ctx: &EvaluationContext) -> ConditionResult {
8309 ConditionResult::True
8310 }
8311
8312 fn evaluate_672(&self, _ctx: &EvaluationContext) -> ConditionResult {
8314 ConditionResult::True
8315 }
8316
8317 fn evaluate_673(&self, _ctx: &EvaluationContext) -> ConditionResult {
8319 ConditionResult::True
8320 }
8321
8322 fn evaluate_674(&self, _ctx: &EvaluationContext) -> ConditionResult {
8324 ConditionResult::True
8325 }
8326
8327 fn evaluate_675(&self, _ctx: &EvaluationContext) -> ConditionResult {
8329 ConditionResult::True
8330 }
8331
8332 fn evaluate_677(&self, _ctx: &EvaluationContext) -> ConditionResult {
8334 ConditionResult::True
8335 }
8336
8337 fn evaluate_678(&self, _ctx: &EvaluationContext) -> ConditionResult {
8339 ConditionResult::True
8340 }
8341
8342 fn evaluate_679(&self, _ctx: &EvaluationContext) -> ConditionResult {
8344 ConditionResult::True
8345 }
8346
8347 fn evaluate_680(&self, _ctx: &EvaluationContext) -> ConditionResult {
8349 ConditionResult::True
8350 }
8351
8352 fn evaluate_682(&self, _ctx: &EvaluationContext) -> ConditionResult {
8354 ConditionResult::True
8355 }
8356
8357 fn evaluate_683(&self, _ctx: &EvaluationContext) -> ConditionResult {
8359 ConditionResult::True
8360 }
8361
8362 fn evaluate_684(&self, _ctx: &EvaluationContext) -> ConditionResult {
8364 ConditionResult::True
8365 }
8366
8367 fn evaluate_685(&self, _ctx: &EvaluationContext) -> ConditionResult {
8369 ConditionResult::True
8370 }
8371
8372 fn evaluate_687(&self, _ctx: &EvaluationContext) -> ConditionResult {
8374 ConditionResult::True
8375 }
8376
8377 fn evaluate_688(&self, _ctx: &EvaluationContext) -> ConditionResult {
8379 ConditionResult::True
8380 }
8381
8382 fn evaluate_689(&self, _ctx: &EvaluationContext) -> ConditionResult {
8384 ConditionResult::True
8385 }
8386
8387 fn evaluate_690(&self, _ctx: &EvaluationContext) -> ConditionResult {
8389 ConditionResult::True
8390 }
8391
8392 fn evaluate_693(&self, _ctx: &EvaluationContext) -> ConditionResult {
8394 ConditionResult::True
8395 }
8396
8397 fn evaluate_694(&self, _ctx: &EvaluationContext) -> ConditionResult {
8399 ConditionResult::True
8400 }
8401
8402 fn evaluate_695(&self, _ctx: &EvaluationContext) -> ConditionResult {
8404 ConditionResult::True
8405 }
8406
8407 fn evaluate_696(&self, _ctx: &EvaluationContext) -> ConditionResult {
8409 ConditionResult::True
8410 }
8411
8412 fn evaluate_698(&self, _ctx: &EvaluationContext) -> ConditionResult {
8414 ConditionResult::True
8415 }
8416
8417 fn evaluate_699(&self, _ctx: &EvaluationContext) -> ConditionResult {
8419 ConditionResult::True
8420 }
8421
8422 fn evaluate_700(&self, _ctx: &EvaluationContext) -> ConditionResult {
8424 ConditionResult::True
8425 }
8426
8427 fn evaluate_704(&self, _ctx: &EvaluationContext) -> ConditionResult {
8429 ConditionResult::True
8430 }
8431
8432 fn evaluate_705(&self, _ctx: &EvaluationContext) -> ConditionResult {
8434 ConditionResult::True
8435 }
8436
8437 fn evaluate_706(&self, ctx: &EvaluationContext) -> ConditionResult {
8439 ctx.external.evaluate("data_clearing_required")
8440 }
8441
8442 fn evaluate_707(&self, _ctx: &EvaluationContext) -> ConditionResult {
8444 ConditionResult::True
8445 }
8446
8447 fn evaluate_708(&self, _ctx: &EvaluationContext) -> ConditionResult {
8449 ConditionResult::True
8450 }
8451
8452 fn evaluate_709(&self, _ctx: &EvaluationContext) -> ConditionResult {
8454 ConditionResult::True
8455 }
8456
8457 fn evaluate_710(&self, _ctx: &EvaluationContext) -> ConditionResult {
8459 ConditionResult::True
8460 }
8461
8462 fn evaluate_711(&self, _ctx: &EvaluationContext) -> ConditionResult {
8464 ConditionResult::True
8465 }
8466
8467 fn evaluate_712(&self, _ctx: &EvaluationContext) -> ConditionResult {
8469 ConditionResult::True
8470 }
8471
8472 fn evaluate_713(&self, _ctx: &EvaluationContext) -> ConditionResult {
8474 ConditionResult::True
8475 }
8476
8477 fn evaluate_714(&self, _ctx: &EvaluationContext) -> ConditionResult {
8479 ConditionResult::True
8480 }
8481
8482 fn evaluate_715(&self, _ctx: &EvaluationContext) -> ConditionResult {
8484 ConditionResult::True
8485 }
8486
8487 fn evaluate_716(&self, _ctx: &EvaluationContext) -> ConditionResult {
8489 ConditionResult::True
8490 }
8491
8492 fn evaluate_717(&self, ctx: &EvaluationContext) -> ConditionResult {
8494 ctx.external.evaluate("data_clearing_required")
8495 }
8496
8497 fn evaluate_718(&self, _ctx: &EvaluationContext) -> ConditionResult {
8499 ConditionResult::True
8500 }
8501
8502 fn evaluate_719(&self, _ctx: &EvaluationContext) -> ConditionResult {
8504 ConditionResult::True
8505 }
8506
8507 fn evaluate_902(&self, _ctx: &EvaluationContext) -> ConditionResult {
8509 ConditionResult::True
8511 }
8512
8513 fn evaluate_910(&self, _ctx: &EvaluationContext) -> ConditionResult {
8515 ConditionResult::True
8517 }
8518
8519 fn evaluate_914(&self, ctx: &EvaluationContext) -> ConditionResult {
8521 ctx.format_check("SEQ", 1, 0, |val| validate_numeric(val, ">", 0.0))
8522 }
8523
8524 fn evaluate_922(&self, _ctx: &EvaluationContext) -> ConditionResult {
8526 ConditionResult::True
8528 }
8529
8530 fn evaluate_926(&self, _ctx: &EvaluationContext) -> ConditionResult {
8532 ConditionResult::True
8534 }
8535
8536 fn evaluate_930(&self, _ctx: &EvaluationContext) -> ConditionResult {
8538 ConditionResult::True
8540 }
8541
8542 fn evaluate_931(&self, ctx: &EvaluationContext) -> ConditionResult {
8544 ctx.format_check("DTM", 0, 1, validate_timezone_utc)
8545 }
8546
8547 fn evaluate_932(&self, ctx: &EvaluationContext) -> ConditionResult {
8549 ctx.format_check("DTM", 0, 1, |val| validate_hhmm_equals(val, "2200"))
8550 }
8551
8552 fn evaluate_933(&self, ctx: &EvaluationContext) -> ConditionResult {
8554 ctx.format_check("DTM", 0, 1, |val| validate_hhmm_equals(val, "2300"))
8555 }
8556
8557 fn evaluate_937(&self, ctx: &EvaluationContext) -> ConditionResult {
8559 ctx.format_check("SEQ", 1, 0, |val| validate_max_decimal_places(val, 0))
8560 }
8561
8562 fn evaluate_938(&self, _ctx: &EvaluationContext) -> ConditionResult {
8564 ConditionResult::True
8565 }
8566
8567 fn evaluate_939(&self, ctx: &EvaluationContext) -> ConditionResult {
8569 ctx.format_check("COM", 0, 0, validate_email)
8570 }
8571
8572 fn evaluate_940(&self, ctx: &EvaluationContext) -> ConditionResult {
8574 ctx.format_check("COM", 0, 0, validate_phone)
8575 }
8576
8577 fn evaluate_942(&self, _ctx: &EvaluationContext) -> ConditionResult {
8579 ConditionResult::True
8581 }
8582
8583 fn evaluate_943(&self, _ctx: &EvaluationContext) -> ConditionResult {
8585 ConditionResult::True
8587 }
8588
8589 fn evaluate_946(&self, _ctx: &EvaluationContext) -> ConditionResult {
8591 ConditionResult::True
8593 }
8594
8595 fn evaluate_948(&self, _ctx: &EvaluationContext) -> ConditionResult {
8597 ConditionResult::True
8599 }
8600
8601 fn evaluate_950(&self, _ctx: &EvaluationContext) -> ConditionResult {
8603 ConditionResult::True
8605 }
8606
8607 fn evaluate_951(&self, _ctx: &EvaluationContext) -> ConditionResult {
8609 ConditionResult::True
8611 }
8612
8613 fn evaluate_952(&self, _ctx: &EvaluationContext) -> ConditionResult {
8615 ConditionResult::True
8617 }
8618
8619 fn evaluate_955(&self, _ctx: &EvaluationContext) -> ConditionResult {
8621 ConditionResult::True
8623 }
8624
8625 fn evaluate_957(&self, _ctx: &EvaluationContext) -> ConditionResult {
8627 ConditionResult::True
8629 }
8630
8631 fn evaluate_960(&self, _ctx: &EvaluationContext) -> ConditionResult {
8633 ConditionResult::True
8635 }
8636
8637 fn evaluate_961(&self, _ctx: &EvaluationContext) -> ConditionResult {
8639 ConditionResult::True
8641 }
8642
8643 fn evaluate_967(&self, _ctx: &EvaluationContext) -> ConditionResult {
8645 ConditionResult::True
8647 }
8648
8649 fn evaluate_2001(&self, ctx: &EvaluationContext) -> ConditionResult {
8651 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
8653 ConditionResult::from(ide_count > 0)
8654 }
8655
8656 fn evaluate_2002(&self, ctx: &EvaluationContext) -> ConditionResult {
8658 let seq_segs = ctx.find_segments("SEQ");
8659 let has_z79 = seq_segs.iter().any(|s| {
8660 s.elements
8661 .first()
8662 .and_then(|e| e.first())
8663 .is_some_and(|v| v == "Z79")
8664 });
8665 ConditionResult::from(has_z79)
8666 }
8667
8668 fn evaluate_2003(&self, _ctx: &EvaluationContext) -> ConditionResult {
8670 ConditionResult::Unknown
8672 }
8673
8674 fn evaluate_2004(&self, ctx: &EvaluationContext) -> ConditionResult {
8677 let rff_qualifiers = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG6"]);
8678 let rff_zeitraum_ids = ctx.collect_group_values("RFF", 0, 2, &["SG4", "SG6"]);
8679
8680 let zeitraum_ids: Vec<String> = rff_qualifiers
8681 .iter()
8682 .filter(|(_, qual)| qual.as_str() == "Z49")
8683 .filter_map(|(idx, _)| {
8684 rff_zeitraum_ids
8685 .iter()
8686 .find(|(i, v)| i == idx && !v.is_empty())
8687 .map(|(_, v)| v.clone())
8688 })
8689 .collect();
8690
8691 if zeitraum_ids.is_empty() {
8692 return ConditionResult::Unknown;
8693 }
8694
8695 let seq_refs = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
8696
8697 for zid in &zeitraum_ids {
8698 let count = seq_refs.iter().filter(|(_, v)| v == zid).count();
8699 if count != 1 {
8700 return ConditionResult::False;
8701 }
8702 }
8703
8704 ConditionResult::True
8705 }
8706
8707 fn evaluate_2005(&self, ctx: &EvaluationContext) -> ConditionResult {
8710 let rff_qualifiers = ctx.collect_group_values("RFF", 0, 0, &["SG4", "SG6"]);
8711 let rff_zeitraum_ids = ctx.collect_group_values("RFF", 0, 2, &["SG4", "SG6"]);
8712
8713 let zeitraum_ids: Vec<String> = rff_qualifiers
8714 .iter()
8715 .filter(|(_, qual)| qual.as_str() == "Z49")
8716 .filter_map(|(idx, _)| {
8717 rff_zeitraum_ids
8718 .iter()
8719 .find(|(i, v)| i == idx && !v.is_empty())
8720 .map(|(_, v)| v.clone())
8721 })
8722 .collect();
8723
8724 if zeitraum_ids.is_empty() {
8725 return ConditionResult::Unknown;
8726 }
8727
8728 let seq_refs = ctx.collect_group_values("SEQ", 1, 0, &["SG4", "SG8"]);
8729
8730 for zid in &zeitraum_ids {
8731 let count = seq_refs.iter().filter(|(_, v)| v == zid).count();
8732 if count == 0 {
8733 return ConditionResult::False;
8734 }
8735 }
8736
8737 ConditionResult::True
8738 }
8739
8740 fn evaluate_2010(&self, _ctx: &EvaluationContext) -> ConditionResult {
8742 ConditionResult::Unknown
8744 }
8745
8746 fn evaluate_2011(&self, ctx: &EvaluationContext) -> ConditionResult {
8750 ctx.external
8751 .evaluate("request_message_zeitraum_ids_present")
8752 }
8753
8754 fn evaluate_2012(&self, _ctx: &EvaluationContext) -> ConditionResult {
8756 ConditionResult::Unknown
8758 }
8759
8760 fn evaluate_2013(&self, ctx: &EvaluationContext) -> ConditionResult {
8762 ctx.lacks_qualifier("RFF", 0, "Z54")
8764 }
8765
8766 fn evaluate_2014(&self, ctx: &EvaluationContext) -> ConditionResult {
8768 ctx.lacks_qualifier("RFF", 0, "Z47")
8770 }
8771
8772 fn evaluate_2015(&self, _ctx: &EvaluationContext) -> ConditionResult {
8774 ConditionResult::Unknown
8776 }
8777
8778 fn evaluate_2016(&self, ctx: &EvaluationContext) -> ConditionResult {
8780 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z16").len();
8782 ConditionResult::from(loc_count > 0)
8783 }
8784
8785 fn evaluate_2017(&self, ctx: &EvaluationContext) -> ConditionResult {
8787 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z17").len();
8789 ConditionResult::from(loc_count > 0)
8790 }
8791
8792 fn evaluate_2018(&self, _ctx: &EvaluationContext) -> ConditionResult {
8794 ConditionResult::Unknown
8796 }
8797
8798 fn evaluate_2060(&self, ctx: &EvaluationContext) -> ConditionResult {
8800 let found = ctx.find_segments("CAV").iter().any(|s| {
8802 s.elements
8803 .first()
8804 .and_then(|e| e.first())
8805 .is_some_and(|v| v == "NZR")
8806 });
8807 ConditionResult::from(found)
8808 }
8809
8810 fn evaluate_2061(&self, ctx: &EvaluationContext) -> ConditionResult {
8812 let ide_count = ctx.find_segments("IDE").len();
8814 ConditionResult::from(ide_count > 0)
8815 }
8816
8817 fn evaluate_2071(&self, ctx: &EvaluationContext) -> ConditionResult {
8819 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
8821 ConditionResult::from(ide_count > 0)
8822 }
8823
8824 fn evaluate_2073(&self, ctx: &EvaluationContext) -> ConditionResult {
8826 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
8828 ConditionResult::from(ide_count > 0)
8829 }
8830
8831 fn evaluate_2075(&self, ctx: &EvaluationContext) -> ConditionResult {
8833 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
8835 ConditionResult::from(ide_count > 0)
8836 }
8837
8838 fn evaluate_2080(&self, ctx: &EvaluationContext) -> ConditionResult {
8840 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
8842 ConditionResult::from(ide_count > 0)
8843 }
8844
8845 fn evaluate_2095(&self, ctx: &EvaluationContext) -> ConditionResult {
8847 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z15").len();
8849 ConditionResult::from(loc_count > 0)
8850 }
8851
8852 fn evaluate_2096(&self, ctx: &EvaluationContext) -> ConditionResult {
8854 let ide_count = ctx.find_segments("IDE").len();
8856 ConditionResult::from(ide_count > 0)
8857 }
8858
8859 fn evaluate_2119(&self, ctx: &EvaluationContext) -> ConditionResult {
8861 let found = ctx.find_segments("SEQ").iter().any(|s| {
8863 s.elements
8864 .first()
8865 .and_then(|e| e.first())
8866 .is_some_and(|v| v == "Z13" || v == "ZG0")
8867 });
8868 ConditionResult::from(found)
8869 }
8870
8871 fn evaluate_2140(&self, ctx: &EvaluationContext) -> ConditionResult {
8873 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "Z01").len();
8875 ConditionResult::from(ide_count > 0)
8876 }
8877
8878 fn evaluate_2182(&self, ctx: &EvaluationContext) -> ConditionResult {
8880 let found = ctx.find_segments("SEQ").iter().any(|s| {
8882 s.elements
8883 .first()
8884 .and_then(|e| e.first())
8885 .is_some_and(|v| ["Z01", "Z80", "Z81", "Z98"].contains(&v.as_str()))
8886 });
8887 ConditionResult::from(found)
8888 }
8889
8890 fn evaluate_2183(&self, ctx: &EvaluationContext) -> ConditionResult {
8892 let found = ctx.find_segments("SEQ").iter().any(|s| {
8894 s.elements
8895 .first()
8896 .and_then(|e| e.first())
8897 .is_some_and(|v| ["Z01", "Z80", "Z81", "Z98"].contains(&v.as_str()))
8898 });
8899 ConditionResult::from(found)
8900 }
8901
8902 fn evaluate_2207(&self, ctx: &EvaluationContext) -> ConditionResult {
8904 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "Z01").len();
8906 ConditionResult::from(ide_count > 0)
8907 }
8908
8909 fn evaluate_2225(&self, _ctx: &EvaluationContext) -> ConditionResult {
8911 ConditionResult::Unknown
8913 }
8914
8915 fn evaluate_2236(&self, ctx: &EvaluationContext) -> ConditionResult {
8917 let ide_count = ctx.find_segments_with_qualifier("IDE", 0, "24").len();
8919 ConditionResult::from(ide_count > 0)
8920 }
8921
8922 fn evaluate_2252(&self, _ctx: &EvaluationContext) -> ConditionResult {
8924 ConditionResult::Unknown
8926 }
8927
8928 fn evaluate_2261(&self, ctx: &EvaluationContext) -> ConditionResult {
8930 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z21").len();
8932 ConditionResult::from(loc_count > 0)
8933 }
8934
8935 fn evaluate_2284(&self, ctx: &EvaluationContext) -> ConditionResult {
8937 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z17").len();
8939 ConditionResult::from(loc_count > 0)
8940 }
8941
8942 fn evaluate_2286(&self, ctx: &EvaluationContext) -> ConditionResult {
8944 let found = !ctx.find_segments_with_qualifier("SEQ", 0, "ZF3").is_empty();
8946 ConditionResult::from(found)
8947 }
8948
8949 fn evaluate_2287(&self, ctx: &EvaluationContext) -> ConditionResult {
8951 let found = ctx.find_segments("SEQ").iter().any(|s| {
8953 s.elements
8954 .first()
8955 .and_then(|e| e.first())
8956 .is_some_and(|v| v == "Z03" || v == "ZF5")
8957 });
8958 ConditionResult::from(found)
8959 }
8960
8961 fn evaluate_2288(&self, _ctx: &EvaluationContext) -> ConditionResult {
8963 ConditionResult::Unknown
8965 }
8966
8967 fn evaluate_2307(&self, ctx: &EvaluationContext) -> ConditionResult {
8969 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z21").len();
8971 ConditionResult::from(loc_count > 0)
8972 }
8973
8974 fn evaluate_2308(&self, ctx: &EvaluationContext) -> ConditionResult {
8976 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z16").len();
8978 ConditionResult::from(loc_count > 0)
8979 }
8980
8981 fn evaluate_2309(&self, ctx: &EvaluationContext) -> ConditionResult {
8983 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z17").len();
8985 ConditionResult::from(loc_count > 0)
8986 }
8987
8988 fn evaluate_2310(&self, ctx: &EvaluationContext) -> ConditionResult {
8990 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z16").len();
8992 ConditionResult::from(loc_count > 0)
8993 }
8994
8995 fn evaluate_2311(&self, ctx: &EvaluationContext) -> ConditionResult {
8997 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z21").len();
8999 ConditionResult::from(loc_count > 0)
9000 }
9001
9002 fn evaluate_2312(&self, ctx: &EvaluationContext) -> ConditionResult {
9004 let rff_z33 = ctx.scoped_find_segments_in_with_qualifier("SG8", "RFF", 0, "Z33");
9007 let has_netzlokation = rff_z33.iter().any(|s| {
9008 s.elements
9009 .first()
9010 .and_then(|e| e.get(1))
9011 .is_some_and(|v| v == "9992000001256")
9012 });
9013 ConditionResult::from(!has_netzlokation)
9014 }
9015
9016 fn evaluate_2313(&self, ctx: &EvaluationContext) -> ConditionResult {
9018 let found = ctx.find_segments("SEQ").iter().any(|s| {
9020 s.elements
9021 .first()
9022 .and_then(|e| e.first())
9023 .is_some_and(|v| ["Z58", "ZC9", "ZD0", "ZD6"].contains(&v.as_str()))
9024 });
9025 ConditionResult::from(found)
9026 }
9027
9028 fn evaluate_2317(&self, ctx: &EvaluationContext) -> ConditionResult {
9030 let has_cav = ctx.scoped_find_segments_in("SG8", "CAV").iter().any(|s| {
9033 s.elements
9034 .first()
9035 .and_then(|e| e.first())
9036 .is_some_and(|v| ["MIW", "MPW", "MUW"].contains(&v.as_str()))
9037 });
9038 ConditionResult::from(has_cav)
9039 }
9040
9041 fn evaluate_2318(&self, ctx: &EvaluationContext) -> ConditionResult {
9043 let has_cav = ctx.scoped_find_segments_in("SG8", "CAV").iter().any(|s| {
9046 s.elements
9047 .first()
9048 .and_then(|e| e.first())
9049 .is_some_and(|v| v == "MBW")
9050 });
9051 ConditionResult::from(has_cav)
9052 }
9053
9054 fn evaluate_2344(&self, _ctx: &EvaluationContext) -> ConditionResult {
9056 ConditionResult::Unknown
9058 }
9059
9060 fn evaluate_2350(&self, _ctx: &EvaluationContext) -> ConditionResult {
9062 ConditionResult::Unknown
9064 }
9065
9066 fn evaluate_2351(&self, _ctx: &EvaluationContext) -> ConditionResult {
9068 ConditionResult::Unknown
9070 }
9071
9072 fn evaluate_2352(&self, _ctx: &EvaluationContext) -> ConditionResult {
9074 ConditionResult::Unknown
9076 }
9077
9078 fn evaluate_2356(&self, ctx: &EvaluationContext) -> ConditionResult {
9080 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z18").len();
9082 ConditionResult::from(loc_count > 0)
9083 }
9084
9085 fn evaluate_2357(&self, ctx: &EvaluationContext) -> ConditionResult {
9087 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z20").len();
9089 ConditionResult::from(loc_count > 0)
9090 }
9091
9092 fn evaluate_2358(&self, ctx: &EvaluationContext) -> ConditionResult {
9094 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z19").len();
9096 ConditionResult::from(loc_count > 0)
9097 }
9098
9099 fn evaluate_2359(&self, ctx: &EvaluationContext) -> ConditionResult {
9101 let found = ctx.find_segments("LOC").iter().any(|s| {
9103 s.elements
9104 .first()
9105 .and_then(|e| e.first())
9106 .is_some_and(|v| ["Z16", "Z17", "Z20"].contains(&v.as_str()))
9107 });
9108 ConditionResult::from(found)
9109 }
9110
9111 fn evaluate_2360(&self, ctx: &EvaluationContext) -> ConditionResult {
9113 let loc_count = ctx.find_segments_with_qualifier("LOC", 0, "Z18").len();
9115 ConditionResult::from(loc_count > 0)
9116 }
9117
9118 fn evaluate_2361(&self, ctx: &EvaluationContext) -> ConditionResult {
9120 let found = ctx.find_segments("LOC").iter().any(|s| {
9122 s.elements
9123 .first()
9124 .and_then(|e| e.first())
9125 .is_some_and(|v| ["Z17", "Z20", "Z22"].contains(&v.as_str()))
9126 });
9127 ConditionResult::from(found)
9128 }
9129}
9130
9131use mig_types::segment::OwnedSegment;
9134
9135struct Sg8Block {
9138 seq: String,
9139 malo_refs: Vec<String>,
9140 sg10: Vec<(Vec<OwnedSegment>, Vec<OwnedSegment>)>,
9141}
9142
9143fn component(seg: &OwnedSegment, element: usize, comp: usize) -> Option<&str> {
9144 seg.elements
9145 .get(element)
9146 .and_then(|e| e.get(comp))
9147 .map(String::as_str)
9148}
9149
9150fn sg8_blocks(ctx: &EvaluationContext) -> Option<Vec<Sg8Block>> {
9155 let malo_refs = |rffs: &[OwnedSegment]| -> Vec<String> {
9156 rffs.iter()
9157 .filter(|s| component(s, 0, 0) == Some("Z18"))
9158 .filter_map(|s| component(s, 0, 1).map(str::to_string))
9159 .collect()
9160 };
9161 if let Some(nav) = ctx.navigator() {
9162 let sg8 = ["SG4", "SG8"];
9163 return Some(
9164 (0..nav.group_instance_count(&sg8))
9165 .map(|i| Sg8Block {
9166 seq: nav
9167 .find_segments_in_group("SEQ", &sg8, i)
9168 .first()
9169 .and_then(|s| component(s, 0, 0).map(str::to_string))
9170 .unwrap_or_default(),
9171 malo_refs: malo_refs(&nav.find_segments_in_group("RFF", &sg8, i)),
9172 sg10: (0..nav.child_group_instance_count(&sg8, i, "SG10"))
9173 .map(|j| {
9174 (
9175 nav.find_segments_in_child_group("CCI", &sg8, i, "SG10", j),
9176 nav.find_segments_in_child_group("CAV", &sg8, i, "SG10", j),
9177 )
9178 })
9179 .collect(),
9180 })
9181 .collect(),
9182 );
9183 }
9184 if ctx.segments.is_empty() {
9185 return None;
9186 }
9187 let mut blocks: Vec<Sg8Block> = Vec::new();
9188 let mut rffs: Vec<OwnedSegment> = Vec::new();
9189 for seg in ctx.segments {
9190 match seg.id.as_str() {
9191 "SEQ" => {
9192 if let Some(b) = blocks.last_mut() {
9193 b.malo_refs = malo_refs(&std::mem::take(&mut rffs));
9194 }
9195 rffs.clear();
9196 blocks.push(Sg8Block {
9197 seq: component(seg, 0, 0).unwrap_or_default().to_string(),
9198 malo_refs: Vec::new(),
9199 sg10: Vec::new(),
9200 });
9201 }
9202 "NAD" | "UNT" | "IDE" => {
9204 if let Some(b) = blocks.last_mut() {
9205 if b.malo_refs.is_empty() {
9206 b.malo_refs = malo_refs(&std::mem::take(&mut rffs));
9207 }
9208 }
9209 rffs.clear();
9210 if seg.id == "IDE" {
9211 continue;
9212 }
9213 break;
9214 }
9215 "RFF" if !blocks.is_empty() => rffs.push(seg.clone()),
9216 "CCI" => {
9217 if let Some(b) = blocks.last_mut() {
9218 b.sg10.push((vec![seg.clone()], Vec::new()));
9219 }
9220 }
9221 "CAV" => {
9222 if let Some((_, cavs)) = blocks.last_mut().and_then(|b| b.sg10.last_mut()) {
9223 cavs.push(seg.clone());
9224 }
9225 }
9226 _ => {}
9227 }
9228 }
9229 if let Some(b) = blocks.last_mut() {
9230 if b.malo_refs.is_empty() {
9231 b.malo_refs = malo_refs(&rffs);
9232 }
9233 }
9234 Some(blocks)
9235}