001package org.hl7.fhir.r4.model; 002 003/* 004 Copyright (c) 2011+, HL7, Inc. 005 All rights reserved. 006 007 Redistribution and use in source and binary forms, with or without modification, 008 are permitted provided that the following conditions are met: 009 010 * Redistributions of source code must retain the above copyright notice, this 011 list of conditions and the following disclaimer. 012 * Redistributions in binary form must reproduce the above copyright notice, 013 this list of conditions and the following disclaimer in the documentation 014 and/or other materials provided with the distribution. 015 * Neither the name of HL7 nor the names of its contributors may be used to 016 endorse or promote products derived from this software without specific 017 prior written permission. 018 019 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 020 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 021 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 022 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 023 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 024 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 025 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 026 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 027 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 028 POSSIBILITY OF SUCH DAMAGE. 029 030*/ 031 032// Generated on Tue, May 12, 2020 07:26+1000 for FHIR v4.0.1 033import java.util.ArrayList; 034import java.util.Date; 035import java.util.List; 036 037import org.hl7.fhir.exceptions.FHIRException; 038import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 039import org.hl7.fhir.r4.model.Enumerations.PublicationStatus; 040import org.hl7.fhir.r4.model.Enumerations.PublicationStatusEnumFactory; 041import org.hl7.fhir.utilities.Utilities; 042 043import ca.uhn.fhir.model.api.annotation.Block; 044import ca.uhn.fhir.model.api.annotation.Child; 045import ca.uhn.fhir.model.api.annotation.ChildOrder; 046import ca.uhn.fhir.model.api.annotation.Description; 047import ca.uhn.fhir.model.api.annotation.ResourceDef; 048import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 049 050/** 051 * This resource allows for the definition of various types of plans as a 052 * sharable, consumable, and executable artifact. The resource is general enough 053 * to support the description of a broad range of clinical artifacts such as 054 * clinical decision support rules, order sets and protocols. 055 */ 056@ResourceDef(name = "PlanDefinition", profile = "http://hl7.org/fhir/StructureDefinition/PlanDefinition") 057@ChildOrder(names = { "url", "identifier", "version", "name", "title", "subtitle", "type", "status", "experimental", 058 "subject[x]", "date", "publisher", "contact", "description", "useContext", "jurisdiction", "purpose", "usage", 059 "copyright", "approvalDate", "lastReviewDate", "effectivePeriod", "topic", "author", "editor", "reviewer", 060 "endorser", "relatedArtifact", "library", "goal", "action" }) 061public class PlanDefinition extends MetadataResource { 062 063 public enum RequestPriority { 064 /** 065 * The request has normal priority. 066 */ 067 ROUTINE, 068 /** 069 * The request should be actioned promptly - higher priority than routine. 070 */ 071 URGENT, 072 /** 073 * The request should be actioned as soon as possible - higher priority than 074 * urgent. 075 */ 076 ASAP, 077 /** 078 * The request should be actioned immediately - highest possible priority. E.g. 079 * an emergency. 080 */ 081 STAT, 082 /** 083 * added to help the parsers with the generic types 084 */ 085 NULL; 086 087 public static RequestPriority fromCode(String codeString) throws FHIRException { 088 if (codeString == null || "".equals(codeString)) 089 return null; 090 if ("routine".equals(codeString)) 091 return ROUTINE; 092 if ("urgent".equals(codeString)) 093 return URGENT; 094 if ("asap".equals(codeString)) 095 return ASAP; 096 if ("stat".equals(codeString)) 097 return STAT; 098 if (Configuration.isAcceptInvalidEnums()) 099 return null; 100 else 101 throw new FHIRException("Unknown RequestPriority code '" + codeString + "'"); 102 } 103 104 public String toCode() { 105 switch (this) { 106 case ROUTINE: 107 return "routine"; 108 case URGENT: 109 return "urgent"; 110 case ASAP: 111 return "asap"; 112 case STAT: 113 return "stat"; 114 case NULL: 115 return null; 116 default: 117 return "?"; 118 } 119 } 120 121 public String getSystem() { 122 switch (this) { 123 case ROUTINE: 124 return "http://hl7.org/fhir/request-priority"; 125 case URGENT: 126 return "http://hl7.org/fhir/request-priority"; 127 case ASAP: 128 return "http://hl7.org/fhir/request-priority"; 129 case STAT: 130 return "http://hl7.org/fhir/request-priority"; 131 case NULL: 132 return null; 133 default: 134 return "?"; 135 } 136 } 137 138 public String getDefinition() { 139 switch (this) { 140 case ROUTINE: 141 return "The request has normal priority."; 142 case URGENT: 143 return "The request should be actioned promptly - higher priority than routine."; 144 case ASAP: 145 return "The request should be actioned as soon as possible - higher priority than urgent."; 146 case STAT: 147 return "The request should be actioned immediately - highest possible priority. E.g. an emergency."; 148 case NULL: 149 return null; 150 default: 151 return "?"; 152 } 153 } 154 155 public String getDisplay() { 156 switch (this) { 157 case ROUTINE: 158 return "Routine"; 159 case URGENT: 160 return "Urgent"; 161 case ASAP: 162 return "ASAP"; 163 case STAT: 164 return "STAT"; 165 case NULL: 166 return null; 167 default: 168 return "?"; 169 } 170 } 171 } 172 173 public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> { 174 public RequestPriority fromCode(String codeString) throws IllegalArgumentException { 175 if (codeString == null || "".equals(codeString)) 176 if (codeString == null || "".equals(codeString)) 177 return null; 178 if ("routine".equals(codeString)) 179 return RequestPriority.ROUTINE; 180 if ("urgent".equals(codeString)) 181 return RequestPriority.URGENT; 182 if ("asap".equals(codeString)) 183 return RequestPriority.ASAP; 184 if ("stat".equals(codeString)) 185 return RequestPriority.STAT; 186 throw new IllegalArgumentException("Unknown RequestPriority code '" + codeString + "'"); 187 } 188 189 public Enumeration<RequestPriority> fromType(PrimitiveType<?> code) throws FHIRException { 190 if (code == null) 191 return null; 192 if (code.isEmpty()) 193 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 194 String codeString = code.asStringValue(); 195 if (codeString == null || "".equals(codeString)) 196 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 197 if ("routine".equals(codeString)) 198 return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE, code); 199 if ("urgent".equals(codeString)) 200 return new Enumeration<RequestPriority>(this, RequestPriority.URGENT, code); 201 if ("asap".equals(codeString)) 202 return new Enumeration<RequestPriority>(this, RequestPriority.ASAP, code); 203 if ("stat".equals(codeString)) 204 return new Enumeration<RequestPriority>(this, RequestPriority.STAT, code); 205 throw new FHIRException("Unknown RequestPriority code '" + codeString + "'"); 206 } 207 208 public String toCode(RequestPriority code) { 209 if (code == RequestPriority.NULL) 210 return null; 211 if (code == RequestPriority.ROUTINE) 212 return "routine"; 213 if (code == RequestPriority.URGENT) 214 return "urgent"; 215 if (code == RequestPriority.ASAP) 216 return "asap"; 217 if (code == RequestPriority.STAT) 218 return "stat"; 219 return "?"; 220 } 221 222 public String toSystem(RequestPriority code) { 223 return code.getSystem(); 224 } 225 } 226 227 public enum ActionConditionKind { 228 /** 229 * The condition describes whether or not a given action is applicable. 230 */ 231 APPLICABILITY, 232 /** 233 * The condition is a starting condition for the action. 234 */ 235 START, 236 /** 237 * The condition is a stop, or exit condition for the action. 238 */ 239 STOP, 240 /** 241 * added to help the parsers with the generic types 242 */ 243 NULL; 244 245 public static ActionConditionKind fromCode(String codeString) throws FHIRException { 246 if (codeString == null || "".equals(codeString)) 247 return null; 248 if ("applicability".equals(codeString)) 249 return APPLICABILITY; 250 if ("start".equals(codeString)) 251 return START; 252 if ("stop".equals(codeString)) 253 return STOP; 254 if (Configuration.isAcceptInvalidEnums()) 255 return null; 256 else 257 throw new FHIRException("Unknown ActionConditionKind code '" + codeString + "'"); 258 } 259 260 public String toCode() { 261 switch (this) { 262 case APPLICABILITY: 263 return "applicability"; 264 case START: 265 return "start"; 266 case STOP: 267 return "stop"; 268 case NULL: 269 return null; 270 default: 271 return "?"; 272 } 273 } 274 275 public String getSystem() { 276 switch (this) { 277 case APPLICABILITY: 278 return "http://hl7.org/fhir/action-condition-kind"; 279 case START: 280 return "http://hl7.org/fhir/action-condition-kind"; 281 case STOP: 282 return "http://hl7.org/fhir/action-condition-kind"; 283 case NULL: 284 return null; 285 default: 286 return "?"; 287 } 288 } 289 290 public String getDefinition() { 291 switch (this) { 292 case APPLICABILITY: 293 return "The condition describes whether or not a given action is applicable."; 294 case START: 295 return "The condition is a starting condition for the action."; 296 case STOP: 297 return "The condition is a stop, or exit condition for the action."; 298 case NULL: 299 return null; 300 default: 301 return "?"; 302 } 303 } 304 305 public String getDisplay() { 306 switch (this) { 307 case APPLICABILITY: 308 return "Applicability"; 309 case START: 310 return "Start"; 311 case STOP: 312 return "Stop"; 313 case NULL: 314 return null; 315 default: 316 return "?"; 317 } 318 } 319 } 320 321 public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> { 322 public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException { 323 if (codeString == null || "".equals(codeString)) 324 if (codeString == null || "".equals(codeString)) 325 return null; 326 if ("applicability".equals(codeString)) 327 return ActionConditionKind.APPLICABILITY; 328 if ("start".equals(codeString)) 329 return ActionConditionKind.START; 330 if ("stop".equals(codeString)) 331 return ActionConditionKind.STOP; 332 throw new IllegalArgumentException("Unknown ActionConditionKind code '" + codeString + "'"); 333 } 334 335 public Enumeration<ActionConditionKind> fromType(PrimitiveType<?> code) throws FHIRException { 336 if (code == null) 337 return null; 338 if (code.isEmpty()) 339 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 340 String codeString = code.asStringValue(); 341 if (codeString == null || "".equals(codeString)) 342 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 343 if ("applicability".equals(codeString)) 344 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY, code); 345 if ("start".equals(codeString)) 346 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START, code); 347 if ("stop".equals(codeString)) 348 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP, code); 349 throw new FHIRException("Unknown ActionConditionKind code '" + codeString + "'"); 350 } 351 352 public String toCode(ActionConditionKind code) { 353 if (code == ActionConditionKind.NULL) 354 return null; 355 if (code == ActionConditionKind.APPLICABILITY) 356 return "applicability"; 357 if (code == ActionConditionKind.START) 358 return "start"; 359 if (code == ActionConditionKind.STOP) 360 return "stop"; 361 return "?"; 362 } 363 364 public String toSystem(ActionConditionKind code) { 365 return code.getSystem(); 366 } 367 } 368 369 public enum ActionRelationshipType { 370 /** 371 * The action must be performed before the start of the related action. 372 */ 373 BEFORESTART, 374 /** 375 * The action must be performed before the related action. 376 */ 377 BEFORE, 378 /** 379 * The action must be performed before the end of the related action. 380 */ 381 BEFOREEND, 382 /** 383 * The action must be performed concurrent with the start of the related action. 384 */ 385 CONCURRENTWITHSTART, 386 /** 387 * The action must be performed concurrent with the related action. 388 */ 389 CONCURRENT, 390 /** 391 * The action must be performed concurrent with the end of the related action. 392 */ 393 CONCURRENTWITHEND, 394 /** 395 * The action must be performed after the start of the related action. 396 */ 397 AFTERSTART, 398 /** 399 * The action must be performed after the related action. 400 */ 401 AFTER, 402 /** 403 * The action must be performed after the end of the related action. 404 */ 405 AFTEREND, 406 /** 407 * added to help the parsers with the generic types 408 */ 409 NULL; 410 411 public static ActionRelationshipType fromCode(String codeString) throws FHIRException { 412 if (codeString == null || "".equals(codeString)) 413 return null; 414 if ("before-start".equals(codeString)) 415 return BEFORESTART; 416 if ("before".equals(codeString)) 417 return BEFORE; 418 if ("before-end".equals(codeString)) 419 return BEFOREEND; 420 if ("concurrent-with-start".equals(codeString)) 421 return CONCURRENTWITHSTART; 422 if ("concurrent".equals(codeString)) 423 return CONCURRENT; 424 if ("concurrent-with-end".equals(codeString)) 425 return CONCURRENTWITHEND; 426 if ("after-start".equals(codeString)) 427 return AFTERSTART; 428 if ("after".equals(codeString)) 429 return AFTER; 430 if ("after-end".equals(codeString)) 431 return AFTEREND; 432 if (Configuration.isAcceptInvalidEnums()) 433 return null; 434 else 435 throw new FHIRException("Unknown ActionRelationshipType code '" + codeString + "'"); 436 } 437 438 public String toCode() { 439 switch (this) { 440 case BEFORESTART: 441 return "before-start"; 442 case BEFORE: 443 return "before"; 444 case BEFOREEND: 445 return "before-end"; 446 case CONCURRENTWITHSTART: 447 return "concurrent-with-start"; 448 case CONCURRENT: 449 return "concurrent"; 450 case CONCURRENTWITHEND: 451 return "concurrent-with-end"; 452 case AFTERSTART: 453 return "after-start"; 454 case AFTER: 455 return "after"; 456 case AFTEREND: 457 return "after-end"; 458 case NULL: 459 return null; 460 default: 461 return "?"; 462 } 463 } 464 465 public String getSystem() { 466 switch (this) { 467 case BEFORESTART: 468 return "http://hl7.org/fhir/action-relationship-type"; 469 case BEFORE: 470 return "http://hl7.org/fhir/action-relationship-type"; 471 case BEFOREEND: 472 return "http://hl7.org/fhir/action-relationship-type"; 473 case CONCURRENTWITHSTART: 474 return "http://hl7.org/fhir/action-relationship-type"; 475 case CONCURRENT: 476 return "http://hl7.org/fhir/action-relationship-type"; 477 case CONCURRENTWITHEND: 478 return "http://hl7.org/fhir/action-relationship-type"; 479 case AFTERSTART: 480 return "http://hl7.org/fhir/action-relationship-type"; 481 case AFTER: 482 return "http://hl7.org/fhir/action-relationship-type"; 483 case AFTEREND: 484 return "http://hl7.org/fhir/action-relationship-type"; 485 case NULL: 486 return null; 487 default: 488 return "?"; 489 } 490 } 491 492 public String getDefinition() { 493 switch (this) { 494 case BEFORESTART: 495 return "The action must be performed before the start of the related action."; 496 case BEFORE: 497 return "The action must be performed before the related action."; 498 case BEFOREEND: 499 return "The action must be performed before the end of the related action."; 500 case CONCURRENTWITHSTART: 501 return "The action must be performed concurrent with the start of the related action."; 502 case CONCURRENT: 503 return "The action must be performed concurrent with the related action."; 504 case CONCURRENTWITHEND: 505 return "The action must be performed concurrent with the end of the related action."; 506 case AFTERSTART: 507 return "The action must be performed after the start of the related action."; 508 case AFTER: 509 return "The action must be performed after the related action."; 510 case AFTEREND: 511 return "The action must be performed after the end of the related action."; 512 case NULL: 513 return null; 514 default: 515 return "?"; 516 } 517 } 518 519 public String getDisplay() { 520 switch (this) { 521 case BEFORESTART: 522 return "Before Start"; 523 case BEFORE: 524 return "Before"; 525 case BEFOREEND: 526 return "Before End"; 527 case CONCURRENTWITHSTART: 528 return "Concurrent With Start"; 529 case CONCURRENT: 530 return "Concurrent"; 531 case CONCURRENTWITHEND: 532 return "Concurrent With End"; 533 case AFTERSTART: 534 return "After Start"; 535 case AFTER: 536 return "After"; 537 case AFTEREND: 538 return "After End"; 539 case NULL: 540 return null; 541 default: 542 return "?"; 543 } 544 } 545 } 546 547 public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> { 548 public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException { 549 if (codeString == null || "".equals(codeString)) 550 if (codeString == null || "".equals(codeString)) 551 return null; 552 if ("before-start".equals(codeString)) 553 return ActionRelationshipType.BEFORESTART; 554 if ("before".equals(codeString)) 555 return ActionRelationshipType.BEFORE; 556 if ("before-end".equals(codeString)) 557 return ActionRelationshipType.BEFOREEND; 558 if ("concurrent-with-start".equals(codeString)) 559 return ActionRelationshipType.CONCURRENTWITHSTART; 560 if ("concurrent".equals(codeString)) 561 return ActionRelationshipType.CONCURRENT; 562 if ("concurrent-with-end".equals(codeString)) 563 return ActionRelationshipType.CONCURRENTWITHEND; 564 if ("after-start".equals(codeString)) 565 return ActionRelationshipType.AFTERSTART; 566 if ("after".equals(codeString)) 567 return ActionRelationshipType.AFTER; 568 if ("after-end".equals(codeString)) 569 return ActionRelationshipType.AFTEREND; 570 throw new IllegalArgumentException("Unknown ActionRelationshipType code '" + codeString + "'"); 571 } 572 573 public Enumeration<ActionRelationshipType> fromType(PrimitiveType<?> code) throws FHIRException { 574 if (code == null) 575 return null; 576 if (code.isEmpty()) 577 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 578 String codeString = code.asStringValue(); 579 if (codeString == null || "".equals(codeString)) 580 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 581 if ("before-start".equals(codeString)) 582 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART, code); 583 if ("before".equals(codeString)) 584 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE, code); 585 if ("before-end".equals(codeString)) 586 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND, code); 587 if ("concurrent-with-start".equals(codeString)) 588 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART, code); 589 if ("concurrent".equals(codeString)) 590 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT, code); 591 if ("concurrent-with-end".equals(codeString)) 592 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND, code); 593 if ("after-start".equals(codeString)) 594 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART, code); 595 if ("after".equals(codeString)) 596 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER, code); 597 if ("after-end".equals(codeString)) 598 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND, code); 599 throw new FHIRException("Unknown ActionRelationshipType code '" + codeString + "'"); 600 } 601 602 public String toCode(ActionRelationshipType code) { 603 if (code == ActionRelationshipType.NULL) 604 return null; 605 if (code == ActionRelationshipType.BEFORESTART) 606 return "before-start"; 607 if (code == ActionRelationshipType.BEFORE) 608 return "before"; 609 if (code == ActionRelationshipType.BEFOREEND) 610 return "before-end"; 611 if (code == ActionRelationshipType.CONCURRENTWITHSTART) 612 return "concurrent-with-start"; 613 if (code == ActionRelationshipType.CONCURRENT) 614 return "concurrent"; 615 if (code == ActionRelationshipType.CONCURRENTWITHEND) 616 return "concurrent-with-end"; 617 if (code == ActionRelationshipType.AFTERSTART) 618 return "after-start"; 619 if (code == ActionRelationshipType.AFTER) 620 return "after"; 621 if (code == ActionRelationshipType.AFTEREND) 622 return "after-end"; 623 return "?"; 624 } 625 626 public String toSystem(ActionRelationshipType code) { 627 return code.getSystem(); 628 } 629 } 630 631 public enum ActionParticipantType { 632 /** 633 * The participant is the patient under evaluation. 634 */ 635 PATIENT, 636 /** 637 * The participant is a practitioner involved in the patient's care. 638 */ 639 PRACTITIONER, 640 /** 641 * The participant is a person related to the patient. 642 */ 643 RELATEDPERSON, 644 /** 645 * The participant is a system or device used in the care of the patient. 646 */ 647 DEVICE, 648 /** 649 * added to help the parsers with the generic types 650 */ 651 NULL; 652 653 public static ActionParticipantType fromCode(String codeString) throws FHIRException { 654 if (codeString == null || "".equals(codeString)) 655 return null; 656 if ("patient".equals(codeString)) 657 return PATIENT; 658 if ("practitioner".equals(codeString)) 659 return PRACTITIONER; 660 if ("related-person".equals(codeString)) 661 return RELATEDPERSON; 662 if ("device".equals(codeString)) 663 return DEVICE; 664 if (Configuration.isAcceptInvalidEnums()) 665 return null; 666 else 667 throw new FHIRException("Unknown ActionParticipantType code '" + codeString + "'"); 668 } 669 670 public String toCode() { 671 switch (this) { 672 case PATIENT: 673 return "patient"; 674 case PRACTITIONER: 675 return "practitioner"; 676 case RELATEDPERSON: 677 return "related-person"; 678 case DEVICE: 679 return "device"; 680 case NULL: 681 return null; 682 default: 683 return "?"; 684 } 685 } 686 687 public String getSystem() { 688 switch (this) { 689 case PATIENT: 690 return "http://hl7.org/fhir/action-participant-type"; 691 case PRACTITIONER: 692 return "http://hl7.org/fhir/action-participant-type"; 693 case RELATEDPERSON: 694 return "http://hl7.org/fhir/action-participant-type"; 695 case DEVICE: 696 return "http://hl7.org/fhir/action-participant-type"; 697 case NULL: 698 return null; 699 default: 700 return "?"; 701 } 702 } 703 704 public String getDefinition() { 705 switch (this) { 706 case PATIENT: 707 return "The participant is the patient under evaluation."; 708 case PRACTITIONER: 709 return "The participant is a practitioner involved in the patient's care."; 710 case RELATEDPERSON: 711 return "The participant is a person related to the patient."; 712 case DEVICE: 713 return "The participant is a system or device used in the care of the patient."; 714 case NULL: 715 return null; 716 default: 717 return "?"; 718 } 719 } 720 721 public String getDisplay() { 722 switch (this) { 723 case PATIENT: 724 return "Patient"; 725 case PRACTITIONER: 726 return "Practitioner"; 727 case RELATEDPERSON: 728 return "Related Person"; 729 case DEVICE: 730 return "Device"; 731 case NULL: 732 return null; 733 default: 734 return "?"; 735 } 736 } 737 } 738 739 public static class ActionParticipantTypeEnumFactory implements EnumFactory<ActionParticipantType> { 740 public ActionParticipantType fromCode(String codeString) throws IllegalArgumentException { 741 if (codeString == null || "".equals(codeString)) 742 if (codeString == null || "".equals(codeString)) 743 return null; 744 if ("patient".equals(codeString)) 745 return ActionParticipantType.PATIENT; 746 if ("practitioner".equals(codeString)) 747 return ActionParticipantType.PRACTITIONER; 748 if ("related-person".equals(codeString)) 749 return ActionParticipantType.RELATEDPERSON; 750 if ("device".equals(codeString)) 751 return ActionParticipantType.DEVICE; 752 throw new IllegalArgumentException("Unknown ActionParticipantType code '" + codeString + "'"); 753 } 754 755 public Enumeration<ActionParticipantType> fromType(PrimitiveType<?> code) throws FHIRException { 756 if (code == null) 757 return null; 758 if (code.isEmpty()) 759 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 760 String codeString = code.asStringValue(); 761 if (codeString == null || "".equals(codeString)) 762 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 763 if ("patient".equals(codeString)) 764 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PATIENT, code); 765 if ("practitioner".equals(codeString)) 766 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONER, code); 767 if ("related-person".equals(codeString)) 768 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.RELATEDPERSON, code); 769 if ("device".equals(codeString)) 770 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.DEVICE, code); 771 throw new FHIRException("Unknown ActionParticipantType code '" + codeString + "'"); 772 } 773 774 public String toCode(ActionParticipantType code) { 775 if (code == ActionParticipantType.NULL) 776 return null; 777 if (code == ActionParticipantType.PATIENT) 778 return "patient"; 779 if (code == ActionParticipantType.PRACTITIONER) 780 return "practitioner"; 781 if (code == ActionParticipantType.RELATEDPERSON) 782 return "related-person"; 783 if (code == ActionParticipantType.DEVICE) 784 return "device"; 785 return "?"; 786 } 787 788 public String toSystem(ActionParticipantType code) { 789 return code.getSystem(); 790 } 791 } 792 793 public enum ActionGroupingBehavior { 794 /** 795 * Any group marked with this behavior should be displayed as a visual group to 796 * the end user. 797 */ 798 VISUALGROUP, 799 /** 800 * A group with this behavior logically groups its sub-elements, and may be 801 * shown as a visual group to the end user, but it is not required to do so. 802 */ 803 LOGICALGROUP, 804 /** 805 * A group of related alternative actions is a sentence group if the target 806 * referenced by the action is the same in all the actions and each action 807 * simply constitutes a different variation on how to specify the details for 808 * the target. For example, two actions that could be in a SentenceGroup are 809 * "aspirin, 500 mg, 2 times per day" and "aspirin, 300 mg, 3 times per day". In 810 * both cases, aspirin is the target referenced by the action, and the two 811 * actions represent different options for how aspirin might be ordered for the 812 * patient. Note that a SentenceGroup would almost always have an associated 813 * selection behavior of "AtMostOne", unless it's a required action, in which 814 * case, it would be "ExactlyOne". 815 */ 816 SENTENCEGROUP, 817 /** 818 * added to help the parsers with the generic types 819 */ 820 NULL; 821 822 public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException { 823 if (codeString == null || "".equals(codeString)) 824 return null; 825 if ("visual-group".equals(codeString)) 826 return VISUALGROUP; 827 if ("logical-group".equals(codeString)) 828 return LOGICALGROUP; 829 if ("sentence-group".equals(codeString)) 830 return SENTENCEGROUP; 831 if (Configuration.isAcceptInvalidEnums()) 832 return null; 833 else 834 throw new FHIRException("Unknown ActionGroupingBehavior code '" + codeString + "'"); 835 } 836 837 public String toCode() { 838 switch (this) { 839 case VISUALGROUP: 840 return "visual-group"; 841 case LOGICALGROUP: 842 return "logical-group"; 843 case SENTENCEGROUP: 844 return "sentence-group"; 845 case NULL: 846 return null; 847 default: 848 return "?"; 849 } 850 } 851 852 public String getSystem() { 853 switch (this) { 854 case VISUALGROUP: 855 return "http://hl7.org/fhir/action-grouping-behavior"; 856 case LOGICALGROUP: 857 return "http://hl7.org/fhir/action-grouping-behavior"; 858 case SENTENCEGROUP: 859 return "http://hl7.org/fhir/action-grouping-behavior"; 860 case NULL: 861 return null; 862 default: 863 return "?"; 864 } 865 } 866 867 public String getDefinition() { 868 switch (this) { 869 case VISUALGROUP: 870 return "Any group marked with this behavior should be displayed as a visual group to the end user."; 871 case LOGICALGROUP: 872 return "A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so."; 873 case SENTENCEGROUP: 874 return "A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are \"aspirin, 500 mg, 2 times per day\" and \"aspirin, 300 mg, 3 times per day\". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of \"AtMostOne\", unless it's a required action, in which case, it would be \"ExactlyOne\"."; 875 case NULL: 876 return null; 877 default: 878 return "?"; 879 } 880 } 881 882 public String getDisplay() { 883 switch (this) { 884 case VISUALGROUP: 885 return "Visual Group"; 886 case LOGICALGROUP: 887 return "Logical Group"; 888 case SENTENCEGROUP: 889 return "Sentence Group"; 890 case NULL: 891 return null; 892 default: 893 return "?"; 894 } 895 } 896 } 897 898 public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> { 899 public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException { 900 if (codeString == null || "".equals(codeString)) 901 if (codeString == null || "".equals(codeString)) 902 return null; 903 if ("visual-group".equals(codeString)) 904 return ActionGroupingBehavior.VISUALGROUP; 905 if ("logical-group".equals(codeString)) 906 return ActionGroupingBehavior.LOGICALGROUP; 907 if ("sentence-group".equals(codeString)) 908 return ActionGroupingBehavior.SENTENCEGROUP; 909 throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '" + codeString + "'"); 910 } 911 912 public Enumeration<ActionGroupingBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 913 if (code == null) 914 return null; 915 if (code.isEmpty()) 916 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 917 String codeString = code.asStringValue(); 918 if (codeString == null || "".equals(codeString)) 919 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 920 if ("visual-group".equals(codeString)) 921 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP, code); 922 if ("logical-group".equals(codeString)) 923 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP, code); 924 if ("sentence-group".equals(codeString)) 925 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP, code); 926 throw new FHIRException("Unknown ActionGroupingBehavior code '" + codeString + "'"); 927 } 928 929 public String toCode(ActionGroupingBehavior code) { 930 if (code == ActionGroupingBehavior.NULL) 931 return null; 932 if (code == ActionGroupingBehavior.VISUALGROUP) 933 return "visual-group"; 934 if (code == ActionGroupingBehavior.LOGICALGROUP) 935 return "logical-group"; 936 if (code == ActionGroupingBehavior.SENTENCEGROUP) 937 return "sentence-group"; 938 return "?"; 939 } 940 941 public String toSystem(ActionGroupingBehavior code) { 942 return code.getSystem(); 943 } 944 } 945 946 public enum ActionSelectionBehavior { 947 /** 948 * Any number of the actions in the group may be chosen, from zero to all. 949 */ 950 ANY, 951 /** 952 * All the actions in the group must be selected as a single unit. 953 */ 954 ALL, 955 /** 956 * All the actions in the group are meant to be chosen as a single unit: either 957 * all must be selected by the end user, or none may be selected. 958 */ 959 ALLORNONE, 960 /** 961 * The end user must choose one and only one of the selectable actions in the 962 * group. The user SHALL NOT choose none of the actions in the group. 963 */ 964 EXACTLYONE, 965 /** 966 * The end user may choose zero or at most one of the actions in the group. 967 */ 968 ATMOSTONE, 969 /** 970 * The end user must choose a minimum of one, and as many additional as desired. 971 */ 972 ONEORMORE, 973 /** 974 * added to help the parsers with the generic types 975 */ 976 NULL; 977 978 public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException { 979 if (codeString == null || "".equals(codeString)) 980 return null; 981 if ("any".equals(codeString)) 982 return ANY; 983 if ("all".equals(codeString)) 984 return ALL; 985 if ("all-or-none".equals(codeString)) 986 return ALLORNONE; 987 if ("exactly-one".equals(codeString)) 988 return EXACTLYONE; 989 if ("at-most-one".equals(codeString)) 990 return ATMOSTONE; 991 if ("one-or-more".equals(codeString)) 992 return ONEORMORE; 993 if (Configuration.isAcceptInvalidEnums()) 994 return null; 995 else 996 throw new FHIRException("Unknown ActionSelectionBehavior code '" + codeString + "'"); 997 } 998 999 public String toCode() { 1000 switch (this) { 1001 case ANY: 1002 return "any"; 1003 case ALL: 1004 return "all"; 1005 case ALLORNONE: 1006 return "all-or-none"; 1007 case EXACTLYONE: 1008 return "exactly-one"; 1009 case ATMOSTONE: 1010 return "at-most-one"; 1011 case ONEORMORE: 1012 return "one-or-more"; 1013 case NULL: 1014 return null; 1015 default: 1016 return "?"; 1017 } 1018 } 1019 1020 public String getSystem() { 1021 switch (this) { 1022 case ANY: 1023 return "http://hl7.org/fhir/action-selection-behavior"; 1024 case ALL: 1025 return "http://hl7.org/fhir/action-selection-behavior"; 1026 case ALLORNONE: 1027 return "http://hl7.org/fhir/action-selection-behavior"; 1028 case EXACTLYONE: 1029 return "http://hl7.org/fhir/action-selection-behavior"; 1030 case ATMOSTONE: 1031 return "http://hl7.org/fhir/action-selection-behavior"; 1032 case ONEORMORE: 1033 return "http://hl7.org/fhir/action-selection-behavior"; 1034 case NULL: 1035 return null; 1036 default: 1037 return "?"; 1038 } 1039 } 1040 1041 public String getDefinition() { 1042 switch (this) { 1043 case ANY: 1044 return "Any number of the actions in the group may be chosen, from zero to all."; 1045 case ALL: 1046 return "All the actions in the group must be selected as a single unit."; 1047 case ALLORNONE: 1048 return "All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected."; 1049 case EXACTLYONE: 1050 return "The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group."; 1051 case ATMOSTONE: 1052 return "The end user may choose zero or at most one of the actions in the group."; 1053 case ONEORMORE: 1054 return "The end user must choose a minimum of one, and as many additional as desired."; 1055 case NULL: 1056 return null; 1057 default: 1058 return "?"; 1059 } 1060 } 1061 1062 public String getDisplay() { 1063 switch (this) { 1064 case ANY: 1065 return "Any"; 1066 case ALL: 1067 return "All"; 1068 case ALLORNONE: 1069 return "All Or None"; 1070 case EXACTLYONE: 1071 return "Exactly One"; 1072 case ATMOSTONE: 1073 return "At Most One"; 1074 case ONEORMORE: 1075 return "One Or More"; 1076 case NULL: 1077 return null; 1078 default: 1079 return "?"; 1080 } 1081 } 1082 } 1083 1084 public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> { 1085 public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException { 1086 if (codeString == null || "".equals(codeString)) 1087 if (codeString == null || "".equals(codeString)) 1088 return null; 1089 if ("any".equals(codeString)) 1090 return ActionSelectionBehavior.ANY; 1091 if ("all".equals(codeString)) 1092 return ActionSelectionBehavior.ALL; 1093 if ("all-or-none".equals(codeString)) 1094 return ActionSelectionBehavior.ALLORNONE; 1095 if ("exactly-one".equals(codeString)) 1096 return ActionSelectionBehavior.EXACTLYONE; 1097 if ("at-most-one".equals(codeString)) 1098 return ActionSelectionBehavior.ATMOSTONE; 1099 if ("one-or-more".equals(codeString)) 1100 return ActionSelectionBehavior.ONEORMORE; 1101 throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '" + codeString + "'"); 1102 } 1103 1104 public Enumeration<ActionSelectionBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1105 if (code == null) 1106 return null; 1107 if (code.isEmpty()) 1108 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1109 String codeString = code.asStringValue(); 1110 if (codeString == null || "".equals(codeString)) 1111 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1112 if ("any".equals(codeString)) 1113 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY, code); 1114 if ("all".equals(codeString)) 1115 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL, code); 1116 if ("all-or-none".equals(codeString)) 1117 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE, code); 1118 if ("exactly-one".equals(codeString)) 1119 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE, code); 1120 if ("at-most-one".equals(codeString)) 1121 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE, code); 1122 if ("one-or-more".equals(codeString)) 1123 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE, code); 1124 throw new FHIRException("Unknown ActionSelectionBehavior code '" + codeString + "'"); 1125 } 1126 1127 public String toCode(ActionSelectionBehavior code) { 1128 if (code == ActionSelectionBehavior.NULL) 1129 return null; 1130 if (code == ActionSelectionBehavior.ANY) 1131 return "any"; 1132 if (code == ActionSelectionBehavior.ALL) 1133 return "all"; 1134 if (code == ActionSelectionBehavior.ALLORNONE) 1135 return "all-or-none"; 1136 if (code == ActionSelectionBehavior.EXACTLYONE) 1137 return "exactly-one"; 1138 if (code == ActionSelectionBehavior.ATMOSTONE) 1139 return "at-most-one"; 1140 if (code == ActionSelectionBehavior.ONEORMORE) 1141 return "one-or-more"; 1142 return "?"; 1143 } 1144 1145 public String toSystem(ActionSelectionBehavior code) { 1146 return code.getSystem(); 1147 } 1148 } 1149 1150 public enum ActionRequiredBehavior { 1151 /** 1152 * An action with this behavior must be included in the actions processed by the 1153 * end user; the end user SHALL NOT choose not to include this action. 1154 */ 1155 MUST, 1156 /** 1157 * An action with this behavior may be included in the set of actions processed 1158 * by the end user. 1159 */ 1160 COULD, 1161 /** 1162 * An action with this behavior must be included in the set of actions processed 1163 * by the end user, unless the end user provides documentation as to why the 1164 * action was not included. 1165 */ 1166 MUSTUNLESSDOCUMENTED, 1167 /** 1168 * added to help the parsers with the generic types 1169 */ 1170 NULL; 1171 1172 public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException { 1173 if (codeString == null || "".equals(codeString)) 1174 return null; 1175 if ("must".equals(codeString)) 1176 return MUST; 1177 if ("could".equals(codeString)) 1178 return COULD; 1179 if ("must-unless-documented".equals(codeString)) 1180 return MUSTUNLESSDOCUMENTED; 1181 if (Configuration.isAcceptInvalidEnums()) 1182 return null; 1183 else 1184 throw new FHIRException("Unknown ActionRequiredBehavior code '" + codeString + "'"); 1185 } 1186 1187 public String toCode() { 1188 switch (this) { 1189 case MUST: 1190 return "must"; 1191 case COULD: 1192 return "could"; 1193 case MUSTUNLESSDOCUMENTED: 1194 return "must-unless-documented"; 1195 case NULL: 1196 return null; 1197 default: 1198 return "?"; 1199 } 1200 } 1201 1202 public String getSystem() { 1203 switch (this) { 1204 case MUST: 1205 return "http://hl7.org/fhir/action-required-behavior"; 1206 case COULD: 1207 return "http://hl7.org/fhir/action-required-behavior"; 1208 case MUSTUNLESSDOCUMENTED: 1209 return "http://hl7.org/fhir/action-required-behavior"; 1210 case NULL: 1211 return null; 1212 default: 1213 return "?"; 1214 } 1215 } 1216 1217 public String getDefinition() { 1218 switch (this) { 1219 case MUST: 1220 return "An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action."; 1221 case COULD: 1222 return "An action with this behavior may be included in the set of actions processed by the end user."; 1223 case MUSTUNLESSDOCUMENTED: 1224 return "An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included."; 1225 case NULL: 1226 return null; 1227 default: 1228 return "?"; 1229 } 1230 } 1231 1232 public String getDisplay() { 1233 switch (this) { 1234 case MUST: 1235 return "Must"; 1236 case COULD: 1237 return "Could"; 1238 case MUSTUNLESSDOCUMENTED: 1239 return "Must Unless Documented"; 1240 case NULL: 1241 return null; 1242 default: 1243 return "?"; 1244 } 1245 } 1246 } 1247 1248 public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> { 1249 public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException { 1250 if (codeString == null || "".equals(codeString)) 1251 if (codeString == null || "".equals(codeString)) 1252 return null; 1253 if ("must".equals(codeString)) 1254 return ActionRequiredBehavior.MUST; 1255 if ("could".equals(codeString)) 1256 return ActionRequiredBehavior.COULD; 1257 if ("must-unless-documented".equals(codeString)) 1258 return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED; 1259 throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '" + codeString + "'"); 1260 } 1261 1262 public Enumeration<ActionRequiredBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1263 if (code == null) 1264 return null; 1265 if (code.isEmpty()) 1266 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1267 String codeString = code.asStringValue(); 1268 if (codeString == null || "".equals(codeString)) 1269 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1270 if ("must".equals(codeString)) 1271 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST, code); 1272 if ("could".equals(codeString)) 1273 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD, code); 1274 if ("must-unless-documented".equals(codeString)) 1275 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED, code); 1276 throw new FHIRException("Unknown ActionRequiredBehavior code '" + codeString + "'"); 1277 } 1278 1279 public String toCode(ActionRequiredBehavior code) { 1280 if (code == ActionRequiredBehavior.NULL) 1281 return null; 1282 if (code == ActionRequiredBehavior.MUST) 1283 return "must"; 1284 if (code == ActionRequiredBehavior.COULD) 1285 return "could"; 1286 if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED) 1287 return "must-unless-documented"; 1288 return "?"; 1289 } 1290 1291 public String toSystem(ActionRequiredBehavior code) { 1292 return code.getSystem(); 1293 } 1294 } 1295 1296 public enum ActionPrecheckBehavior { 1297 /** 1298 * An action with this behavior is one of the most frequent action that is, or 1299 * should be, included by an end user, for the particular context in which the 1300 * action occurs. The system displaying the action to the end user should 1301 * consider "pre-checking" such an action as a convenience for the user. 1302 */ 1303 YES, 1304 /** 1305 * An action with this behavior is one of the less frequent actions included by 1306 * the end user, for the particular context in which the action occurs. The 1307 * system displaying the actions to the end user would typically not "pre-check" 1308 * such an action. 1309 */ 1310 NO, 1311 /** 1312 * added to help the parsers with the generic types 1313 */ 1314 NULL; 1315 1316 public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException { 1317 if (codeString == null || "".equals(codeString)) 1318 return null; 1319 if ("yes".equals(codeString)) 1320 return YES; 1321 if ("no".equals(codeString)) 1322 return NO; 1323 if (Configuration.isAcceptInvalidEnums()) 1324 return null; 1325 else 1326 throw new FHIRException("Unknown ActionPrecheckBehavior code '" + codeString + "'"); 1327 } 1328 1329 public String toCode() { 1330 switch (this) { 1331 case YES: 1332 return "yes"; 1333 case NO: 1334 return "no"; 1335 case NULL: 1336 return null; 1337 default: 1338 return "?"; 1339 } 1340 } 1341 1342 public String getSystem() { 1343 switch (this) { 1344 case YES: 1345 return "http://hl7.org/fhir/action-precheck-behavior"; 1346 case NO: 1347 return "http://hl7.org/fhir/action-precheck-behavior"; 1348 case NULL: 1349 return null; 1350 default: 1351 return "?"; 1352 } 1353 } 1354 1355 public String getDefinition() { 1356 switch (this) { 1357 case YES: 1358 return "An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider \"pre-checking\" such an action as a convenience for the user."; 1359 case NO: 1360 return "An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not \"pre-check\" such an action."; 1361 case NULL: 1362 return null; 1363 default: 1364 return "?"; 1365 } 1366 } 1367 1368 public String getDisplay() { 1369 switch (this) { 1370 case YES: 1371 return "Yes"; 1372 case NO: 1373 return "No"; 1374 case NULL: 1375 return null; 1376 default: 1377 return "?"; 1378 } 1379 } 1380 } 1381 1382 public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> { 1383 public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException { 1384 if (codeString == null || "".equals(codeString)) 1385 if (codeString == null || "".equals(codeString)) 1386 return null; 1387 if ("yes".equals(codeString)) 1388 return ActionPrecheckBehavior.YES; 1389 if ("no".equals(codeString)) 1390 return ActionPrecheckBehavior.NO; 1391 throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '" + codeString + "'"); 1392 } 1393 1394 public Enumeration<ActionPrecheckBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1395 if (code == null) 1396 return null; 1397 if (code.isEmpty()) 1398 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 1399 String codeString = code.asStringValue(); 1400 if (codeString == null || "".equals(codeString)) 1401 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 1402 if ("yes".equals(codeString)) 1403 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES, code); 1404 if ("no".equals(codeString)) 1405 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO, code); 1406 throw new FHIRException("Unknown ActionPrecheckBehavior code '" + codeString + "'"); 1407 } 1408 1409 public String toCode(ActionPrecheckBehavior code) { 1410 if (code == ActionPrecheckBehavior.NULL) 1411 return null; 1412 if (code == ActionPrecheckBehavior.YES) 1413 return "yes"; 1414 if (code == ActionPrecheckBehavior.NO) 1415 return "no"; 1416 return "?"; 1417 } 1418 1419 public String toSystem(ActionPrecheckBehavior code) { 1420 return code.getSystem(); 1421 } 1422 } 1423 1424 public enum ActionCardinalityBehavior { 1425 /** 1426 * The action may only be selected one time. 1427 */ 1428 SINGLE, 1429 /** 1430 * The action may be selected multiple times. 1431 */ 1432 MULTIPLE, 1433 /** 1434 * added to help the parsers with the generic types 1435 */ 1436 NULL; 1437 1438 public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException { 1439 if (codeString == null || "".equals(codeString)) 1440 return null; 1441 if ("single".equals(codeString)) 1442 return SINGLE; 1443 if ("multiple".equals(codeString)) 1444 return MULTIPLE; 1445 if (Configuration.isAcceptInvalidEnums()) 1446 return null; 1447 else 1448 throw new FHIRException("Unknown ActionCardinalityBehavior code '" + codeString + "'"); 1449 } 1450 1451 public String toCode() { 1452 switch (this) { 1453 case SINGLE: 1454 return "single"; 1455 case MULTIPLE: 1456 return "multiple"; 1457 case NULL: 1458 return null; 1459 default: 1460 return "?"; 1461 } 1462 } 1463 1464 public String getSystem() { 1465 switch (this) { 1466 case SINGLE: 1467 return "http://hl7.org/fhir/action-cardinality-behavior"; 1468 case MULTIPLE: 1469 return "http://hl7.org/fhir/action-cardinality-behavior"; 1470 case NULL: 1471 return null; 1472 default: 1473 return "?"; 1474 } 1475 } 1476 1477 public String getDefinition() { 1478 switch (this) { 1479 case SINGLE: 1480 return "The action may only be selected one time."; 1481 case MULTIPLE: 1482 return "The action may be selected multiple times."; 1483 case NULL: 1484 return null; 1485 default: 1486 return "?"; 1487 } 1488 } 1489 1490 public String getDisplay() { 1491 switch (this) { 1492 case SINGLE: 1493 return "Single"; 1494 case MULTIPLE: 1495 return "Multiple"; 1496 case NULL: 1497 return null; 1498 default: 1499 return "?"; 1500 } 1501 } 1502 } 1503 1504 public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> { 1505 public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException { 1506 if (codeString == null || "".equals(codeString)) 1507 if (codeString == null || "".equals(codeString)) 1508 return null; 1509 if ("single".equals(codeString)) 1510 return ActionCardinalityBehavior.SINGLE; 1511 if ("multiple".equals(codeString)) 1512 return ActionCardinalityBehavior.MULTIPLE; 1513 throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '" + codeString + "'"); 1514 } 1515 1516 public Enumeration<ActionCardinalityBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1517 if (code == null) 1518 return null; 1519 if (code.isEmpty()) 1520 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 1521 String codeString = code.asStringValue(); 1522 if (codeString == null || "".equals(codeString)) 1523 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 1524 if ("single".equals(codeString)) 1525 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE, code); 1526 if ("multiple".equals(codeString)) 1527 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE, code); 1528 throw new FHIRException("Unknown ActionCardinalityBehavior code '" + codeString + "'"); 1529 } 1530 1531 public String toCode(ActionCardinalityBehavior code) { 1532 if (code == ActionCardinalityBehavior.NULL) 1533 return null; 1534 if (code == ActionCardinalityBehavior.SINGLE) 1535 return "single"; 1536 if (code == ActionCardinalityBehavior.MULTIPLE) 1537 return "multiple"; 1538 return "?"; 1539 } 1540 1541 public String toSystem(ActionCardinalityBehavior code) { 1542 return code.getSystem(); 1543 } 1544 } 1545 1546 @Block() 1547 public static class PlanDefinitionGoalComponent extends BackboneElement implements IBaseBackboneElement { 1548 /** 1549 * Indicates a category the goal falls within. 1550 */ 1551 @Child(name = "category", type = { 1552 CodeableConcept.class }, order = 1, min = 0, max = 1, modifier = false, summary = false) 1553 @Description(shortDefinition = "E.g. Treatment, dietary, behavioral", formalDefinition = "Indicates a category the goal falls within.") 1554 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/goal-category") 1555 protected CodeableConcept category; 1556 1557 /** 1558 * Human-readable and/or coded description of a specific desired objective of 1559 * care, such as "control blood pressure" or "negotiate an obstacle course" or 1560 * "dance with child at wedding". 1561 */ 1562 @Child(name = "description", type = { 1563 CodeableConcept.class }, order = 2, min = 1, max = 1, modifier = false, summary = false) 1564 @Description(shortDefinition = "Code or text describing the goal", formalDefinition = "Human-readable and/or coded description of a specific desired objective of care, such as \"control blood pressure\" or \"negotiate an obstacle course\" or \"dance with child at wedding\".") 1565 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/clinical-findings") 1566 protected CodeableConcept description; 1567 1568 /** 1569 * Identifies the expected level of importance associated with 1570 * reaching/sustaining the defined goal. 1571 */ 1572 @Child(name = "priority", type = { 1573 CodeableConcept.class }, order = 3, min = 0, max = 1, modifier = false, summary = false) 1574 @Description(shortDefinition = "high-priority | medium-priority | low-priority", formalDefinition = "Identifies the expected level of importance associated with reaching/sustaining the defined goal.") 1575 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/goal-priority") 1576 protected CodeableConcept priority; 1577 1578 /** 1579 * The event after which the goal should begin being pursued. 1580 */ 1581 @Child(name = "start", type = { 1582 CodeableConcept.class }, order = 4, min = 0, max = 1, modifier = false, summary = false) 1583 @Description(shortDefinition = "When goal pursuit begins", formalDefinition = "The event after which the goal should begin being pursued.") 1584 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/goal-start-event") 1585 protected CodeableConcept start; 1586 1587 /** 1588 * Identifies problems, conditions, issues, or concerns the goal is intended to 1589 * address. 1590 */ 1591 @Child(name = "addresses", type = { 1592 CodeableConcept.class }, order = 5, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1593 @Description(shortDefinition = "What does the goal address", formalDefinition = "Identifies problems, conditions, issues, or concerns the goal is intended to address.") 1594 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/condition-code") 1595 protected List<CodeableConcept> addresses; 1596 1597 /** 1598 * Didactic or other informational resources associated with the goal that 1599 * provide further supporting information about the goal. Information resources 1600 * can include inline text commentary and links to web resources. 1601 */ 1602 @Child(name = "documentation", type = { 1603 RelatedArtifact.class }, order = 6, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1604 @Description(shortDefinition = "Supporting documentation for the goal", formalDefinition = "Didactic or other informational resources associated with the goal that provide further supporting information about the goal. Information resources can include inline text commentary and links to web resources.") 1605 protected List<RelatedArtifact> documentation; 1606 1607 /** 1608 * Indicates what should be done and within what timeframe. 1609 */ 1610 @Child(name = "target", type = {}, order = 7, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1611 @Description(shortDefinition = "Target outcome for the goal", formalDefinition = "Indicates what should be done and within what timeframe.") 1612 protected List<PlanDefinitionGoalTargetComponent> target; 1613 1614 private static final long serialVersionUID = -795308926L; 1615 1616 /** 1617 * Constructor 1618 */ 1619 public PlanDefinitionGoalComponent() { 1620 super(); 1621 } 1622 1623 /** 1624 * Constructor 1625 */ 1626 public PlanDefinitionGoalComponent(CodeableConcept description) { 1627 super(); 1628 this.description = description; 1629 } 1630 1631 /** 1632 * @return {@link #category} (Indicates a category the goal falls within.) 1633 */ 1634 public CodeableConcept getCategory() { 1635 if (this.category == null) 1636 if (Configuration.errorOnAutoCreate()) 1637 throw new Error("Attempt to auto-create PlanDefinitionGoalComponent.category"); 1638 else if (Configuration.doAutoCreate()) 1639 this.category = new CodeableConcept(); // cc 1640 return this.category; 1641 } 1642 1643 public boolean hasCategory() { 1644 return this.category != null && !this.category.isEmpty(); 1645 } 1646 1647 /** 1648 * @param value {@link #category} (Indicates a category the goal falls within.) 1649 */ 1650 public PlanDefinitionGoalComponent setCategory(CodeableConcept value) { 1651 this.category = value; 1652 return this; 1653 } 1654 1655 /** 1656 * @return {@link #description} (Human-readable and/or coded description of a 1657 * specific desired objective of care, such as "control blood pressure" 1658 * or "negotiate an obstacle course" or "dance with child at wedding".) 1659 */ 1660 public CodeableConcept getDescription() { 1661 if (this.description == null) 1662 if (Configuration.errorOnAutoCreate()) 1663 throw new Error("Attempt to auto-create PlanDefinitionGoalComponent.description"); 1664 else if (Configuration.doAutoCreate()) 1665 this.description = new CodeableConcept(); // cc 1666 return this.description; 1667 } 1668 1669 public boolean hasDescription() { 1670 return this.description != null && !this.description.isEmpty(); 1671 } 1672 1673 /** 1674 * @param value {@link #description} (Human-readable and/or coded description of 1675 * a specific desired objective of care, such as "control blood 1676 * pressure" or "negotiate an obstacle course" or "dance with child 1677 * at wedding".) 1678 */ 1679 public PlanDefinitionGoalComponent setDescription(CodeableConcept value) { 1680 this.description = value; 1681 return this; 1682 } 1683 1684 /** 1685 * @return {@link #priority} (Identifies the expected level of importance 1686 * associated with reaching/sustaining the defined goal.) 1687 */ 1688 public CodeableConcept getPriority() { 1689 if (this.priority == null) 1690 if (Configuration.errorOnAutoCreate()) 1691 throw new Error("Attempt to auto-create PlanDefinitionGoalComponent.priority"); 1692 else if (Configuration.doAutoCreate()) 1693 this.priority = new CodeableConcept(); // cc 1694 return this.priority; 1695 } 1696 1697 public boolean hasPriority() { 1698 return this.priority != null && !this.priority.isEmpty(); 1699 } 1700 1701 /** 1702 * @param value {@link #priority} (Identifies the expected level of importance 1703 * associated with reaching/sustaining the defined goal.) 1704 */ 1705 public PlanDefinitionGoalComponent setPriority(CodeableConcept value) { 1706 this.priority = value; 1707 return this; 1708 } 1709 1710 /** 1711 * @return {@link #start} (The event after which the goal should begin being 1712 * pursued.) 1713 */ 1714 public CodeableConcept getStart() { 1715 if (this.start == null) 1716 if (Configuration.errorOnAutoCreate()) 1717 throw new Error("Attempt to auto-create PlanDefinitionGoalComponent.start"); 1718 else if (Configuration.doAutoCreate()) 1719 this.start = new CodeableConcept(); // cc 1720 return this.start; 1721 } 1722 1723 public boolean hasStart() { 1724 return this.start != null && !this.start.isEmpty(); 1725 } 1726 1727 /** 1728 * @param value {@link #start} (The event after which the goal should begin 1729 * being pursued.) 1730 */ 1731 public PlanDefinitionGoalComponent setStart(CodeableConcept value) { 1732 this.start = value; 1733 return this; 1734 } 1735 1736 /** 1737 * @return {@link #addresses} (Identifies problems, conditions, issues, or 1738 * concerns the goal is intended to address.) 1739 */ 1740 public List<CodeableConcept> getAddresses() { 1741 if (this.addresses == null) 1742 this.addresses = new ArrayList<CodeableConcept>(); 1743 return this.addresses; 1744 } 1745 1746 /** 1747 * @return Returns a reference to <code>this</code> for easy method chaining 1748 */ 1749 public PlanDefinitionGoalComponent setAddresses(List<CodeableConcept> theAddresses) { 1750 this.addresses = theAddresses; 1751 return this; 1752 } 1753 1754 public boolean hasAddresses() { 1755 if (this.addresses == null) 1756 return false; 1757 for (CodeableConcept item : this.addresses) 1758 if (!item.isEmpty()) 1759 return true; 1760 return false; 1761 } 1762 1763 public CodeableConcept addAddresses() { // 3 1764 CodeableConcept t = new CodeableConcept(); 1765 if (this.addresses == null) 1766 this.addresses = new ArrayList<CodeableConcept>(); 1767 this.addresses.add(t); 1768 return t; 1769 } 1770 1771 public PlanDefinitionGoalComponent addAddresses(CodeableConcept t) { // 3 1772 if (t == null) 1773 return this; 1774 if (this.addresses == null) 1775 this.addresses = new ArrayList<CodeableConcept>(); 1776 this.addresses.add(t); 1777 return this; 1778 } 1779 1780 /** 1781 * @return The first repetition of repeating field {@link #addresses}, creating 1782 * it if it does not already exist 1783 */ 1784 public CodeableConcept getAddressesFirstRep() { 1785 if (getAddresses().isEmpty()) { 1786 addAddresses(); 1787 } 1788 return getAddresses().get(0); 1789 } 1790 1791 /** 1792 * @return {@link #documentation} (Didactic or other informational resources 1793 * associated with the goal that provide further supporting information 1794 * about the goal. Information resources can include inline text 1795 * commentary and links to web resources.) 1796 */ 1797 public List<RelatedArtifact> getDocumentation() { 1798 if (this.documentation == null) 1799 this.documentation = new ArrayList<RelatedArtifact>(); 1800 return this.documentation; 1801 } 1802 1803 /** 1804 * @return Returns a reference to <code>this</code> for easy method chaining 1805 */ 1806 public PlanDefinitionGoalComponent setDocumentation(List<RelatedArtifact> theDocumentation) { 1807 this.documentation = theDocumentation; 1808 return this; 1809 } 1810 1811 public boolean hasDocumentation() { 1812 if (this.documentation == null) 1813 return false; 1814 for (RelatedArtifact item : this.documentation) 1815 if (!item.isEmpty()) 1816 return true; 1817 return false; 1818 } 1819 1820 public RelatedArtifact addDocumentation() { // 3 1821 RelatedArtifact t = new RelatedArtifact(); 1822 if (this.documentation == null) 1823 this.documentation = new ArrayList<RelatedArtifact>(); 1824 this.documentation.add(t); 1825 return t; 1826 } 1827 1828 public PlanDefinitionGoalComponent addDocumentation(RelatedArtifact t) { // 3 1829 if (t == null) 1830 return this; 1831 if (this.documentation == null) 1832 this.documentation = new ArrayList<RelatedArtifact>(); 1833 this.documentation.add(t); 1834 return this; 1835 } 1836 1837 /** 1838 * @return The first repetition of repeating field {@link #documentation}, 1839 * creating it if it does not already exist 1840 */ 1841 public RelatedArtifact getDocumentationFirstRep() { 1842 if (getDocumentation().isEmpty()) { 1843 addDocumentation(); 1844 } 1845 return getDocumentation().get(0); 1846 } 1847 1848 /** 1849 * @return {@link #target} (Indicates what should be done and within what 1850 * timeframe.) 1851 */ 1852 public List<PlanDefinitionGoalTargetComponent> getTarget() { 1853 if (this.target == null) 1854 this.target = new ArrayList<PlanDefinitionGoalTargetComponent>(); 1855 return this.target; 1856 } 1857 1858 /** 1859 * @return Returns a reference to <code>this</code> for easy method chaining 1860 */ 1861 public PlanDefinitionGoalComponent setTarget(List<PlanDefinitionGoalTargetComponent> theTarget) { 1862 this.target = theTarget; 1863 return this; 1864 } 1865 1866 public boolean hasTarget() { 1867 if (this.target == null) 1868 return false; 1869 for (PlanDefinitionGoalTargetComponent item : this.target) 1870 if (!item.isEmpty()) 1871 return true; 1872 return false; 1873 } 1874 1875 public PlanDefinitionGoalTargetComponent addTarget() { // 3 1876 PlanDefinitionGoalTargetComponent t = new PlanDefinitionGoalTargetComponent(); 1877 if (this.target == null) 1878 this.target = new ArrayList<PlanDefinitionGoalTargetComponent>(); 1879 this.target.add(t); 1880 return t; 1881 } 1882 1883 public PlanDefinitionGoalComponent addTarget(PlanDefinitionGoalTargetComponent t) { // 3 1884 if (t == null) 1885 return this; 1886 if (this.target == null) 1887 this.target = new ArrayList<PlanDefinitionGoalTargetComponent>(); 1888 this.target.add(t); 1889 return this; 1890 } 1891 1892 /** 1893 * @return The first repetition of repeating field {@link #target}, creating it 1894 * if it does not already exist 1895 */ 1896 public PlanDefinitionGoalTargetComponent getTargetFirstRep() { 1897 if (getTarget().isEmpty()) { 1898 addTarget(); 1899 } 1900 return getTarget().get(0); 1901 } 1902 1903 protected void listChildren(List<Property> children) { 1904 super.listChildren(children); 1905 children.add( 1906 new Property("category", "CodeableConcept", "Indicates a category the goal falls within.", 0, 1, category)); 1907 children.add(new Property("description", "CodeableConcept", 1908 "Human-readable and/or coded description of a specific desired objective of care, such as \"control blood pressure\" or \"negotiate an obstacle course\" or \"dance with child at wedding\".", 1909 0, 1, description)); 1910 children.add(new Property("priority", "CodeableConcept", 1911 "Identifies the expected level of importance associated with reaching/sustaining the defined goal.", 0, 1, 1912 priority)); 1913 children.add(new Property("start", "CodeableConcept", 1914 "The event after which the goal should begin being pursued.", 0, 1, start)); 1915 children.add(new Property("addresses", "CodeableConcept", 1916 "Identifies problems, conditions, issues, or concerns the goal is intended to address.", 0, 1917 java.lang.Integer.MAX_VALUE, addresses)); 1918 children.add(new Property("documentation", "RelatedArtifact", 1919 "Didactic or other informational resources associated with the goal that provide further supporting information about the goal. Information resources can include inline text commentary and links to web resources.", 1920 0, java.lang.Integer.MAX_VALUE, documentation)); 1921 children.add(new Property("target", "", "Indicates what should be done and within what timeframe.", 0, 1922 java.lang.Integer.MAX_VALUE, target)); 1923 } 1924 1925 @Override 1926 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1927 switch (_hash) { 1928 case 50511102: 1929 /* category */ return new Property("category", "CodeableConcept", "Indicates a category the goal falls within.", 1930 0, 1, category); 1931 case -1724546052: 1932 /* description */ return new Property("description", "CodeableConcept", 1933 "Human-readable and/or coded description of a specific desired objective of care, such as \"control blood pressure\" or \"negotiate an obstacle course\" or \"dance with child at wedding\".", 1934 0, 1, description); 1935 case -1165461084: 1936 /* priority */ return new Property("priority", "CodeableConcept", 1937 "Identifies the expected level of importance associated with reaching/sustaining the defined goal.", 0, 1, 1938 priority); 1939 case 109757538: 1940 /* start */ return new Property("start", "CodeableConcept", 1941 "The event after which the goal should begin being pursued.", 0, 1, start); 1942 case 874544034: 1943 /* addresses */ return new Property("addresses", "CodeableConcept", 1944 "Identifies problems, conditions, issues, or concerns the goal is intended to address.", 0, 1945 java.lang.Integer.MAX_VALUE, addresses); 1946 case 1587405498: 1947 /* documentation */ return new Property("documentation", "RelatedArtifact", 1948 "Didactic or other informational resources associated with the goal that provide further supporting information about the goal. Information resources can include inline text commentary and links to web resources.", 1949 0, java.lang.Integer.MAX_VALUE, documentation); 1950 case -880905839: 1951 /* target */ return new Property("target", "", "Indicates what should be done and within what timeframe.", 0, 1952 java.lang.Integer.MAX_VALUE, target); 1953 default: 1954 return super.getNamedProperty(_hash, _name, _checkValid); 1955 } 1956 1957 } 1958 1959 @Override 1960 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1961 switch (hash) { 1962 case 50511102: 1963 /* category */ return this.category == null ? new Base[0] : new Base[] { this.category }; // CodeableConcept 1964 case -1724546052: 1965 /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // CodeableConcept 1966 case -1165461084: 1967 /* priority */ return this.priority == null ? new Base[0] : new Base[] { this.priority }; // CodeableConcept 1968 case 109757538: 1969 /* start */ return this.start == null ? new Base[0] : new Base[] { this.start }; // CodeableConcept 1970 case 874544034: 1971 /* addresses */ return this.addresses == null ? new Base[0] 1972 : this.addresses.toArray(new Base[this.addresses.size()]); // CodeableConcept 1973 case 1587405498: 1974 /* documentation */ return this.documentation == null ? new Base[0] 1975 : this.documentation.toArray(new Base[this.documentation.size()]); // RelatedArtifact 1976 case -880905839: 1977 /* target */ return this.target == null ? new Base[0] : this.target.toArray(new Base[this.target.size()]); // PlanDefinitionGoalTargetComponent 1978 default: 1979 return super.getProperty(hash, name, checkValid); 1980 } 1981 1982 } 1983 1984 @Override 1985 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1986 switch (hash) { 1987 case 50511102: // category 1988 this.category = castToCodeableConcept(value); // CodeableConcept 1989 return value; 1990 case -1724546052: // description 1991 this.description = castToCodeableConcept(value); // CodeableConcept 1992 return value; 1993 case -1165461084: // priority 1994 this.priority = castToCodeableConcept(value); // CodeableConcept 1995 return value; 1996 case 109757538: // start 1997 this.start = castToCodeableConcept(value); // CodeableConcept 1998 return value; 1999 case 874544034: // addresses 2000 this.getAddresses().add(castToCodeableConcept(value)); // CodeableConcept 2001 return value; 2002 case 1587405498: // documentation 2003 this.getDocumentation().add(castToRelatedArtifact(value)); // RelatedArtifact 2004 return value; 2005 case -880905839: // target 2006 this.getTarget().add((PlanDefinitionGoalTargetComponent) value); // PlanDefinitionGoalTargetComponent 2007 return value; 2008 default: 2009 return super.setProperty(hash, name, value); 2010 } 2011 2012 } 2013 2014 @Override 2015 public Base setProperty(String name, Base value) throws FHIRException { 2016 if (name.equals("category")) { 2017 this.category = castToCodeableConcept(value); // CodeableConcept 2018 } else if (name.equals("description")) { 2019 this.description = castToCodeableConcept(value); // CodeableConcept 2020 } else if (name.equals("priority")) { 2021 this.priority = castToCodeableConcept(value); // CodeableConcept 2022 } else if (name.equals("start")) { 2023 this.start = castToCodeableConcept(value); // CodeableConcept 2024 } else if (name.equals("addresses")) { 2025 this.getAddresses().add(castToCodeableConcept(value)); 2026 } else if (name.equals("documentation")) { 2027 this.getDocumentation().add(castToRelatedArtifact(value)); 2028 } else if (name.equals("target")) { 2029 this.getTarget().add((PlanDefinitionGoalTargetComponent) value); 2030 } else 2031 return super.setProperty(name, value); 2032 return value; 2033 } 2034 2035 @Override 2036 public void removeChild(String name, Base value) throws FHIRException { 2037 if (name.equals("category")) { 2038 this.category = null; 2039 } else if (name.equals("description")) { 2040 this.description = null; 2041 } else if (name.equals("priority")) { 2042 this.priority = null; 2043 } else if (name.equals("start")) { 2044 this.start = null; 2045 } else if (name.equals("addresses")) { 2046 this.getAddresses().remove(castToCodeableConcept(value)); 2047 } else if (name.equals("documentation")) { 2048 this.getDocumentation().remove(castToRelatedArtifact(value)); 2049 } else if (name.equals("target")) { 2050 this.getTarget().remove((PlanDefinitionGoalTargetComponent) value); 2051 } else 2052 super.removeChild(name, value); 2053 2054 } 2055 2056 @Override 2057 public Base makeProperty(int hash, String name) throws FHIRException { 2058 switch (hash) { 2059 case 50511102: 2060 return getCategory(); 2061 case -1724546052: 2062 return getDescription(); 2063 case -1165461084: 2064 return getPriority(); 2065 case 109757538: 2066 return getStart(); 2067 case 874544034: 2068 return addAddresses(); 2069 case 1587405498: 2070 return addDocumentation(); 2071 case -880905839: 2072 return addTarget(); 2073 default: 2074 return super.makeProperty(hash, name); 2075 } 2076 2077 } 2078 2079 @Override 2080 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2081 switch (hash) { 2082 case 50511102: 2083 /* category */ return new String[] { "CodeableConcept" }; 2084 case -1724546052: 2085 /* description */ return new String[] { "CodeableConcept" }; 2086 case -1165461084: 2087 /* priority */ return new String[] { "CodeableConcept" }; 2088 case 109757538: 2089 /* start */ return new String[] { "CodeableConcept" }; 2090 case 874544034: 2091 /* addresses */ return new String[] { "CodeableConcept" }; 2092 case 1587405498: 2093 /* documentation */ return new String[] { "RelatedArtifact" }; 2094 case -880905839: 2095 /* target */ return new String[] {}; 2096 default: 2097 return super.getTypesForProperty(hash, name); 2098 } 2099 2100 } 2101 2102 @Override 2103 public Base addChild(String name) throws FHIRException { 2104 if (name.equals("category")) { 2105 this.category = new CodeableConcept(); 2106 return this.category; 2107 } else if (name.equals("description")) { 2108 this.description = new CodeableConcept(); 2109 return this.description; 2110 } else if (name.equals("priority")) { 2111 this.priority = new CodeableConcept(); 2112 return this.priority; 2113 } else if (name.equals("start")) { 2114 this.start = new CodeableConcept(); 2115 return this.start; 2116 } else if (name.equals("addresses")) { 2117 return addAddresses(); 2118 } else if (name.equals("documentation")) { 2119 return addDocumentation(); 2120 } else if (name.equals("target")) { 2121 return addTarget(); 2122 } else 2123 return super.addChild(name); 2124 } 2125 2126 public PlanDefinitionGoalComponent copy() { 2127 PlanDefinitionGoalComponent dst = new PlanDefinitionGoalComponent(); 2128 copyValues(dst); 2129 return dst; 2130 } 2131 2132 public void copyValues(PlanDefinitionGoalComponent dst) { 2133 super.copyValues(dst); 2134 dst.category = category == null ? null : category.copy(); 2135 dst.description = description == null ? null : description.copy(); 2136 dst.priority = priority == null ? null : priority.copy(); 2137 dst.start = start == null ? null : start.copy(); 2138 if (addresses != null) { 2139 dst.addresses = new ArrayList<CodeableConcept>(); 2140 for (CodeableConcept i : addresses) 2141 dst.addresses.add(i.copy()); 2142 } 2143 ; 2144 if (documentation != null) { 2145 dst.documentation = new ArrayList<RelatedArtifact>(); 2146 for (RelatedArtifact i : documentation) 2147 dst.documentation.add(i.copy()); 2148 } 2149 ; 2150 if (target != null) { 2151 dst.target = new ArrayList<PlanDefinitionGoalTargetComponent>(); 2152 for (PlanDefinitionGoalTargetComponent i : target) 2153 dst.target.add(i.copy()); 2154 } 2155 ; 2156 } 2157 2158 @Override 2159 public boolean equalsDeep(Base other_) { 2160 if (!super.equalsDeep(other_)) 2161 return false; 2162 if (!(other_ instanceof PlanDefinitionGoalComponent)) 2163 return false; 2164 PlanDefinitionGoalComponent o = (PlanDefinitionGoalComponent) other_; 2165 return compareDeep(category, o.category, true) && compareDeep(description, o.description, true) 2166 && compareDeep(priority, o.priority, true) && compareDeep(start, o.start, true) 2167 && compareDeep(addresses, o.addresses, true) && compareDeep(documentation, o.documentation, true) 2168 && compareDeep(target, o.target, true); 2169 } 2170 2171 @Override 2172 public boolean equalsShallow(Base other_) { 2173 if (!super.equalsShallow(other_)) 2174 return false; 2175 if (!(other_ instanceof PlanDefinitionGoalComponent)) 2176 return false; 2177 PlanDefinitionGoalComponent o = (PlanDefinitionGoalComponent) other_; 2178 return true; 2179 } 2180 2181 public boolean isEmpty() { 2182 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(category, description, priority, start, addresses, 2183 documentation, target); 2184 } 2185 2186 public String fhirType() { 2187 return "PlanDefinition.goal"; 2188 2189 } 2190 2191 } 2192 2193 @Block() 2194 public static class PlanDefinitionGoalTargetComponent extends BackboneElement implements IBaseBackboneElement { 2195 /** 2196 * The parameter whose value is to be tracked, e.g. body weight, blood pressure, 2197 * or hemoglobin A1c level. 2198 */ 2199 @Child(name = "measure", type = { 2200 CodeableConcept.class }, order = 1, min = 0, max = 1, modifier = false, summary = false) 2201 @Description(shortDefinition = "The parameter whose value is to be tracked", formalDefinition = "The parameter whose value is to be tracked, e.g. body weight, blood pressure, or hemoglobin A1c level.") 2202 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/observation-codes") 2203 protected CodeableConcept measure; 2204 2205 /** 2206 * The target value of the measure to be achieved to signify fulfillment of the 2207 * goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the 2208 * range can be specified. When a low value is missing, it indicates that the 2209 * goal is achieved at any value at or below the high value. Similarly, if the 2210 * high value is missing, it indicates that the goal is achieved at any value at 2211 * or above the low value. 2212 */ 2213 @Child(name = "detail", type = { Quantity.class, Range.class, 2214 CodeableConcept.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 2215 @Description(shortDefinition = "The target value to be achieved", formalDefinition = "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. When a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.") 2216 protected Type detail; 2217 2218 /** 2219 * Indicates the timeframe after the start of the goal in which the goal should 2220 * be met. 2221 */ 2222 @Child(name = "due", type = { Duration.class }, order = 3, min = 0, max = 1, modifier = false, summary = false) 2223 @Description(shortDefinition = "Reach goal within", formalDefinition = "Indicates the timeframe after the start of the goal in which the goal should be met.") 2224 protected Duration due; 2225 2226 private static final long serialVersionUID = -131874144L; 2227 2228 /** 2229 * Constructor 2230 */ 2231 public PlanDefinitionGoalTargetComponent() { 2232 super(); 2233 } 2234 2235 /** 2236 * @return {@link #measure} (The parameter whose value is to be tracked, e.g. 2237 * body weight, blood pressure, or hemoglobin A1c level.) 2238 */ 2239 public CodeableConcept getMeasure() { 2240 if (this.measure == null) 2241 if (Configuration.errorOnAutoCreate()) 2242 throw new Error("Attempt to auto-create PlanDefinitionGoalTargetComponent.measure"); 2243 else if (Configuration.doAutoCreate()) 2244 this.measure = new CodeableConcept(); // cc 2245 return this.measure; 2246 } 2247 2248 public boolean hasMeasure() { 2249 return this.measure != null && !this.measure.isEmpty(); 2250 } 2251 2252 /** 2253 * @param value {@link #measure} (The parameter whose value is to be tracked, 2254 * e.g. body weight, blood pressure, or hemoglobin A1c level.) 2255 */ 2256 public PlanDefinitionGoalTargetComponent setMeasure(CodeableConcept value) { 2257 this.measure = value; 2258 return this; 2259 } 2260 2261 /** 2262 * @return {@link #detail} (The target value of the measure to be achieved to 2263 * signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the 2264 * high or low or both values of the range can be specified. When a low 2265 * value is missing, it indicates that the goal is achieved at any value 2266 * at or below the high value. Similarly, if the high value is missing, 2267 * it indicates that the goal is achieved at any value at or above the 2268 * low value.) 2269 */ 2270 public Type getDetail() { 2271 return this.detail; 2272 } 2273 2274 /** 2275 * @return {@link #detail} (The target value of the measure to be achieved to 2276 * signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the 2277 * high or low or both values of the range can be specified. When a low 2278 * value is missing, it indicates that the goal is achieved at any value 2279 * at or below the high value. Similarly, if the high value is missing, 2280 * it indicates that the goal is achieved at any value at or above the 2281 * low value.) 2282 */ 2283 public Quantity getDetailQuantity() throws FHIRException { 2284 if (this.detail == null) 2285 this.detail = new Quantity(); 2286 if (!(this.detail instanceof Quantity)) 2287 throw new FHIRException("Type mismatch: the type Quantity was expected, but " + this.detail.getClass().getName() 2288 + " was encountered"); 2289 return (Quantity) this.detail; 2290 } 2291 2292 public boolean hasDetailQuantity() { 2293 return this != null && this.detail instanceof Quantity; 2294 } 2295 2296 /** 2297 * @return {@link #detail} (The target value of the measure to be achieved to 2298 * signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the 2299 * high or low or both values of the range can be specified. When a low 2300 * value is missing, it indicates that the goal is achieved at any value 2301 * at or below the high value. Similarly, if the high value is missing, 2302 * it indicates that the goal is achieved at any value at or above the 2303 * low value.) 2304 */ 2305 public Range getDetailRange() throws FHIRException { 2306 if (this.detail == null) 2307 this.detail = new Range(); 2308 if (!(this.detail instanceof Range)) 2309 throw new FHIRException( 2310 "Type mismatch: the type Range was expected, but " + this.detail.getClass().getName() + " was encountered"); 2311 return (Range) this.detail; 2312 } 2313 2314 public boolean hasDetailRange() { 2315 return this != null && this.detail instanceof Range; 2316 } 2317 2318 /** 2319 * @return {@link #detail} (The target value of the measure to be achieved to 2320 * signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the 2321 * high or low or both values of the range can be specified. When a low 2322 * value is missing, it indicates that the goal is achieved at any value 2323 * at or below the high value. Similarly, if the high value is missing, 2324 * it indicates that the goal is achieved at any value at or above the 2325 * low value.) 2326 */ 2327 public CodeableConcept getDetailCodeableConcept() throws FHIRException { 2328 if (this.detail == null) 2329 this.detail = new CodeableConcept(); 2330 if (!(this.detail instanceof CodeableConcept)) 2331 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but " 2332 + this.detail.getClass().getName() + " was encountered"); 2333 return (CodeableConcept) this.detail; 2334 } 2335 2336 public boolean hasDetailCodeableConcept() { 2337 return this != null && this.detail instanceof CodeableConcept; 2338 } 2339 2340 public boolean hasDetail() { 2341 return this.detail != null && !this.detail.isEmpty(); 2342 } 2343 2344 /** 2345 * @param value {@link #detail} (The target value of the measure to be achieved 2346 * to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. 2347 * Either the high or low or both values of the range can be 2348 * specified. When a low value is missing, it indicates that the 2349 * goal is achieved at any value at or below the high value. 2350 * Similarly, if the high value is missing, it indicates that the 2351 * goal is achieved at any value at or above the low value.) 2352 */ 2353 public PlanDefinitionGoalTargetComponent setDetail(Type value) { 2354 if (value != null && !(value instanceof Quantity || value instanceof Range || value instanceof CodeableConcept)) 2355 throw new Error("Not the right type for PlanDefinition.goal.target.detail[x]: " + value.fhirType()); 2356 this.detail = value; 2357 return this; 2358 } 2359 2360 /** 2361 * @return {@link #due} (Indicates the timeframe after the start of the goal in 2362 * which the goal should be met.) 2363 */ 2364 public Duration getDue() { 2365 if (this.due == null) 2366 if (Configuration.errorOnAutoCreate()) 2367 throw new Error("Attempt to auto-create PlanDefinitionGoalTargetComponent.due"); 2368 else if (Configuration.doAutoCreate()) 2369 this.due = new Duration(); // cc 2370 return this.due; 2371 } 2372 2373 public boolean hasDue() { 2374 return this.due != null && !this.due.isEmpty(); 2375 } 2376 2377 /** 2378 * @param value {@link #due} (Indicates the timeframe after the start of the 2379 * goal in which the goal should be met.) 2380 */ 2381 public PlanDefinitionGoalTargetComponent setDue(Duration value) { 2382 this.due = value; 2383 return this; 2384 } 2385 2386 protected void listChildren(List<Property> children) { 2387 super.listChildren(children); 2388 children.add(new Property("measure", "CodeableConcept", 2389 "The parameter whose value is to be tracked, e.g. body weight, blood pressure, or hemoglobin A1c level.", 0, 2390 1, measure)); 2391 children.add(new Property("detail[x]", "Quantity|Range|CodeableConcept", 2392 "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. When a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.", 2393 0, 1, detail)); 2394 children.add(new Property("due", "Duration", 2395 "Indicates the timeframe after the start of the goal in which the goal should be met.", 0, 1, due)); 2396 } 2397 2398 @Override 2399 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2400 switch (_hash) { 2401 case 938321246: 2402 /* measure */ return new Property("measure", "CodeableConcept", 2403 "The parameter whose value is to be tracked, e.g. body weight, blood pressure, or hemoglobin A1c level.", 0, 2404 1, measure); 2405 case -1973084529: 2406 /* detail[x] */ return new Property("detail[x]", "Quantity|Range|CodeableConcept", 2407 "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. When a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.", 2408 0, 1, detail); 2409 case -1335224239: 2410 /* detail */ return new Property("detail[x]", "Quantity|Range|CodeableConcept", 2411 "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. When a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.", 2412 0, 1, detail); 2413 case -1313079300: 2414 /* detailQuantity */ return new Property("detail[x]", "Quantity|Range|CodeableConcept", 2415 "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. When a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.", 2416 0, 1, detail); 2417 case -2062632084: 2418 /* detailRange */ return new Property("detail[x]", "Quantity|Range|CodeableConcept", 2419 "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. When a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.", 2420 0, 1, detail); 2421 case -175586544: 2422 /* detailCodeableConcept */ return new Property("detail[x]", "Quantity|Range|CodeableConcept", 2423 "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. When a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.", 2424 0, 1, detail); 2425 case 99828: 2426 /* due */ return new Property("due", "Duration", 2427 "Indicates the timeframe after the start of the goal in which the goal should be met.", 0, 1, due); 2428 default: 2429 return super.getNamedProperty(_hash, _name, _checkValid); 2430 } 2431 2432 } 2433 2434 @Override 2435 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2436 switch (hash) { 2437 case 938321246: 2438 /* measure */ return this.measure == null ? new Base[0] : new Base[] { this.measure }; // CodeableConcept 2439 case -1335224239: 2440 /* detail */ return this.detail == null ? new Base[0] : new Base[] { this.detail }; // Type 2441 case 99828: 2442 /* due */ return this.due == null ? new Base[0] : new Base[] { this.due }; // Duration 2443 default: 2444 return super.getProperty(hash, name, checkValid); 2445 } 2446 2447 } 2448 2449 @Override 2450 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2451 switch (hash) { 2452 case 938321246: // measure 2453 this.measure = castToCodeableConcept(value); // CodeableConcept 2454 return value; 2455 case -1335224239: // detail 2456 this.detail = castToType(value); // Type 2457 return value; 2458 case 99828: // due 2459 this.due = castToDuration(value); // Duration 2460 return value; 2461 default: 2462 return super.setProperty(hash, name, value); 2463 } 2464 2465 } 2466 2467 @Override 2468 public Base setProperty(String name, Base value) throws FHIRException { 2469 if (name.equals("measure")) { 2470 this.measure = castToCodeableConcept(value); // CodeableConcept 2471 } else if (name.equals("detail[x]")) { 2472 this.detail = castToType(value); // Type 2473 } else if (name.equals("due")) { 2474 this.due = castToDuration(value); // Duration 2475 } else 2476 return super.setProperty(name, value); 2477 return value; 2478 } 2479 2480 @Override 2481 public void removeChild(String name, Base value) throws FHIRException { 2482 if (name.equals("measure")) { 2483 this.measure = null; 2484 } else if (name.equals("detail[x]")) { 2485 this.detail = null; 2486 } else if (name.equals("due")) { 2487 this.due = null; 2488 } else 2489 super.removeChild(name, value); 2490 2491 } 2492 2493 @Override 2494 public Base makeProperty(int hash, String name) throws FHIRException { 2495 switch (hash) { 2496 case 938321246: 2497 return getMeasure(); 2498 case -1973084529: 2499 return getDetail(); 2500 case -1335224239: 2501 return getDetail(); 2502 case 99828: 2503 return getDue(); 2504 default: 2505 return super.makeProperty(hash, name); 2506 } 2507 2508 } 2509 2510 @Override 2511 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2512 switch (hash) { 2513 case 938321246: 2514 /* measure */ return new String[] { "CodeableConcept" }; 2515 case -1335224239: 2516 /* detail */ return new String[] { "Quantity", "Range", "CodeableConcept" }; 2517 case 99828: 2518 /* due */ return new String[] { "Duration" }; 2519 default: 2520 return super.getTypesForProperty(hash, name); 2521 } 2522 2523 } 2524 2525 @Override 2526 public Base addChild(String name) throws FHIRException { 2527 if (name.equals("measure")) { 2528 this.measure = new CodeableConcept(); 2529 return this.measure; 2530 } else if (name.equals("detailQuantity")) { 2531 this.detail = new Quantity(); 2532 return this.detail; 2533 } else if (name.equals("detailRange")) { 2534 this.detail = new Range(); 2535 return this.detail; 2536 } else if (name.equals("detailCodeableConcept")) { 2537 this.detail = new CodeableConcept(); 2538 return this.detail; 2539 } else if (name.equals("due")) { 2540 this.due = new Duration(); 2541 return this.due; 2542 } else 2543 return super.addChild(name); 2544 } 2545 2546 public PlanDefinitionGoalTargetComponent copy() { 2547 PlanDefinitionGoalTargetComponent dst = new PlanDefinitionGoalTargetComponent(); 2548 copyValues(dst); 2549 return dst; 2550 } 2551 2552 public void copyValues(PlanDefinitionGoalTargetComponent dst) { 2553 super.copyValues(dst); 2554 dst.measure = measure == null ? null : measure.copy(); 2555 dst.detail = detail == null ? null : detail.copy(); 2556 dst.due = due == null ? null : due.copy(); 2557 } 2558 2559 @Override 2560 public boolean equalsDeep(Base other_) { 2561 if (!super.equalsDeep(other_)) 2562 return false; 2563 if (!(other_ instanceof PlanDefinitionGoalTargetComponent)) 2564 return false; 2565 PlanDefinitionGoalTargetComponent o = (PlanDefinitionGoalTargetComponent) other_; 2566 return compareDeep(measure, o.measure, true) && compareDeep(detail, o.detail, true) 2567 && compareDeep(due, o.due, true); 2568 } 2569 2570 @Override 2571 public boolean equalsShallow(Base other_) { 2572 if (!super.equalsShallow(other_)) 2573 return false; 2574 if (!(other_ instanceof PlanDefinitionGoalTargetComponent)) 2575 return false; 2576 PlanDefinitionGoalTargetComponent o = (PlanDefinitionGoalTargetComponent) other_; 2577 return true; 2578 } 2579 2580 public boolean isEmpty() { 2581 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(measure, detail, due); 2582 } 2583 2584 public String fhirType() { 2585 return "PlanDefinition.goal.target"; 2586 2587 } 2588 2589 } 2590 2591 @Block() 2592 public static class PlanDefinitionActionComponent extends BackboneElement implements IBaseBackboneElement { 2593 /** 2594 * A user-visible prefix for the action. 2595 */ 2596 @Child(name = "prefix", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false) 2597 @Description(shortDefinition = "User-visible prefix for the action (e.g. 1. or A.)", formalDefinition = "A user-visible prefix for the action.") 2598 protected StringType prefix; 2599 2600 /** 2601 * The title of the action displayed to a user. 2602 */ 2603 @Child(name = "title", type = { StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 2604 @Description(shortDefinition = "User-visible title", formalDefinition = "The title of the action displayed to a user.") 2605 protected StringType title; 2606 2607 /** 2608 * A brief description of the action used to provide a summary to display to the 2609 * user. 2610 */ 2611 @Child(name = "description", type = { 2612 StringType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false) 2613 @Description(shortDefinition = "Brief description of the action", formalDefinition = "A brief description of the action used to provide a summary to display to the user.") 2614 protected StringType description; 2615 2616 /** 2617 * A text equivalent of the action to be performed. This provides a 2618 * human-interpretable description of the action when the definition is consumed 2619 * by a system that might not be capable of interpreting it dynamically. 2620 */ 2621 @Child(name = "textEquivalent", type = { 2622 StringType.class }, order = 4, min = 0, max = 1, modifier = false, summary = false) 2623 @Description(shortDefinition = "Static text equivalent of the action, used if the dynamic aspects cannot be interpreted by the receiving system", formalDefinition = "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that might not be capable of interpreting it dynamically.") 2624 protected StringType textEquivalent; 2625 2626 /** 2627 * Indicates how quickly the action should be addressed with respect to other 2628 * actions. 2629 */ 2630 @Child(name = "priority", type = { CodeType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false) 2631 @Description(shortDefinition = "routine | urgent | asap | stat", formalDefinition = "Indicates how quickly the action should be addressed with respect to other actions.") 2632 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/request-priority") 2633 protected Enumeration<RequestPriority> priority; 2634 2635 /** 2636 * A code that provides meaning for the action or action group. For example, a 2637 * section may have a LOINC code for the section of a documentation template. 2638 */ 2639 @Child(name = "code", type = { 2640 CodeableConcept.class }, order = 6, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2641 @Description(shortDefinition = "Code representing the meaning of the action or sub-actions", formalDefinition = "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for the section of a documentation template.") 2642 protected List<CodeableConcept> code; 2643 2644 /** 2645 * A description of why this action is necessary or appropriate. 2646 */ 2647 @Child(name = "reason", type = { 2648 CodeableConcept.class }, order = 7, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2649 @Description(shortDefinition = "Why the action should be performed", formalDefinition = "A description of why this action is necessary or appropriate.") 2650 protected List<CodeableConcept> reason; 2651 2652 /** 2653 * Didactic or other informational resources associated with the action that can 2654 * be provided to the CDS recipient. Information resources can include inline 2655 * text commentary and links to web resources. 2656 */ 2657 @Child(name = "documentation", type = { 2658 RelatedArtifact.class }, order = 8, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2659 @Description(shortDefinition = "Supporting documentation for the intended performer of the action", formalDefinition = "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.") 2660 protected List<RelatedArtifact> documentation; 2661 2662 /** 2663 * Identifies goals that this action supports. The reference must be to a goal 2664 * element defined within this plan definition. 2665 */ 2666 @Child(name = "goalId", type = { 2667 IdType.class }, order = 9, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2668 @Description(shortDefinition = "What goals this action supports", formalDefinition = "Identifies goals that this action supports. The reference must be to a goal element defined within this plan definition.") 2669 protected List<IdType> goalId; 2670 2671 /** 2672 * A code or group definition that describes the intended subject of the action 2673 * and its children, if any. 2674 */ 2675 @Child(name = "subject", type = { CodeableConcept.class, 2676 Group.class }, order = 10, min = 0, max = 1, modifier = false, summary = false) 2677 @Description(shortDefinition = "Type of individual the action is focused on", formalDefinition = "A code or group definition that describes the intended subject of the action and its children, if any.") 2678 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/subject-type") 2679 protected Type subject; 2680 2681 /** 2682 * A description of when the action should be triggered. 2683 */ 2684 @Child(name = "trigger", type = { 2685 TriggerDefinition.class }, order = 11, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2686 @Description(shortDefinition = "When the action should be triggered", formalDefinition = "A description of when the action should be triggered.") 2687 protected List<TriggerDefinition> trigger; 2688 2689 /** 2690 * An expression that describes applicability criteria or start/stop conditions 2691 * for the action. 2692 */ 2693 @Child(name = "condition", type = {}, order = 12, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2694 @Description(shortDefinition = "Whether or not the action is applicable", formalDefinition = "An expression that describes applicability criteria or start/stop conditions for the action.") 2695 protected List<PlanDefinitionActionConditionComponent> condition; 2696 2697 /** 2698 * Defines input data requirements for the action. 2699 */ 2700 @Child(name = "input", type = { 2701 DataRequirement.class }, order = 13, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2702 @Description(shortDefinition = "Input data requirements", formalDefinition = "Defines input data requirements for the action.") 2703 protected List<DataRequirement> input; 2704 2705 /** 2706 * Defines the outputs of the action, if any. 2707 */ 2708 @Child(name = "output", type = { 2709 DataRequirement.class }, order = 14, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2710 @Description(shortDefinition = "Output data definition", formalDefinition = "Defines the outputs of the action, if any.") 2711 protected List<DataRequirement> output; 2712 2713 /** 2714 * A relationship to another action such as "before" or "30-60 minutes after 2715 * start of". 2716 */ 2717 @Child(name = "relatedAction", type = {}, order = 15, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2718 @Description(shortDefinition = "Relationship to another action", formalDefinition = "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".") 2719 protected List<PlanDefinitionActionRelatedActionComponent> relatedAction; 2720 2721 /** 2722 * An optional value describing when the action should be performed. 2723 */ 2724 @Child(name = "timing", type = { DateTimeType.class, Age.class, Period.class, Duration.class, Range.class, 2725 Timing.class }, order = 16, min = 0, max = 1, modifier = false, summary = false) 2726 @Description(shortDefinition = "When the action should take place", formalDefinition = "An optional value describing when the action should be performed.") 2727 protected Type timing; 2728 2729 /** 2730 * Indicates who should participate in performing the action described. 2731 */ 2732 @Child(name = "participant", type = {}, order = 17, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2733 @Description(shortDefinition = "Who should participate in the action", formalDefinition = "Indicates who should participate in performing the action described.") 2734 protected List<PlanDefinitionActionParticipantComponent> participant; 2735 2736 /** 2737 * The type of action to perform (create, update, remove). 2738 */ 2739 @Child(name = "type", type = { 2740 CodeableConcept.class }, order = 18, min = 0, max = 1, modifier = false, summary = false) 2741 @Description(shortDefinition = "create | update | remove | fire-event", formalDefinition = "The type of action to perform (create, update, remove).") 2742 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-type") 2743 protected CodeableConcept type; 2744 2745 /** 2746 * Defines the grouping behavior for the action and its children. 2747 */ 2748 @Child(name = "groupingBehavior", type = { 2749 CodeType.class }, order = 19, min = 0, max = 1, modifier = false, summary = false) 2750 @Description(shortDefinition = "visual-group | logical-group | sentence-group", formalDefinition = "Defines the grouping behavior for the action and its children.") 2751 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-grouping-behavior") 2752 protected Enumeration<ActionGroupingBehavior> groupingBehavior; 2753 2754 /** 2755 * Defines the selection behavior for the action and its children. 2756 */ 2757 @Child(name = "selectionBehavior", type = { 2758 CodeType.class }, order = 20, min = 0, max = 1, modifier = false, summary = false) 2759 @Description(shortDefinition = "any | all | all-or-none | exactly-one | at-most-one | one-or-more", formalDefinition = "Defines the selection behavior for the action and its children.") 2760 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-selection-behavior") 2761 protected Enumeration<ActionSelectionBehavior> selectionBehavior; 2762 2763 /** 2764 * Defines the required behavior for the action. 2765 */ 2766 @Child(name = "requiredBehavior", type = { 2767 CodeType.class }, order = 21, min = 0, max = 1, modifier = false, summary = false) 2768 @Description(shortDefinition = "must | could | must-unless-documented", formalDefinition = "Defines the required behavior for the action.") 2769 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-required-behavior") 2770 protected Enumeration<ActionRequiredBehavior> requiredBehavior; 2771 2772 /** 2773 * Defines whether the action should usually be preselected. 2774 */ 2775 @Child(name = "precheckBehavior", type = { 2776 CodeType.class }, order = 22, min = 0, max = 1, modifier = false, summary = false) 2777 @Description(shortDefinition = "yes | no", formalDefinition = "Defines whether the action should usually be preselected.") 2778 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-precheck-behavior") 2779 protected Enumeration<ActionPrecheckBehavior> precheckBehavior; 2780 2781 /** 2782 * Defines whether the action can be selected multiple times. 2783 */ 2784 @Child(name = "cardinalityBehavior", type = { 2785 CodeType.class }, order = 23, min = 0, max = 1, modifier = false, summary = false) 2786 @Description(shortDefinition = "single | multiple", formalDefinition = "Defines whether the action can be selected multiple times.") 2787 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-cardinality-behavior") 2788 protected Enumeration<ActionCardinalityBehavior> cardinalityBehavior; 2789 2790 /** 2791 * A reference to an ActivityDefinition that describes the action to be taken in 2792 * detail, or a PlanDefinition that describes a series of actions to be taken. 2793 */ 2794 @Child(name = "definition", type = { CanonicalType.class, 2795 UriType.class }, order = 24, min = 0, max = 1, modifier = false, summary = false) 2796 @Description(shortDefinition = "Description of the activity to be performed", formalDefinition = "A reference to an ActivityDefinition that describes the action to be taken in detail, or a PlanDefinition that describes a series of actions to be taken.") 2797 protected Type definition; 2798 2799 /** 2800 * A reference to a StructureMap resource that defines a transform that can be 2801 * executed to produce the intent resource using the ActivityDefinition instance 2802 * as the input. 2803 */ 2804 @Child(name = "transform", type = { 2805 CanonicalType.class }, order = 25, min = 0, max = 1, modifier = false, summary = false) 2806 @Description(shortDefinition = "Transform to apply the template", formalDefinition = "A reference to a StructureMap resource that defines a transform that can be executed to produce the intent resource using the ActivityDefinition instance as the input.") 2807 protected CanonicalType transform; 2808 2809 /** 2810 * Customizations that should be applied to the statically defined resource. For 2811 * example, if the dosage of a medication must be computed based on the 2812 * patient's weight, a customization would be used to specify an expression that 2813 * calculated the weight, and the path on the resource that would contain the 2814 * result. 2815 */ 2816 @Child(name = "dynamicValue", type = {}, order = 26, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2817 @Description(shortDefinition = "Dynamic aspects of the definition", formalDefinition = "Customizations that should be applied to the statically defined resource. For example, if the dosage of a medication must be computed based on the patient's weight, a customization would be used to specify an expression that calculated the weight, and the path on the resource that would contain the result.") 2818 protected List<PlanDefinitionActionDynamicValueComponent> dynamicValue; 2819 2820 /** 2821 * Sub actions that are contained within the action. The behavior of this action 2822 * determines the functionality of the sub-actions. For example, a selection 2823 * behavior of at-most-one indicates that of the sub-actions, at most one may be 2824 * chosen as part of realizing the action definition. 2825 */ 2826 @Child(name = "action", type = { 2827 PlanDefinitionActionComponent.class }, order = 27, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2828 @Description(shortDefinition = "A sub-action", formalDefinition = "Sub actions that are contained within the action. The behavior of this action determines the functionality of the sub-actions. For example, a selection behavior of at-most-one indicates that of the sub-actions, at most one may be chosen as part of realizing the action definition.") 2829 protected List<PlanDefinitionActionComponent> action; 2830 2831 private static final long serialVersionUID = 158605540L; 2832 2833 /** 2834 * Constructor 2835 */ 2836 public PlanDefinitionActionComponent() { 2837 super(); 2838 } 2839 2840 /** 2841 * @return {@link #prefix} (A user-visible prefix for the action.). This is the 2842 * underlying object with id, value and extensions. The accessor 2843 * "getPrefix" gives direct access to the value 2844 */ 2845 public StringType getPrefixElement() { 2846 if (this.prefix == null) 2847 if (Configuration.errorOnAutoCreate()) 2848 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.prefix"); 2849 else if (Configuration.doAutoCreate()) 2850 this.prefix = new StringType(); // bb 2851 return this.prefix; 2852 } 2853 2854 public boolean hasPrefixElement() { 2855 return this.prefix != null && !this.prefix.isEmpty(); 2856 } 2857 2858 public boolean hasPrefix() { 2859 return this.prefix != null && !this.prefix.isEmpty(); 2860 } 2861 2862 /** 2863 * @param value {@link #prefix} (A user-visible prefix for the action.). This is 2864 * the underlying object with id, value and extensions. The 2865 * accessor "getPrefix" gives direct access to the value 2866 */ 2867 public PlanDefinitionActionComponent setPrefixElement(StringType value) { 2868 this.prefix = value; 2869 return this; 2870 } 2871 2872 /** 2873 * @return A user-visible prefix for the action. 2874 */ 2875 public String getPrefix() { 2876 return this.prefix == null ? null : this.prefix.getValue(); 2877 } 2878 2879 /** 2880 * @param value A user-visible prefix for the action. 2881 */ 2882 public PlanDefinitionActionComponent setPrefix(String value) { 2883 if (Utilities.noString(value)) 2884 this.prefix = null; 2885 else { 2886 if (this.prefix == null) 2887 this.prefix = new StringType(); 2888 this.prefix.setValue(value); 2889 } 2890 return this; 2891 } 2892 2893 /** 2894 * @return {@link #title} (The title of the action displayed to a user.). This 2895 * is the underlying object with id, value and extensions. The accessor 2896 * "getTitle" gives direct access to the value 2897 */ 2898 public StringType getTitleElement() { 2899 if (this.title == null) 2900 if (Configuration.errorOnAutoCreate()) 2901 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.title"); 2902 else if (Configuration.doAutoCreate()) 2903 this.title = new StringType(); // bb 2904 return this.title; 2905 } 2906 2907 public boolean hasTitleElement() { 2908 return this.title != null && !this.title.isEmpty(); 2909 } 2910 2911 public boolean hasTitle() { 2912 return this.title != null && !this.title.isEmpty(); 2913 } 2914 2915 /** 2916 * @param value {@link #title} (The title of the action displayed to a user.). 2917 * This is the underlying object with id, value and extensions. The 2918 * accessor "getTitle" gives direct access to the value 2919 */ 2920 public PlanDefinitionActionComponent setTitleElement(StringType value) { 2921 this.title = value; 2922 return this; 2923 } 2924 2925 /** 2926 * @return The title of the action displayed to a user. 2927 */ 2928 public String getTitle() { 2929 return this.title == null ? null : this.title.getValue(); 2930 } 2931 2932 /** 2933 * @param value The title of the action displayed to a user. 2934 */ 2935 public PlanDefinitionActionComponent setTitle(String value) { 2936 if (Utilities.noString(value)) 2937 this.title = null; 2938 else { 2939 if (this.title == null) 2940 this.title = new StringType(); 2941 this.title.setValue(value); 2942 } 2943 return this; 2944 } 2945 2946 /** 2947 * @return {@link #description} (A brief description of the action used to 2948 * provide a summary to display to the user.). This is the underlying 2949 * object with id, value and extensions. The accessor "getDescription" 2950 * gives direct access to the value 2951 */ 2952 public StringType getDescriptionElement() { 2953 if (this.description == null) 2954 if (Configuration.errorOnAutoCreate()) 2955 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.description"); 2956 else if (Configuration.doAutoCreate()) 2957 this.description = new StringType(); // bb 2958 return this.description; 2959 } 2960 2961 public boolean hasDescriptionElement() { 2962 return this.description != null && !this.description.isEmpty(); 2963 } 2964 2965 public boolean hasDescription() { 2966 return this.description != null && !this.description.isEmpty(); 2967 } 2968 2969 /** 2970 * @param value {@link #description} (A brief description of the action used to 2971 * provide a summary to display to the user.). This is the 2972 * underlying object with id, value and extensions. The accessor 2973 * "getDescription" gives direct access to the value 2974 */ 2975 public PlanDefinitionActionComponent setDescriptionElement(StringType value) { 2976 this.description = value; 2977 return this; 2978 } 2979 2980 /** 2981 * @return A brief description of the action used to provide a summary to 2982 * display to the user. 2983 */ 2984 public String getDescription() { 2985 return this.description == null ? null : this.description.getValue(); 2986 } 2987 2988 /** 2989 * @param value A brief description of the action used to provide a summary to 2990 * display to the user. 2991 */ 2992 public PlanDefinitionActionComponent setDescription(String value) { 2993 if (Utilities.noString(value)) 2994 this.description = null; 2995 else { 2996 if (this.description == null) 2997 this.description = new StringType(); 2998 this.description.setValue(value); 2999 } 3000 return this; 3001 } 3002 3003 /** 3004 * @return {@link #textEquivalent} (A text equivalent of the action to be 3005 * performed. This provides a human-interpretable description of the 3006 * action when the definition is consumed by a system that might not be 3007 * capable of interpreting it dynamically.). This is the underlying 3008 * object with id, value and extensions. The accessor 3009 * "getTextEquivalent" gives direct access to the value 3010 */ 3011 public StringType getTextEquivalentElement() { 3012 if (this.textEquivalent == null) 3013 if (Configuration.errorOnAutoCreate()) 3014 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.textEquivalent"); 3015 else if (Configuration.doAutoCreate()) 3016 this.textEquivalent = new StringType(); // bb 3017 return this.textEquivalent; 3018 } 3019 3020 public boolean hasTextEquivalentElement() { 3021 return this.textEquivalent != null && !this.textEquivalent.isEmpty(); 3022 } 3023 3024 public boolean hasTextEquivalent() { 3025 return this.textEquivalent != null && !this.textEquivalent.isEmpty(); 3026 } 3027 3028 /** 3029 * @param value {@link #textEquivalent} (A text equivalent of the action to be 3030 * performed. This provides a human-interpretable description of 3031 * the action when the definition is consumed by a system that 3032 * might not be capable of interpreting it dynamically.). This is 3033 * the underlying object with id, value and extensions. The 3034 * accessor "getTextEquivalent" gives direct access to the value 3035 */ 3036 public PlanDefinitionActionComponent setTextEquivalentElement(StringType value) { 3037 this.textEquivalent = value; 3038 return this; 3039 } 3040 3041 /** 3042 * @return A text equivalent of the action to be performed. This provides a 3043 * human-interpretable description of the action when the definition is 3044 * consumed by a system that might not be capable of interpreting it 3045 * dynamically. 3046 */ 3047 public String getTextEquivalent() { 3048 return this.textEquivalent == null ? null : this.textEquivalent.getValue(); 3049 } 3050 3051 /** 3052 * @param value A text equivalent of the action to be performed. This provides a 3053 * human-interpretable description of the action when the 3054 * definition is consumed by a system that might not be capable of 3055 * interpreting it dynamically. 3056 */ 3057 public PlanDefinitionActionComponent setTextEquivalent(String value) { 3058 if (Utilities.noString(value)) 3059 this.textEquivalent = null; 3060 else { 3061 if (this.textEquivalent == null) 3062 this.textEquivalent = new StringType(); 3063 this.textEquivalent.setValue(value); 3064 } 3065 return this; 3066 } 3067 3068 /** 3069 * @return {@link #priority} (Indicates how quickly the action should be 3070 * addressed with respect to other actions.). This is the underlying 3071 * object with id, value and extensions. The accessor "getPriority" 3072 * gives direct access to the value 3073 */ 3074 public Enumeration<RequestPriority> getPriorityElement() { 3075 if (this.priority == null) 3076 if (Configuration.errorOnAutoCreate()) 3077 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.priority"); 3078 else if (Configuration.doAutoCreate()) 3079 this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); // bb 3080 return this.priority; 3081 } 3082 3083 public boolean hasPriorityElement() { 3084 return this.priority != null && !this.priority.isEmpty(); 3085 } 3086 3087 public boolean hasPriority() { 3088 return this.priority != null && !this.priority.isEmpty(); 3089 } 3090 3091 /** 3092 * @param value {@link #priority} (Indicates how quickly the action should be 3093 * addressed with respect to other actions.). This is the 3094 * underlying object with id, value and extensions. The accessor 3095 * "getPriority" gives direct access to the value 3096 */ 3097 public PlanDefinitionActionComponent setPriorityElement(Enumeration<RequestPriority> value) { 3098 this.priority = value; 3099 return this; 3100 } 3101 3102 /** 3103 * @return Indicates how quickly the action should be addressed with respect to 3104 * other actions. 3105 */ 3106 public RequestPriority getPriority() { 3107 return this.priority == null ? null : this.priority.getValue(); 3108 } 3109 3110 /** 3111 * @param value Indicates how quickly the action should be addressed with 3112 * respect to other actions. 3113 */ 3114 public PlanDefinitionActionComponent setPriority(RequestPriority value) { 3115 if (value == null) 3116 this.priority = null; 3117 else { 3118 if (this.priority == null) 3119 this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); 3120 this.priority.setValue(value); 3121 } 3122 return this; 3123 } 3124 3125 /** 3126 * @return {@link #code} (A code that provides meaning for the action or action 3127 * group. For example, a section may have a LOINC code for the section 3128 * of a documentation template.) 3129 */ 3130 public List<CodeableConcept> getCode() { 3131 if (this.code == null) 3132 this.code = new ArrayList<CodeableConcept>(); 3133 return this.code; 3134 } 3135 3136 /** 3137 * @return Returns a reference to <code>this</code> for easy method chaining 3138 */ 3139 public PlanDefinitionActionComponent setCode(List<CodeableConcept> theCode) { 3140 this.code = theCode; 3141 return this; 3142 } 3143 3144 public boolean hasCode() { 3145 if (this.code == null) 3146 return false; 3147 for (CodeableConcept item : this.code) 3148 if (!item.isEmpty()) 3149 return true; 3150 return false; 3151 } 3152 3153 public CodeableConcept addCode() { // 3 3154 CodeableConcept t = new CodeableConcept(); 3155 if (this.code == null) 3156 this.code = new ArrayList<CodeableConcept>(); 3157 this.code.add(t); 3158 return t; 3159 } 3160 3161 public PlanDefinitionActionComponent addCode(CodeableConcept t) { // 3 3162 if (t == null) 3163 return this; 3164 if (this.code == null) 3165 this.code = new ArrayList<CodeableConcept>(); 3166 this.code.add(t); 3167 return this; 3168 } 3169 3170 /** 3171 * @return The first repetition of repeating field {@link #code}, creating it if 3172 * it does not already exist 3173 */ 3174 public CodeableConcept getCodeFirstRep() { 3175 if (getCode().isEmpty()) { 3176 addCode(); 3177 } 3178 return getCode().get(0); 3179 } 3180 3181 /** 3182 * @return {@link #reason} (A description of why this action is necessary or 3183 * appropriate.) 3184 */ 3185 public List<CodeableConcept> getReason() { 3186 if (this.reason == null) 3187 this.reason = new ArrayList<CodeableConcept>(); 3188 return this.reason; 3189 } 3190 3191 /** 3192 * @return Returns a reference to <code>this</code> for easy method chaining 3193 */ 3194 public PlanDefinitionActionComponent setReason(List<CodeableConcept> theReason) { 3195 this.reason = theReason; 3196 return this; 3197 } 3198 3199 public boolean hasReason() { 3200 if (this.reason == null) 3201 return false; 3202 for (CodeableConcept item : this.reason) 3203 if (!item.isEmpty()) 3204 return true; 3205 return false; 3206 } 3207 3208 public CodeableConcept addReason() { // 3 3209 CodeableConcept t = new CodeableConcept(); 3210 if (this.reason == null) 3211 this.reason = new ArrayList<CodeableConcept>(); 3212 this.reason.add(t); 3213 return t; 3214 } 3215 3216 public PlanDefinitionActionComponent addReason(CodeableConcept t) { // 3 3217 if (t == null) 3218 return this; 3219 if (this.reason == null) 3220 this.reason = new ArrayList<CodeableConcept>(); 3221 this.reason.add(t); 3222 return this; 3223 } 3224 3225 /** 3226 * @return The first repetition of repeating field {@link #reason}, creating it 3227 * if it does not already exist 3228 */ 3229 public CodeableConcept getReasonFirstRep() { 3230 if (getReason().isEmpty()) { 3231 addReason(); 3232 } 3233 return getReason().get(0); 3234 } 3235 3236 /** 3237 * @return {@link #documentation} (Didactic or other informational resources 3238 * associated with the action that can be provided to the CDS recipient. 3239 * Information resources can include inline text commentary and links to 3240 * web resources.) 3241 */ 3242 public List<RelatedArtifact> getDocumentation() { 3243 if (this.documentation == null) 3244 this.documentation = new ArrayList<RelatedArtifact>(); 3245 return this.documentation; 3246 } 3247 3248 /** 3249 * @return Returns a reference to <code>this</code> for easy method chaining 3250 */ 3251 public PlanDefinitionActionComponent setDocumentation(List<RelatedArtifact> theDocumentation) { 3252 this.documentation = theDocumentation; 3253 return this; 3254 } 3255 3256 public boolean hasDocumentation() { 3257 if (this.documentation == null) 3258 return false; 3259 for (RelatedArtifact item : this.documentation) 3260 if (!item.isEmpty()) 3261 return true; 3262 return false; 3263 } 3264 3265 public RelatedArtifact addDocumentation() { // 3 3266 RelatedArtifact t = new RelatedArtifact(); 3267 if (this.documentation == null) 3268 this.documentation = new ArrayList<RelatedArtifact>(); 3269 this.documentation.add(t); 3270 return t; 3271 } 3272 3273 public PlanDefinitionActionComponent addDocumentation(RelatedArtifact t) { // 3 3274 if (t == null) 3275 return this; 3276 if (this.documentation == null) 3277 this.documentation = new ArrayList<RelatedArtifact>(); 3278 this.documentation.add(t); 3279 return this; 3280 } 3281 3282 /** 3283 * @return The first repetition of repeating field {@link #documentation}, 3284 * creating it if it does not already exist 3285 */ 3286 public RelatedArtifact getDocumentationFirstRep() { 3287 if (getDocumentation().isEmpty()) { 3288 addDocumentation(); 3289 } 3290 return getDocumentation().get(0); 3291 } 3292 3293 /** 3294 * @return {@link #goalId} (Identifies goals that this action supports. The 3295 * reference must be to a goal element defined within this plan 3296 * definition.) 3297 */ 3298 public List<IdType> getGoalId() { 3299 if (this.goalId == null) 3300 this.goalId = new ArrayList<IdType>(); 3301 return this.goalId; 3302 } 3303 3304 /** 3305 * @return Returns a reference to <code>this</code> for easy method chaining 3306 */ 3307 public PlanDefinitionActionComponent setGoalId(List<IdType> theGoalId) { 3308 this.goalId = theGoalId; 3309 return this; 3310 } 3311 3312 public boolean hasGoalId() { 3313 if (this.goalId == null) 3314 return false; 3315 for (IdType item : this.goalId) 3316 if (!item.isEmpty()) 3317 return true; 3318 return false; 3319 } 3320 3321 /** 3322 * @return {@link #goalId} (Identifies goals that this action supports. The 3323 * reference must be to a goal element defined within this plan 3324 * definition.) 3325 */ 3326 public IdType addGoalIdElement() {// 2 3327 IdType t = new IdType(); 3328 if (this.goalId == null) 3329 this.goalId = new ArrayList<IdType>(); 3330 this.goalId.add(t); 3331 return t; 3332 } 3333 3334 /** 3335 * @param value {@link #goalId} (Identifies goals that this action supports. The 3336 * reference must be to a goal element defined within this plan 3337 * definition.) 3338 */ 3339 public PlanDefinitionActionComponent addGoalId(String value) { // 1 3340 IdType t = new IdType(); 3341 t.setValue(value); 3342 if (this.goalId == null) 3343 this.goalId = new ArrayList<IdType>(); 3344 this.goalId.add(t); 3345 return this; 3346 } 3347 3348 /** 3349 * @param value {@link #goalId} (Identifies goals that this action supports. The 3350 * reference must be to a goal element defined within this plan 3351 * definition.) 3352 */ 3353 public boolean hasGoalId(String value) { 3354 if (this.goalId == null) 3355 return false; 3356 for (IdType v : this.goalId) 3357 if (v.getValue().equals(value)) // id 3358 return true; 3359 return false; 3360 } 3361 3362 /** 3363 * @return {@link #subject} (A code or group definition that describes the 3364 * intended subject of the action and its children, if any.) 3365 */ 3366 public Type getSubject() { 3367 return this.subject; 3368 } 3369 3370 /** 3371 * @return {@link #subject} (A code or group definition that describes the 3372 * intended subject of the action and its children, if any.) 3373 */ 3374 public CodeableConcept getSubjectCodeableConcept() throws FHIRException { 3375 if (this.subject == null) 3376 this.subject = new CodeableConcept(); 3377 if (!(this.subject instanceof CodeableConcept)) 3378 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but " 3379 + this.subject.getClass().getName() + " was encountered"); 3380 return (CodeableConcept) this.subject; 3381 } 3382 3383 public boolean hasSubjectCodeableConcept() { 3384 return this != null && this.subject instanceof CodeableConcept; 3385 } 3386 3387 /** 3388 * @return {@link #subject} (A code or group definition that describes the 3389 * intended subject of the action and its children, if any.) 3390 */ 3391 public Reference getSubjectReference() throws FHIRException { 3392 if (this.subject == null) 3393 this.subject = new Reference(); 3394 if (!(this.subject instanceof Reference)) 3395 throw new FHIRException("Type mismatch: the type Reference was expected, but " 3396 + this.subject.getClass().getName() + " was encountered"); 3397 return (Reference) this.subject; 3398 } 3399 3400 public boolean hasSubjectReference() { 3401 return this != null && this.subject instanceof Reference; 3402 } 3403 3404 public boolean hasSubject() { 3405 return this.subject != null && !this.subject.isEmpty(); 3406 } 3407 3408 /** 3409 * @param value {@link #subject} (A code or group definition that describes the 3410 * intended subject of the action and its children, if any.) 3411 */ 3412 public PlanDefinitionActionComponent setSubject(Type value) { 3413 if (value != null && !(value instanceof CodeableConcept || value instanceof Reference)) 3414 throw new Error("Not the right type for PlanDefinition.action.subject[x]: " + value.fhirType()); 3415 this.subject = value; 3416 return this; 3417 } 3418 3419 /** 3420 * @return {@link #trigger} (A description of when the action should be 3421 * triggered.) 3422 */ 3423 public List<TriggerDefinition> getTrigger() { 3424 if (this.trigger == null) 3425 this.trigger = new ArrayList<TriggerDefinition>(); 3426 return this.trigger; 3427 } 3428 3429 /** 3430 * @return Returns a reference to <code>this</code> for easy method chaining 3431 */ 3432 public PlanDefinitionActionComponent setTrigger(List<TriggerDefinition> theTrigger) { 3433 this.trigger = theTrigger; 3434 return this; 3435 } 3436 3437 public boolean hasTrigger() { 3438 if (this.trigger == null) 3439 return false; 3440 for (TriggerDefinition item : this.trigger) 3441 if (!item.isEmpty()) 3442 return true; 3443 return false; 3444 } 3445 3446 public TriggerDefinition addTrigger() { // 3 3447 TriggerDefinition t = new TriggerDefinition(); 3448 if (this.trigger == null) 3449 this.trigger = new ArrayList<TriggerDefinition>(); 3450 this.trigger.add(t); 3451 return t; 3452 } 3453 3454 public PlanDefinitionActionComponent addTrigger(TriggerDefinition t) { // 3 3455 if (t == null) 3456 return this; 3457 if (this.trigger == null) 3458 this.trigger = new ArrayList<TriggerDefinition>(); 3459 this.trigger.add(t); 3460 return this; 3461 } 3462 3463 /** 3464 * @return The first repetition of repeating field {@link #trigger}, creating it 3465 * if it does not already exist 3466 */ 3467 public TriggerDefinition getTriggerFirstRep() { 3468 if (getTrigger().isEmpty()) { 3469 addTrigger(); 3470 } 3471 return getTrigger().get(0); 3472 } 3473 3474 /** 3475 * @return {@link #condition} (An expression that describes applicability 3476 * criteria or start/stop conditions for the action.) 3477 */ 3478 public List<PlanDefinitionActionConditionComponent> getCondition() { 3479 if (this.condition == null) 3480 this.condition = new ArrayList<PlanDefinitionActionConditionComponent>(); 3481 return this.condition; 3482 } 3483 3484 /** 3485 * @return Returns a reference to <code>this</code> for easy method chaining 3486 */ 3487 public PlanDefinitionActionComponent setCondition(List<PlanDefinitionActionConditionComponent> theCondition) { 3488 this.condition = theCondition; 3489 return this; 3490 } 3491 3492 public boolean hasCondition() { 3493 if (this.condition == null) 3494 return false; 3495 for (PlanDefinitionActionConditionComponent item : this.condition) 3496 if (!item.isEmpty()) 3497 return true; 3498 return false; 3499 } 3500 3501 public PlanDefinitionActionConditionComponent addCondition() { // 3 3502 PlanDefinitionActionConditionComponent t = new PlanDefinitionActionConditionComponent(); 3503 if (this.condition == null) 3504 this.condition = new ArrayList<PlanDefinitionActionConditionComponent>(); 3505 this.condition.add(t); 3506 return t; 3507 } 3508 3509 public PlanDefinitionActionComponent addCondition(PlanDefinitionActionConditionComponent t) { // 3 3510 if (t == null) 3511 return this; 3512 if (this.condition == null) 3513 this.condition = new ArrayList<PlanDefinitionActionConditionComponent>(); 3514 this.condition.add(t); 3515 return this; 3516 } 3517 3518 /** 3519 * @return The first repetition of repeating field {@link #condition}, creating 3520 * it if it does not already exist 3521 */ 3522 public PlanDefinitionActionConditionComponent getConditionFirstRep() { 3523 if (getCondition().isEmpty()) { 3524 addCondition(); 3525 } 3526 return getCondition().get(0); 3527 } 3528 3529 /** 3530 * @return {@link #input} (Defines input data requirements for the action.) 3531 */ 3532 public List<DataRequirement> getInput() { 3533 if (this.input == null) 3534 this.input = new ArrayList<DataRequirement>(); 3535 return this.input; 3536 } 3537 3538 /** 3539 * @return Returns a reference to <code>this</code> for easy method chaining 3540 */ 3541 public PlanDefinitionActionComponent setInput(List<DataRequirement> theInput) { 3542 this.input = theInput; 3543 return this; 3544 } 3545 3546 public boolean hasInput() { 3547 if (this.input == null) 3548 return false; 3549 for (DataRequirement item : this.input) 3550 if (!item.isEmpty()) 3551 return true; 3552 return false; 3553 } 3554 3555 public DataRequirement addInput() { // 3 3556 DataRequirement t = new DataRequirement(); 3557 if (this.input == null) 3558 this.input = new ArrayList<DataRequirement>(); 3559 this.input.add(t); 3560 return t; 3561 } 3562 3563 public PlanDefinitionActionComponent addInput(DataRequirement t) { // 3 3564 if (t == null) 3565 return this; 3566 if (this.input == null) 3567 this.input = new ArrayList<DataRequirement>(); 3568 this.input.add(t); 3569 return this; 3570 } 3571 3572 /** 3573 * @return The first repetition of repeating field {@link #input}, creating it 3574 * if it does not already exist 3575 */ 3576 public DataRequirement getInputFirstRep() { 3577 if (getInput().isEmpty()) { 3578 addInput(); 3579 } 3580 return getInput().get(0); 3581 } 3582 3583 /** 3584 * @return {@link #output} (Defines the outputs of the action, if any.) 3585 */ 3586 public List<DataRequirement> getOutput() { 3587 if (this.output == null) 3588 this.output = new ArrayList<DataRequirement>(); 3589 return this.output; 3590 } 3591 3592 /** 3593 * @return Returns a reference to <code>this</code> for easy method chaining 3594 */ 3595 public PlanDefinitionActionComponent setOutput(List<DataRequirement> theOutput) { 3596 this.output = theOutput; 3597 return this; 3598 } 3599 3600 public boolean hasOutput() { 3601 if (this.output == null) 3602 return false; 3603 for (DataRequirement item : this.output) 3604 if (!item.isEmpty()) 3605 return true; 3606 return false; 3607 } 3608 3609 public DataRequirement addOutput() { // 3 3610 DataRequirement t = new DataRequirement(); 3611 if (this.output == null) 3612 this.output = new ArrayList<DataRequirement>(); 3613 this.output.add(t); 3614 return t; 3615 } 3616 3617 public PlanDefinitionActionComponent addOutput(DataRequirement t) { // 3 3618 if (t == null) 3619 return this; 3620 if (this.output == null) 3621 this.output = new ArrayList<DataRequirement>(); 3622 this.output.add(t); 3623 return this; 3624 } 3625 3626 /** 3627 * @return The first repetition of repeating field {@link #output}, creating it 3628 * if it does not already exist 3629 */ 3630 public DataRequirement getOutputFirstRep() { 3631 if (getOutput().isEmpty()) { 3632 addOutput(); 3633 } 3634 return getOutput().get(0); 3635 } 3636 3637 /** 3638 * @return {@link #relatedAction} (A relationship to another action such as 3639 * "before" or "30-60 minutes after start of".) 3640 */ 3641 public List<PlanDefinitionActionRelatedActionComponent> getRelatedAction() { 3642 if (this.relatedAction == null) 3643 this.relatedAction = new ArrayList<PlanDefinitionActionRelatedActionComponent>(); 3644 return this.relatedAction; 3645 } 3646 3647 /** 3648 * @return Returns a reference to <code>this</code> for easy method chaining 3649 */ 3650 public PlanDefinitionActionComponent setRelatedAction( 3651 List<PlanDefinitionActionRelatedActionComponent> theRelatedAction) { 3652 this.relatedAction = theRelatedAction; 3653 return this; 3654 } 3655 3656 public boolean hasRelatedAction() { 3657 if (this.relatedAction == null) 3658 return false; 3659 for (PlanDefinitionActionRelatedActionComponent item : this.relatedAction) 3660 if (!item.isEmpty()) 3661 return true; 3662 return false; 3663 } 3664 3665 public PlanDefinitionActionRelatedActionComponent addRelatedAction() { // 3 3666 PlanDefinitionActionRelatedActionComponent t = new PlanDefinitionActionRelatedActionComponent(); 3667 if (this.relatedAction == null) 3668 this.relatedAction = new ArrayList<PlanDefinitionActionRelatedActionComponent>(); 3669 this.relatedAction.add(t); 3670 return t; 3671 } 3672 3673 public PlanDefinitionActionComponent addRelatedAction(PlanDefinitionActionRelatedActionComponent t) { // 3 3674 if (t == null) 3675 return this; 3676 if (this.relatedAction == null) 3677 this.relatedAction = new ArrayList<PlanDefinitionActionRelatedActionComponent>(); 3678 this.relatedAction.add(t); 3679 return this; 3680 } 3681 3682 /** 3683 * @return The first repetition of repeating field {@link #relatedAction}, 3684 * creating it if it does not already exist 3685 */ 3686 public PlanDefinitionActionRelatedActionComponent getRelatedActionFirstRep() { 3687 if (getRelatedAction().isEmpty()) { 3688 addRelatedAction(); 3689 } 3690 return getRelatedAction().get(0); 3691 } 3692 3693 /** 3694 * @return {@link #timing} (An optional value describing when the action should 3695 * be performed.) 3696 */ 3697 public Type getTiming() { 3698 return this.timing; 3699 } 3700 3701 /** 3702 * @return {@link #timing} (An optional value describing when the action should 3703 * be performed.) 3704 */ 3705 public DateTimeType getTimingDateTimeType() throws FHIRException { 3706 if (this.timing == null) 3707 this.timing = new DateTimeType(); 3708 if (!(this.timing instanceof DateTimeType)) 3709 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but " 3710 + this.timing.getClass().getName() + " was encountered"); 3711 return (DateTimeType) this.timing; 3712 } 3713 3714 public boolean hasTimingDateTimeType() { 3715 return this != null && this.timing instanceof DateTimeType; 3716 } 3717 3718 /** 3719 * @return {@link #timing} (An optional value describing when the action should 3720 * be performed.) 3721 */ 3722 public Age getTimingAge() throws FHIRException { 3723 if (this.timing == null) 3724 this.timing = new Age(); 3725 if (!(this.timing instanceof Age)) 3726 throw new FHIRException( 3727 "Type mismatch: the type Age was expected, but " + this.timing.getClass().getName() + " was encountered"); 3728 return (Age) this.timing; 3729 } 3730 3731 public boolean hasTimingAge() { 3732 return this != null && this.timing instanceof Age; 3733 } 3734 3735 /** 3736 * @return {@link #timing} (An optional value describing when the action should 3737 * be performed.) 3738 */ 3739 public Period getTimingPeriod() throws FHIRException { 3740 if (this.timing == null) 3741 this.timing = new Period(); 3742 if (!(this.timing instanceof Period)) 3743 throw new FHIRException("Type mismatch: the type Period was expected, but " + this.timing.getClass().getName() 3744 + " was encountered"); 3745 return (Period) this.timing; 3746 } 3747 3748 public boolean hasTimingPeriod() { 3749 return this != null && this.timing instanceof Period; 3750 } 3751 3752 /** 3753 * @return {@link #timing} (An optional value describing when the action should 3754 * be performed.) 3755 */ 3756 public Duration getTimingDuration() throws FHIRException { 3757 if (this.timing == null) 3758 this.timing = new Duration(); 3759 if (!(this.timing instanceof Duration)) 3760 throw new FHIRException("Type mismatch: the type Duration was expected, but " + this.timing.getClass().getName() 3761 + " was encountered"); 3762 return (Duration) this.timing; 3763 } 3764 3765 public boolean hasTimingDuration() { 3766 return this != null && this.timing instanceof Duration; 3767 } 3768 3769 /** 3770 * @return {@link #timing} (An optional value describing when the action should 3771 * be performed.) 3772 */ 3773 public Range getTimingRange() throws FHIRException { 3774 if (this.timing == null) 3775 this.timing = new Range(); 3776 if (!(this.timing instanceof Range)) 3777 throw new FHIRException( 3778 "Type mismatch: the type Range was expected, but " + this.timing.getClass().getName() + " was encountered"); 3779 return (Range) this.timing; 3780 } 3781 3782 public boolean hasTimingRange() { 3783 return this != null && this.timing instanceof Range; 3784 } 3785 3786 /** 3787 * @return {@link #timing} (An optional value describing when the action should 3788 * be performed.) 3789 */ 3790 public Timing getTimingTiming() throws FHIRException { 3791 if (this.timing == null) 3792 this.timing = new Timing(); 3793 if (!(this.timing instanceof Timing)) 3794 throw new FHIRException("Type mismatch: the type Timing was expected, but " + this.timing.getClass().getName() 3795 + " was encountered"); 3796 return (Timing) this.timing; 3797 } 3798 3799 public boolean hasTimingTiming() { 3800 return this != null && this.timing instanceof Timing; 3801 } 3802 3803 public boolean hasTiming() { 3804 return this.timing != null && !this.timing.isEmpty(); 3805 } 3806 3807 /** 3808 * @param value {@link #timing} (An optional value describing when the action 3809 * should be performed.) 3810 */ 3811 public PlanDefinitionActionComponent setTiming(Type value) { 3812 if (value != null && !(value instanceof DateTimeType || value instanceof Age || value instanceof Period 3813 || value instanceof Duration || value instanceof Range || value instanceof Timing)) 3814 throw new Error("Not the right type for PlanDefinition.action.timing[x]: " + value.fhirType()); 3815 this.timing = value; 3816 return this; 3817 } 3818 3819 /** 3820 * @return {@link #participant} (Indicates who should participate in performing 3821 * the action described.) 3822 */ 3823 public List<PlanDefinitionActionParticipantComponent> getParticipant() { 3824 if (this.participant == null) 3825 this.participant = new ArrayList<PlanDefinitionActionParticipantComponent>(); 3826 return this.participant; 3827 } 3828 3829 /** 3830 * @return Returns a reference to <code>this</code> for easy method chaining 3831 */ 3832 public PlanDefinitionActionComponent setParticipant(List<PlanDefinitionActionParticipantComponent> theParticipant) { 3833 this.participant = theParticipant; 3834 return this; 3835 } 3836 3837 public boolean hasParticipant() { 3838 if (this.participant == null) 3839 return false; 3840 for (PlanDefinitionActionParticipantComponent item : this.participant) 3841 if (!item.isEmpty()) 3842 return true; 3843 return false; 3844 } 3845 3846 public PlanDefinitionActionParticipantComponent addParticipant() { // 3 3847 PlanDefinitionActionParticipantComponent t = new PlanDefinitionActionParticipantComponent(); 3848 if (this.participant == null) 3849 this.participant = new ArrayList<PlanDefinitionActionParticipantComponent>(); 3850 this.participant.add(t); 3851 return t; 3852 } 3853 3854 public PlanDefinitionActionComponent addParticipant(PlanDefinitionActionParticipantComponent t) { // 3 3855 if (t == null) 3856 return this; 3857 if (this.participant == null) 3858 this.participant = new ArrayList<PlanDefinitionActionParticipantComponent>(); 3859 this.participant.add(t); 3860 return this; 3861 } 3862 3863 /** 3864 * @return The first repetition of repeating field {@link #participant}, 3865 * creating it if it does not already exist 3866 */ 3867 public PlanDefinitionActionParticipantComponent getParticipantFirstRep() { 3868 if (getParticipant().isEmpty()) { 3869 addParticipant(); 3870 } 3871 return getParticipant().get(0); 3872 } 3873 3874 /** 3875 * @return {@link #type} (The type of action to perform (create, update, 3876 * remove).) 3877 */ 3878 public CodeableConcept getType() { 3879 if (this.type == null) 3880 if (Configuration.errorOnAutoCreate()) 3881 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.type"); 3882 else if (Configuration.doAutoCreate()) 3883 this.type = new CodeableConcept(); // cc 3884 return this.type; 3885 } 3886 3887 public boolean hasType() { 3888 return this.type != null && !this.type.isEmpty(); 3889 } 3890 3891 /** 3892 * @param value {@link #type} (The type of action to perform (create, update, 3893 * remove).) 3894 */ 3895 public PlanDefinitionActionComponent setType(CodeableConcept value) { 3896 this.type = value; 3897 return this; 3898 } 3899 3900 /** 3901 * @return {@link #groupingBehavior} (Defines the grouping behavior for the 3902 * action and its children.). This is the underlying object with id, 3903 * value and extensions. The accessor "getGroupingBehavior" gives direct 3904 * access to the value 3905 */ 3906 public Enumeration<ActionGroupingBehavior> getGroupingBehaviorElement() { 3907 if (this.groupingBehavior == null) 3908 if (Configuration.errorOnAutoCreate()) 3909 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.groupingBehavior"); 3910 else if (Configuration.doAutoCreate()) 3911 this.groupingBehavior = new Enumeration<ActionGroupingBehavior>(new ActionGroupingBehaviorEnumFactory()); // bb 3912 return this.groupingBehavior; 3913 } 3914 3915 public boolean hasGroupingBehaviorElement() { 3916 return this.groupingBehavior != null && !this.groupingBehavior.isEmpty(); 3917 } 3918 3919 public boolean hasGroupingBehavior() { 3920 return this.groupingBehavior != null && !this.groupingBehavior.isEmpty(); 3921 } 3922 3923 /** 3924 * @param value {@link #groupingBehavior} (Defines the grouping behavior for the 3925 * action and its children.). This is the underlying object with 3926 * id, value and extensions. The accessor "getGroupingBehavior" 3927 * gives direct access to the value 3928 */ 3929 public PlanDefinitionActionComponent setGroupingBehaviorElement(Enumeration<ActionGroupingBehavior> value) { 3930 this.groupingBehavior = value; 3931 return this; 3932 } 3933 3934 /** 3935 * @return Defines the grouping behavior for the action and its children. 3936 */ 3937 public ActionGroupingBehavior getGroupingBehavior() { 3938 return this.groupingBehavior == null ? null : this.groupingBehavior.getValue(); 3939 } 3940 3941 /** 3942 * @param value Defines the grouping behavior for the action and its children. 3943 */ 3944 public PlanDefinitionActionComponent setGroupingBehavior(ActionGroupingBehavior value) { 3945 if (value == null) 3946 this.groupingBehavior = null; 3947 else { 3948 if (this.groupingBehavior == null) 3949 this.groupingBehavior = new Enumeration<ActionGroupingBehavior>(new ActionGroupingBehaviorEnumFactory()); 3950 this.groupingBehavior.setValue(value); 3951 } 3952 return this; 3953 } 3954 3955 /** 3956 * @return {@link #selectionBehavior} (Defines the selection behavior for the 3957 * action and its children.). This is the underlying object with id, 3958 * value and extensions. The accessor "getSelectionBehavior" gives 3959 * direct access to the value 3960 */ 3961 public Enumeration<ActionSelectionBehavior> getSelectionBehaviorElement() { 3962 if (this.selectionBehavior == null) 3963 if (Configuration.errorOnAutoCreate()) 3964 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.selectionBehavior"); 3965 else if (Configuration.doAutoCreate()) 3966 this.selectionBehavior = new Enumeration<ActionSelectionBehavior>(new ActionSelectionBehaviorEnumFactory()); // bb 3967 return this.selectionBehavior; 3968 } 3969 3970 public boolean hasSelectionBehaviorElement() { 3971 return this.selectionBehavior != null && !this.selectionBehavior.isEmpty(); 3972 } 3973 3974 public boolean hasSelectionBehavior() { 3975 return this.selectionBehavior != null && !this.selectionBehavior.isEmpty(); 3976 } 3977 3978 /** 3979 * @param value {@link #selectionBehavior} (Defines the selection behavior for 3980 * the action and its children.). This is the underlying object 3981 * with id, value and extensions. The accessor 3982 * "getSelectionBehavior" gives direct access to the value 3983 */ 3984 public PlanDefinitionActionComponent setSelectionBehaviorElement(Enumeration<ActionSelectionBehavior> value) { 3985 this.selectionBehavior = value; 3986 return this; 3987 } 3988 3989 /** 3990 * @return Defines the selection behavior for the action and its children. 3991 */ 3992 public ActionSelectionBehavior getSelectionBehavior() { 3993 return this.selectionBehavior == null ? null : this.selectionBehavior.getValue(); 3994 } 3995 3996 /** 3997 * @param value Defines the selection behavior for the action and its children. 3998 */ 3999 public PlanDefinitionActionComponent setSelectionBehavior(ActionSelectionBehavior value) { 4000 if (value == null) 4001 this.selectionBehavior = null; 4002 else { 4003 if (this.selectionBehavior == null) 4004 this.selectionBehavior = new Enumeration<ActionSelectionBehavior>(new ActionSelectionBehaviorEnumFactory()); 4005 this.selectionBehavior.setValue(value); 4006 } 4007 return this; 4008 } 4009 4010 /** 4011 * @return {@link #requiredBehavior} (Defines the required behavior for the 4012 * action.). This is the underlying object with id, value and 4013 * extensions. The accessor "getRequiredBehavior" gives direct access to 4014 * the value 4015 */ 4016 public Enumeration<ActionRequiredBehavior> getRequiredBehaviorElement() { 4017 if (this.requiredBehavior == null) 4018 if (Configuration.errorOnAutoCreate()) 4019 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.requiredBehavior"); 4020 else if (Configuration.doAutoCreate()) 4021 this.requiredBehavior = new Enumeration<ActionRequiredBehavior>(new ActionRequiredBehaviorEnumFactory()); // bb 4022 return this.requiredBehavior; 4023 } 4024 4025 public boolean hasRequiredBehaviorElement() { 4026 return this.requiredBehavior != null && !this.requiredBehavior.isEmpty(); 4027 } 4028 4029 public boolean hasRequiredBehavior() { 4030 return this.requiredBehavior != null && !this.requiredBehavior.isEmpty(); 4031 } 4032 4033 /** 4034 * @param value {@link #requiredBehavior} (Defines the required behavior for the 4035 * action.). This is the underlying object with id, value and 4036 * extensions. The accessor "getRequiredBehavior" gives direct 4037 * access to the value 4038 */ 4039 public PlanDefinitionActionComponent setRequiredBehaviorElement(Enumeration<ActionRequiredBehavior> value) { 4040 this.requiredBehavior = value; 4041 return this; 4042 } 4043 4044 /** 4045 * @return Defines the required behavior for the action. 4046 */ 4047 public ActionRequiredBehavior getRequiredBehavior() { 4048 return this.requiredBehavior == null ? null : this.requiredBehavior.getValue(); 4049 } 4050 4051 /** 4052 * @param value Defines the required behavior for the action. 4053 */ 4054 public PlanDefinitionActionComponent setRequiredBehavior(ActionRequiredBehavior value) { 4055 if (value == null) 4056 this.requiredBehavior = null; 4057 else { 4058 if (this.requiredBehavior == null) 4059 this.requiredBehavior = new Enumeration<ActionRequiredBehavior>(new ActionRequiredBehaviorEnumFactory()); 4060 this.requiredBehavior.setValue(value); 4061 } 4062 return this; 4063 } 4064 4065 /** 4066 * @return {@link #precheckBehavior} (Defines whether the action should usually 4067 * be preselected.). This is the underlying object with id, value and 4068 * extensions. The accessor "getPrecheckBehavior" gives direct access to 4069 * the value 4070 */ 4071 public Enumeration<ActionPrecheckBehavior> getPrecheckBehaviorElement() { 4072 if (this.precheckBehavior == null) 4073 if (Configuration.errorOnAutoCreate()) 4074 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.precheckBehavior"); 4075 else if (Configuration.doAutoCreate()) 4076 this.precheckBehavior = new Enumeration<ActionPrecheckBehavior>(new ActionPrecheckBehaviorEnumFactory()); // bb 4077 return this.precheckBehavior; 4078 } 4079 4080 public boolean hasPrecheckBehaviorElement() { 4081 return this.precheckBehavior != null && !this.precheckBehavior.isEmpty(); 4082 } 4083 4084 public boolean hasPrecheckBehavior() { 4085 return this.precheckBehavior != null && !this.precheckBehavior.isEmpty(); 4086 } 4087 4088 /** 4089 * @param value {@link #precheckBehavior} (Defines whether the action should 4090 * usually be preselected.). This is the underlying object with id, 4091 * value and extensions. The accessor "getPrecheckBehavior" gives 4092 * direct access to the value 4093 */ 4094 public PlanDefinitionActionComponent setPrecheckBehaviorElement(Enumeration<ActionPrecheckBehavior> value) { 4095 this.precheckBehavior = value; 4096 return this; 4097 } 4098 4099 /** 4100 * @return Defines whether the action should usually be preselected. 4101 */ 4102 public ActionPrecheckBehavior getPrecheckBehavior() { 4103 return this.precheckBehavior == null ? null : this.precheckBehavior.getValue(); 4104 } 4105 4106 /** 4107 * @param value Defines whether the action should usually be preselected. 4108 */ 4109 public PlanDefinitionActionComponent setPrecheckBehavior(ActionPrecheckBehavior value) { 4110 if (value == null) 4111 this.precheckBehavior = null; 4112 else { 4113 if (this.precheckBehavior == null) 4114 this.precheckBehavior = new Enumeration<ActionPrecheckBehavior>(new ActionPrecheckBehaviorEnumFactory()); 4115 this.precheckBehavior.setValue(value); 4116 } 4117 return this; 4118 } 4119 4120 /** 4121 * @return {@link #cardinalityBehavior} (Defines whether the action can be 4122 * selected multiple times.). This is the underlying object with id, 4123 * value and extensions. The accessor "getCardinalityBehavior" gives 4124 * direct access to the value 4125 */ 4126 public Enumeration<ActionCardinalityBehavior> getCardinalityBehaviorElement() { 4127 if (this.cardinalityBehavior == null) 4128 if (Configuration.errorOnAutoCreate()) 4129 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.cardinalityBehavior"); 4130 else if (Configuration.doAutoCreate()) 4131 this.cardinalityBehavior = new Enumeration<ActionCardinalityBehavior>( 4132 new ActionCardinalityBehaviorEnumFactory()); // bb 4133 return this.cardinalityBehavior; 4134 } 4135 4136 public boolean hasCardinalityBehaviorElement() { 4137 return this.cardinalityBehavior != null && !this.cardinalityBehavior.isEmpty(); 4138 } 4139 4140 public boolean hasCardinalityBehavior() { 4141 return this.cardinalityBehavior != null && !this.cardinalityBehavior.isEmpty(); 4142 } 4143 4144 /** 4145 * @param value {@link #cardinalityBehavior} (Defines whether the action can be 4146 * selected multiple times.). This is the underlying object with 4147 * id, value and extensions. The accessor "getCardinalityBehavior" 4148 * gives direct access to the value 4149 */ 4150 public PlanDefinitionActionComponent setCardinalityBehaviorElement(Enumeration<ActionCardinalityBehavior> value) { 4151 this.cardinalityBehavior = value; 4152 return this; 4153 } 4154 4155 /** 4156 * @return Defines whether the action can be selected multiple times. 4157 */ 4158 public ActionCardinalityBehavior getCardinalityBehavior() { 4159 return this.cardinalityBehavior == null ? null : this.cardinalityBehavior.getValue(); 4160 } 4161 4162 /** 4163 * @param value Defines whether the action can be selected multiple times. 4164 */ 4165 public PlanDefinitionActionComponent setCardinalityBehavior(ActionCardinalityBehavior value) { 4166 if (value == null) 4167 this.cardinalityBehavior = null; 4168 else { 4169 if (this.cardinalityBehavior == null) 4170 this.cardinalityBehavior = new Enumeration<ActionCardinalityBehavior>( 4171 new ActionCardinalityBehaviorEnumFactory()); 4172 this.cardinalityBehavior.setValue(value); 4173 } 4174 return this; 4175 } 4176 4177 /** 4178 * @return {@link #definition} (A reference to an ActivityDefinition that 4179 * describes the action to be taken in detail, or a PlanDefinition that 4180 * describes a series of actions to be taken.) 4181 */ 4182 public Type getDefinition() { 4183 return this.definition; 4184 } 4185 4186 /** 4187 * @return {@link #definition} (A reference to an ActivityDefinition that 4188 * describes the action to be taken in detail, or a PlanDefinition that 4189 * describes a series of actions to be taken.) 4190 */ 4191 public CanonicalType getDefinitionCanonicalType() throws FHIRException { 4192 if (this.definition == null) 4193 this.definition = new CanonicalType(); 4194 if (!(this.definition instanceof CanonicalType)) 4195 throw new FHIRException("Type mismatch: the type CanonicalType was expected, but " 4196 + this.definition.getClass().getName() + " was encountered"); 4197 return (CanonicalType) this.definition; 4198 } 4199 4200 public boolean hasDefinitionCanonicalType() { 4201 return this != null && this.definition instanceof CanonicalType; 4202 } 4203 4204 /** 4205 * @return {@link #definition} (A reference to an ActivityDefinition that 4206 * describes the action to be taken in detail, or a PlanDefinition that 4207 * describes a series of actions to be taken.) 4208 */ 4209 public UriType getDefinitionUriType() throws FHIRException { 4210 if (this.definition == null) 4211 this.definition = new UriType(); 4212 if (!(this.definition instanceof UriType)) 4213 throw new FHIRException("Type mismatch: the type UriType was expected, but " 4214 + this.definition.getClass().getName() + " was encountered"); 4215 return (UriType) this.definition; 4216 } 4217 4218 public boolean hasDefinitionUriType() { 4219 return this != null && this.definition instanceof UriType; 4220 } 4221 4222 public boolean hasDefinition() { 4223 return this.definition != null && !this.definition.isEmpty(); 4224 } 4225 4226 /** 4227 * @param value {@link #definition} (A reference to an ActivityDefinition that 4228 * describes the action to be taken in detail, or a PlanDefinition 4229 * that describes a series of actions to be taken.) 4230 */ 4231 public PlanDefinitionActionComponent setDefinition(Type value) { 4232 if (value != null && !(value instanceof CanonicalType || value instanceof UriType)) 4233 throw new Error("Not the right type for PlanDefinition.action.definition[x]: " + value.fhirType()); 4234 this.definition = value; 4235 return this; 4236 } 4237 4238 /** 4239 * @return {@link #transform} (A reference to a StructureMap resource that 4240 * defines a transform that can be executed to produce the intent 4241 * resource using the ActivityDefinition instance as the input.). This 4242 * is the underlying object with id, value and extensions. The accessor 4243 * "getTransform" gives direct access to the value 4244 */ 4245 public CanonicalType getTransformElement() { 4246 if (this.transform == null) 4247 if (Configuration.errorOnAutoCreate()) 4248 throw new Error("Attempt to auto-create PlanDefinitionActionComponent.transform"); 4249 else if (Configuration.doAutoCreate()) 4250 this.transform = new CanonicalType(); // bb 4251 return this.transform; 4252 } 4253 4254 public boolean hasTransformElement() { 4255 return this.transform != null && !this.transform.isEmpty(); 4256 } 4257 4258 public boolean hasTransform() { 4259 return this.transform != null && !this.transform.isEmpty(); 4260 } 4261 4262 /** 4263 * @param value {@link #transform} (A reference to a StructureMap resource that 4264 * defines a transform that can be executed to produce the intent 4265 * resource using the ActivityDefinition instance as the input.). 4266 * This is the underlying object with id, value and extensions. The 4267 * accessor "getTransform" gives direct access to the value 4268 */ 4269 public PlanDefinitionActionComponent setTransformElement(CanonicalType value) { 4270 this.transform = value; 4271 return this; 4272 } 4273 4274 /** 4275 * @return A reference to a StructureMap resource that defines a transform that 4276 * can be executed to produce the intent resource using the 4277 * ActivityDefinition instance as the input. 4278 */ 4279 public String getTransform() { 4280 return this.transform == null ? null : this.transform.getValue(); 4281 } 4282 4283 /** 4284 * @param value A reference to a StructureMap resource that defines a transform 4285 * that can be executed to produce the intent resource using the 4286 * ActivityDefinition instance as the input. 4287 */ 4288 public PlanDefinitionActionComponent setTransform(String value) { 4289 if (Utilities.noString(value)) 4290 this.transform = null; 4291 else { 4292 if (this.transform == null) 4293 this.transform = new CanonicalType(); 4294 this.transform.setValue(value); 4295 } 4296 return this; 4297 } 4298 4299 /** 4300 * @return {@link #dynamicValue} (Customizations that should be applied to the 4301 * statically defined resource. For example, if the dosage of a 4302 * medication must be computed based on the patient's weight, a 4303 * customization would be used to specify an expression that calculated 4304 * the weight, and the path on the resource that would contain the 4305 * result.) 4306 */ 4307 public List<PlanDefinitionActionDynamicValueComponent> getDynamicValue() { 4308 if (this.dynamicValue == null) 4309 this.dynamicValue = new ArrayList<PlanDefinitionActionDynamicValueComponent>(); 4310 return this.dynamicValue; 4311 } 4312 4313 /** 4314 * @return Returns a reference to <code>this</code> for easy method chaining 4315 */ 4316 public PlanDefinitionActionComponent setDynamicValue( 4317 List<PlanDefinitionActionDynamicValueComponent> theDynamicValue) { 4318 this.dynamicValue = theDynamicValue; 4319 return this; 4320 } 4321 4322 public boolean hasDynamicValue() { 4323 if (this.dynamicValue == null) 4324 return false; 4325 for (PlanDefinitionActionDynamicValueComponent item : this.dynamicValue) 4326 if (!item.isEmpty()) 4327 return true; 4328 return false; 4329 } 4330 4331 public PlanDefinitionActionDynamicValueComponent addDynamicValue() { // 3 4332 PlanDefinitionActionDynamicValueComponent t = new PlanDefinitionActionDynamicValueComponent(); 4333 if (this.dynamicValue == null) 4334 this.dynamicValue = new ArrayList<PlanDefinitionActionDynamicValueComponent>(); 4335 this.dynamicValue.add(t); 4336 return t; 4337 } 4338 4339 public PlanDefinitionActionComponent addDynamicValue(PlanDefinitionActionDynamicValueComponent t) { // 3 4340 if (t == null) 4341 return this; 4342 if (this.dynamicValue == null) 4343 this.dynamicValue = new ArrayList<PlanDefinitionActionDynamicValueComponent>(); 4344 this.dynamicValue.add(t); 4345 return this; 4346 } 4347 4348 /** 4349 * @return The first repetition of repeating field {@link #dynamicValue}, 4350 * creating it if it does not already exist 4351 */ 4352 public PlanDefinitionActionDynamicValueComponent getDynamicValueFirstRep() { 4353 if (getDynamicValue().isEmpty()) { 4354 addDynamicValue(); 4355 } 4356 return getDynamicValue().get(0); 4357 } 4358 4359 /** 4360 * @return {@link #action} (Sub actions that are contained within the action. 4361 * The behavior of this action determines the functionality of the 4362 * sub-actions. For example, a selection behavior of at-most-one 4363 * indicates that of the sub-actions, at most one may be chosen as part 4364 * of realizing the action definition.) 4365 */ 4366 public List<PlanDefinitionActionComponent> getAction() { 4367 if (this.action == null) 4368 this.action = new ArrayList<PlanDefinitionActionComponent>(); 4369 return this.action; 4370 } 4371 4372 /** 4373 * @return Returns a reference to <code>this</code> for easy method chaining 4374 */ 4375 public PlanDefinitionActionComponent setAction(List<PlanDefinitionActionComponent> theAction) { 4376 this.action = theAction; 4377 return this; 4378 } 4379 4380 public boolean hasAction() { 4381 if (this.action == null) 4382 return false; 4383 for (PlanDefinitionActionComponent item : this.action) 4384 if (!item.isEmpty()) 4385 return true; 4386 return false; 4387 } 4388 4389 public PlanDefinitionActionComponent addAction() { // 3 4390 PlanDefinitionActionComponent t = new PlanDefinitionActionComponent(); 4391 if (this.action == null) 4392 this.action = new ArrayList<PlanDefinitionActionComponent>(); 4393 this.action.add(t); 4394 return t; 4395 } 4396 4397 public PlanDefinitionActionComponent addAction(PlanDefinitionActionComponent t) { // 3 4398 if (t == null) 4399 return this; 4400 if (this.action == null) 4401 this.action = new ArrayList<PlanDefinitionActionComponent>(); 4402 this.action.add(t); 4403 return this; 4404 } 4405 4406 /** 4407 * @return The first repetition of repeating field {@link #action}, creating it 4408 * if it does not already exist 4409 */ 4410 public PlanDefinitionActionComponent getActionFirstRep() { 4411 if (getAction().isEmpty()) { 4412 addAction(); 4413 } 4414 return getAction().get(0); 4415 } 4416 4417 protected void listChildren(List<Property> children) { 4418 super.listChildren(children); 4419 children.add(new Property("prefix", "string", "A user-visible prefix for the action.", 0, 1, prefix)); 4420 children.add(new Property("title", "string", "The title of the action displayed to a user.", 0, 1, title)); 4421 children.add(new Property("description", "string", 4422 "A brief description of the action used to provide a summary to display to the user.", 0, 1, description)); 4423 children.add(new Property("textEquivalent", "string", 4424 "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that might not be capable of interpreting it dynamically.", 4425 0, 1, textEquivalent)); 4426 children.add(new Property("priority", "code", 4427 "Indicates how quickly the action should be addressed with respect to other actions.", 0, 1, priority)); 4428 children.add(new Property("code", "CodeableConcept", 4429 "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for the section of a documentation template.", 4430 0, java.lang.Integer.MAX_VALUE, code)); 4431 children.add(new Property("reason", "CodeableConcept", 4432 "A description of why this action is necessary or appropriate.", 0, java.lang.Integer.MAX_VALUE, reason)); 4433 children.add(new Property("documentation", "RelatedArtifact", 4434 "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.", 4435 0, java.lang.Integer.MAX_VALUE, documentation)); 4436 children.add(new Property("goalId", "id", 4437 "Identifies goals that this action supports. The reference must be to a goal element defined within this plan definition.", 4438 0, java.lang.Integer.MAX_VALUE, goalId)); 4439 children.add(new Property("subject[x]", "CodeableConcept|Reference(Group)", 4440 "A code or group definition that describes the intended subject of the action and its children, if any.", 0, 4441 1, subject)); 4442 children.add(new Property("trigger", "TriggerDefinition", "A description of when the action should be triggered.", 4443 0, java.lang.Integer.MAX_VALUE, trigger)); 4444 children.add(new Property("condition", "", 4445 "An expression that describes applicability criteria or start/stop conditions for the action.", 0, 4446 java.lang.Integer.MAX_VALUE, condition)); 4447 children.add(new Property("input", "DataRequirement", "Defines input data requirements for the action.", 0, 4448 java.lang.Integer.MAX_VALUE, input)); 4449 children.add(new Property("output", "DataRequirement", "Defines the outputs of the action, if any.", 0, 4450 java.lang.Integer.MAX_VALUE, output)); 4451 children.add(new Property("relatedAction", "", 4452 "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".", 0, 4453 java.lang.Integer.MAX_VALUE, relatedAction)); 4454 children.add(new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4455 "An optional value describing when the action should be performed.", 0, 1, timing)); 4456 children 4457 .add(new Property("participant", "", "Indicates who should participate in performing the action described.", 4458 0, java.lang.Integer.MAX_VALUE, participant)); 4459 children.add(new Property("type", "CodeableConcept", "The type of action to perform (create, update, remove).", 0, 4460 1, type)); 4461 children.add(new Property("groupingBehavior", "code", 4462 "Defines the grouping behavior for the action and its children.", 0, 1, groupingBehavior)); 4463 children.add(new Property("selectionBehavior", "code", 4464 "Defines the selection behavior for the action and its children.", 0, 1, selectionBehavior)); 4465 children.add(new Property("requiredBehavior", "code", "Defines the required behavior for the action.", 0, 1, 4466 requiredBehavior)); 4467 children.add(new Property("precheckBehavior", "code", "Defines whether the action should usually be preselected.", 4468 0, 1, precheckBehavior)); 4469 children.add(new Property("cardinalityBehavior", "code", 4470 "Defines whether the action can be selected multiple times.", 0, 1, cardinalityBehavior)); 4471 children.add(new Property("definition[x]", "canonical(ActivityDefinition|PlanDefinition|Questionnaire)|uri", 4472 "A reference to an ActivityDefinition that describes the action to be taken in detail, or a PlanDefinition that describes a series of actions to be taken.", 4473 0, 1, definition)); 4474 children.add(new Property("transform", "canonical(StructureMap)", 4475 "A reference to a StructureMap resource that defines a transform that can be executed to produce the intent resource using the ActivityDefinition instance as the input.", 4476 0, 1, transform)); 4477 children.add(new Property("dynamicValue", "", 4478 "Customizations that should be applied to the statically defined resource. For example, if the dosage of a medication must be computed based on the patient's weight, a customization would be used to specify an expression that calculated the weight, and the path on the resource that would contain the result.", 4479 0, java.lang.Integer.MAX_VALUE, dynamicValue)); 4480 children.add(new Property("action", "@PlanDefinition.action", 4481 "Sub actions that are contained within the action. The behavior of this action determines the functionality of the sub-actions. For example, a selection behavior of at-most-one indicates that of the sub-actions, at most one may be chosen as part of realizing the action definition.", 4482 0, java.lang.Integer.MAX_VALUE, action)); 4483 } 4484 4485 @Override 4486 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4487 switch (_hash) { 4488 case -980110702: 4489 /* prefix */ return new Property("prefix", "string", "A user-visible prefix for the action.", 0, 1, prefix); 4490 case 110371416: 4491 /* title */ return new Property("title", "string", "The title of the action displayed to a user.", 0, 1, title); 4492 case -1724546052: 4493 /* description */ return new Property("description", "string", 4494 "A brief description of the action used to provide a summary to display to the user.", 0, 1, description); 4495 case -900391049: 4496 /* textEquivalent */ return new Property("textEquivalent", "string", 4497 "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that might not be capable of interpreting it dynamically.", 4498 0, 1, textEquivalent); 4499 case -1165461084: 4500 /* priority */ return new Property("priority", "code", 4501 "Indicates how quickly the action should be addressed with respect to other actions.", 0, 1, priority); 4502 case 3059181: 4503 /* code */ return new Property("code", "CodeableConcept", 4504 "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for the section of a documentation template.", 4505 0, java.lang.Integer.MAX_VALUE, code); 4506 case -934964668: 4507 /* reason */ return new Property("reason", "CodeableConcept", 4508 "A description of why this action is necessary or appropriate.", 0, java.lang.Integer.MAX_VALUE, reason); 4509 case 1587405498: 4510 /* documentation */ return new Property("documentation", "RelatedArtifact", 4511 "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.", 4512 0, java.lang.Integer.MAX_VALUE, documentation); 4513 case -1240658034: 4514 /* goalId */ return new Property("goalId", "id", 4515 "Identifies goals that this action supports. The reference must be to a goal element defined within this plan definition.", 4516 0, java.lang.Integer.MAX_VALUE, goalId); 4517 case -573640748: 4518 /* subject[x] */ return new Property("subject[x]", "CodeableConcept|Reference(Group)", 4519 "A code or group definition that describes the intended subject of the action and its children, if any.", 0, 4520 1, subject); 4521 case -1867885268: 4522 /* subject */ return new Property("subject[x]", "CodeableConcept|Reference(Group)", 4523 "A code or group definition that describes the intended subject of the action and its children, if any.", 0, 4524 1, subject); 4525 case -1257122603: 4526 /* subjectCodeableConcept */ return new Property("subject[x]", "CodeableConcept|Reference(Group)", 4527 "A code or group definition that describes the intended subject of the action and its children, if any.", 0, 4528 1, subject); 4529 case 772938623: 4530 /* subjectReference */ return new Property("subject[x]", "CodeableConcept|Reference(Group)", 4531 "A code or group definition that describes the intended subject of the action and its children, if any.", 0, 4532 1, subject); 4533 case -1059891784: 4534 /* trigger */ return new Property("trigger", "TriggerDefinition", 4535 "A description of when the action should be triggered.", 0, java.lang.Integer.MAX_VALUE, trigger); 4536 case -861311717: 4537 /* condition */ return new Property("condition", "", 4538 "An expression that describes applicability criteria or start/stop conditions for the action.", 0, 4539 java.lang.Integer.MAX_VALUE, condition); 4540 case 100358090: 4541 /* input */ return new Property("input", "DataRequirement", "Defines input data requirements for the action.", 4542 0, java.lang.Integer.MAX_VALUE, input); 4543 case -1005512447: 4544 /* output */ return new Property("output", "DataRequirement", "Defines the outputs of the action, if any.", 0, 4545 java.lang.Integer.MAX_VALUE, output); 4546 case -384107967: 4547 /* relatedAction */ return new Property("relatedAction", "", 4548 "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".", 0, 4549 java.lang.Integer.MAX_VALUE, relatedAction); 4550 case 164632566: 4551 /* timing[x] */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4552 "An optional value describing when the action should be performed.", 0, 1, timing); 4553 case -873664438: 4554 /* timing */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4555 "An optional value describing when the action should be performed.", 0, 1, timing); 4556 case -1837458939: 4557 /* timingDateTime */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4558 "An optional value describing when the action should be performed.", 0, 1, timing); 4559 case 164607061: 4560 /* timingAge */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4561 "An optional value describing when the action should be performed.", 0, 1, timing); 4562 case -615615829: 4563 /* timingPeriod */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4564 "An optional value describing when the action should be performed.", 0, 1, timing); 4565 case -1327253506: 4566 /* timingDuration */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4567 "An optional value describing when the action should be performed.", 0, 1, timing); 4568 case -710871277: 4569 /* timingRange */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4570 "An optional value describing when the action should be performed.", 0, 1, timing); 4571 case -497554124: 4572 /* timingTiming */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 4573 "An optional value describing when the action should be performed.", 0, 1, timing); 4574 case 767422259: 4575 /* participant */ return new Property("participant", "", 4576 "Indicates who should participate in performing the action described.", 0, java.lang.Integer.MAX_VALUE, 4577 participant); 4578 case 3575610: 4579 /* type */ return new Property("type", "CodeableConcept", 4580 "The type of action to perform (create, update, remove).", 0, 1, type); 4581 case 586678389: 4582 /* groupingBehavior */ return new Property("groupingBehavior", "code", 4583 "Defines the grouping behavior for the action and its children.", 0, 1, groupingBehavior); 4584 case 168639486: 4585 /* selectionBehavior */ return new Property("selectionBehavior", "code", 4586 "Defines the selection behavior for the action and its children.", 0, 1, selectionBehavior); 4587 case -1163906287: 4588 /* requiredBehavior */ return new Property("requiredBehavior", "code", 4589 "Defines the required behavior for the action.", 0, 1, requiredBehavior); 4590 case -1174249033: 4591 /* precheckBehavior */ return new Property("precheckBehavior", "code", 4592 "Defines whether the action should usually be preselected.", 0, 1, precheckBehavior); 4593 case -922577408: 4594 /* cardinalityBehavior */ return new Property("cardinalityBehavior", "code", 4595 "Defines whether the action can be selected multiple times.", 0, 1, cardinalityBehavior); 4596 case -1139422643: 4597 /* definition[x] */ return new Property("definition[x]", 4598 "canonical(ActivityDefinition|PlanDefinition|Questionnaire)|uri", 4599 "A reference to an ActivityDefinition that describes the action to be taken in detail, or a PlanDefinition that describes a series of actions to be taken.", 4600 0, 1, definition); 4601 case -1014418093: 4602 /* definition */ return new Property("definition[x]", 4603 "canonical(ActivityDefinition|PlanDefinition|Questionnaire)|uri", 4604 "A reference to an ActivityDefinition that describes the action to be taken in detail, or a PlanDefinition that describes a series of actions to be taken.", 4605 0, 1, definition); 4606 case 933485793: 4607 /* definitionCanonical */ return new Property("definition[x]", 4608 "canonical(ActivityDefinition|PlanDefinition|Questionnaire)|uri", 4609 "A reference to an ActivityDefinition that describes the action to be taken in detail, or a PlanDefinition that describes a series of actions to be taken.", 4610 0, 1, definition); 4611 case -1139428583: 4612 /* definitionUri */ return new Property("definition[x]", 4613 "canonical(ActivityDefinition|PlanDefinition|Questionnaire)|uri", 4614 "A reference to an ActivityDefinition that describes the action to be taken in detail, or a PlanDefinition that describes a series of actions to be taken.", 4615 0, 1, definition); 4616 case 1052666732: 4617 /* transform */ return new Property("transform", "canonical(StructureMap)", 4618 "A reference to a StructureMap resource that defines a transform that can be executed to produce the intent resource using the ActivityDefinition instance as the input.", 4619 0, 1, transform); 4620 case 572625010: 4621 /* dynamicValue */ return new Property("dynamicValue", "", 4622 "Customizations that should be applied to the statically defined resource. For example, if the dosage of a medication must be computed based on the patient's weight, a customization would be used to specify an expression that calculated the weight, and the path on the resource that would contain the result.", 4623 0, java.lang.Integer.MAX_VALUE, dynamicValue); 4624 case -1422950858: 4625 /* action */ return new Property("action", "@PlanDefinition.action", 4626 "Sub actions that are contained within the action. The behavior of this action determines the functionality of the sub-actions. For example, a selection behavior of at-most-one indicates that of the sub-actions, at most one may be chosen as part of realizing the action definition.", 4627 0, java.lang.Integer.MAX_VALUE, action); 4628 default: 4629 return super.getNamedProperty(_hash, _name, _checkValid); 4630 } 4631 4632 } 4633 4634 @Override 4635 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4636 switch (hash) { 4637 case -980110702: 4638 /* prefix */ return this.prefix == null ? new Base[0] : new Base[] { this.prefix }; // StringType 4639 case 110371416: 4640 /* title */ return this.title == null ? new Base[0] : new Base[] { this.title }; // StringType 4641 case -1724546052: 4642 /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType 4643 case -900391049: 4644 /* textEquivalent */ return this.textEquivalent == null ? new Base[0] : new Base[] { this.textEquivalent }; // StringType 4645 case -1165461084: 4646 /* priority */ return this.priority == null ? new Base[0] : new Base[] { this.priority }; // Enumeration<RequestPriority> 4647 case 3059181: 4648 /* code */ return this.code == null ? new Base[0] : this.code.toArray(new Base[this.code.size()]); // CodeableConcept 4649 case -934964668: 4650 /* reason */ return this.reason == null ? new Base[0] : this.reason.toArray(new Base[this.reason.size()]); // CodeableConcept 4651 case 1587405498: 4652 /* documentation */ return this.documentation == null ? new Base[0] 4653 : this.documentation.toArray(new Base[this.documentation.size()]); // RelatedArtifact 4654 case -1240658034: 4655 /* goalId */ return this.goalId == null ? new Base[0] : this.goalId.toArray(new Base[this.goalId.size()]); // IdType 4656 case -1867885268: 4657 /* subject */ return this.subject == null ? new Base[0] : new Base[] { this.subject }; // Type 4658 case -1059891784: 4659 /* trigger */ return this.trigger == null ? new Base[0] : this.trigger.toArray(new Base[this.trigger.size()]); // TriggerDefinition 4660 case -861311717: 4661 /* condition */ return this.condition == null ? new Base[0] 4662 : this.condition.toArray(new Base[this.condition.size()]); // PlanDefinitionActionConditionComponent 4663 case 100358090: 4664 /* input */ return this.input == null ? new Base[0] : this.input.toArray(new Base[this.input.size()]); // DataRequirement 4665 case -1005512447: 4666 /* output */ return this.output == null ? new Base[0] : this.output.toArray(new Base[this.output.size()]); // DataRequirement 4667 case -384107967: 4668 /* relatedAction */ return this.relatedAction == null ? new Base[0] 4669 : this.relatedAction.toArray(new Base[this.relatedAction.size()]); // PlanDefinitionActionRelatedActionComponent 4670 case -873664438: 4671 /* timing */ return this.timing == null ? new Base[0] : new Base[] { this.timing }; // Type 4672 case 767422259: 4673 /* participant */ return this.participant == null ? new Base[0] 4674 : this.participant.toArray(new Base[this.participant.size()]); // PlanDefinitionActionParticipantComponent 4675 case 3575610: 4676 /* type */ return this.type == null ? new Base[0] : new Base[] { this.type }; // CodeableConcept 4677 case 586678389: 4678 /* groupingBehavior */ return this.groupingBehavior == null ? new Base[0] 4679 : new Base[] { this.groupingBehavior }; // Enumeration<ActionGroupingBehavior> 4680 case 168639486: 4681 /* selectionBehavior */ return this.selectionBehavior == null ? new Base[0] 4682 : new Base[] { this.selectionBehavior }; // Enumeration<ActionSelectionBehavior> 4683 case -1163906287: 4684 /* requiredBehavior */ return this.requiredBehavior == null ? new Base[0] 4685 : new Base[] { this.requiredBehavior }; // Enumeration<ActionRequiredBehavior> 4686 case -1174249033: 4687 /* precheckBehavior */ return this.precheckBehavior == null ? new Base[0] 4688 : new Base[] { this.precheckBehavior }; // Enumeration<ActionPrecheckBehavior> 4689 case -922577408: 4690 /* cardinalityBehavior */ return this.cardinalityBehavior == null ? new Base[0] 4691 : new Base[] { this.cardinalityBehavior }; // Enumeration<ActionCardinalityBehavior> 4692 case -1014418093: 4693 /* definition */ return this.definition == null ? new Base[0] : new Base[] { this.definition }; // Type 4694 case 1052666732: 4695 /* transform */ return this.transform == null ? new Base[0] : new Base[] { this.transform }; // CanonicalType 4696 case 572625010: 4697 /* dynamicValue */ return this.dynamicValue == null ? new Base[0] 4698 : this.dynamicValue.toArray(new Base[this.dynamicValue.size()]); // PlanDefinitionActionDynamicValueComponent 4699 case -1422950858: 4700 /* action */ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // PlanDefinitionActionComponent 4701 default: 4702 return super.getProperty(hash, name, checkValid); 4703 } 4704 4705 } 4706 4707 @Override 4708 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4709 switch (hash) { 4710 case -980110702: // prefix 4711 this.prefix = castToString(value); // StringType 4712 return value; 4713 case 110371416: // title 4714 this.title = castToString(value); // StringType 4715 return value; 4716 case -1724546052: // description 4717 this.description = castToString(value); // StringType 4718 return value; 4719 case -900391049: // textEquivalent 4720 this.textEquivalent = castToString(value); // StringType 4721 return value; 4722 case -1165461084: // priority 4723 value = new RequestPriorityEnumFactory().fromType(castToCode(value)); 4724 this.priority = (Enumeration) value; // Enumeration<RequestPriority> 4725 return value; 4726 case 3059181: // code 4727 this.getCode().add(castToCodeableConcept(value)); // CodeableConcept 4728 return value; 4729 case -934964668: // reason 4730 this.getReason().add(castToCodeableConcept(value)); // CodeableConcept 4731 return value; 4732 case 1587405498: // documentation 4733 this.getDocumentation().add(castToRelatedArtifact(value)); // RelatedArtifact 4734 return value; 4735 case -1240658034: // goalId 4736 this.getGoalId().add(castToId(value)); // IdType 4737 return value; 4738 case -1867885268: // subject 4739 this.subject = castToType(value); // Type 4740 return value; 4741 case -1059891784: // trigger 4742 this.getTrigger().add(castToTriggerDefinition(value)); // TriggerDefinition 4743 return value; 4744 case -861311717: // condition 4745 this.getCondition().add((PlanDefinitionActionConditionComponent) value); // PlanDefinitionActionConditionComponent 4746 return value; 4747 case 100358090: // input 4748 this.getInput().add(castToDataRequirement(value)); // DataRequirement 4749 return value; 4750 case -1005512447: // output 4751 this.getOutput().add(castToDataRequirement(value)); // DataRequirement 4752 return value; 4753 case -384107967: // relatedAction 4754 this.getRelatedAction().add((PlanDefinitionActionRelatedActionComponent) value); // PlanDefinitionActionRelatedActionComponent 4755 return value; 4756 case -873664438: // timing 4757 this.timing = castToType(value); // Type 4758 return value; 4759 case 767422259: // participant 4760 this.getParticipant().add((PlanDefinitionActionParticipantComponent) value); // PlanDefinitionActionParticipantComponent 4761 return value; 4762 case 3575610: // type 4763 this.type = castToCodeableConcept(value); // CodeableConcept 4764 return value; 4765 case 586678389: // groupingBehavior 4766 value = new ActionGroupingBehaviorEnumFactory().fromType(castToCode(value)); 4767 this.groupingBehavior = (Enumeration) value; // Enumeration<ActionGroupingBehavior> 4768 return value; 4769 case 168639486: // selectionBehavior 4770 value = new ActionSelectionBehaviorEnumFactory().fromType(castToCode(value)); 4771 this.selectionBehavior = (Enumeration) value; // Enumeration<ActionSelectionBehavior> 4772 return value; 4773 case -1163906287: // requiredBehavior 4774 value = new ActionRequiredBehaviorEnumFactory().fromType(castToCode(value)); 4775 this.requiredBehavior = (Enumeration) value; // Enumeration<ActionRequiredBehavior> 4776 return value; 4777 case -1174249033: // precheckBehavior 4778 value = new ActionPrecheckBehaviorEnumFactory().fromType(castToCode(value)); 4779 this.precheckBehavior = (Enumeration) value; // Enumeration<ActionPrecheckBehavior> 4780 return value; 4781 case -922577408: // cardinalityBehavior 4782 value = new ActionCardinalityBehaviorEnumFactory().fromType(castToCode(value)); 4783 this.cardinalityBehavior = (Enumeration) value; // Enumeration<ActionCardinalityBehavior> 4784 return value; 4785 case -1014418093: // definition 4786 this.definition = castToType(value); // Type 4787 return value; 4788 case 1052666732: // transform 4789 this.transform = castToCanonical(value); // CanonicalType 4790 return value; 4791 case 572625010: // dynamicValue 4792 this.getDynamicValue().add((PlanDefinitionActionDynamicValueComponent) value); // PlanDefinitionActionDynamicValueComponent 4793 return value; 4794 case -1422950858: // action 4795 this.getAction().add((PlanDefinitionActionComponent) value); // PlanDefinitionActionComponent 4796 return value; 4797 default: 4798 return super.setProperty(hash, name, value); 4799 } 4800 4801 } 4802 4803 @Override 4804 public Base setProperty(String name, Base value) throws FHIRException { 4805 if (name.equals("prefix")) { 4806 this.prefix = castToString(value); // StringType 4807 } else if (name.equals("title")) { 4808 this.title = castToString(value); // StringType 4809 } else if (name.equals("description")) { 4810 this.description = castToString(value); // StringType 4811 } else if (name.equals("textEquivalent")) { 4812 this.textEquivalent = castToString(value); // StringType 4813 } else if (name.equals("priority")) { 4814 value = new RequestPriorityEnumFactory().fromType(castToCode(value)); 4815 this.priority = (Enumeration) value; // Enumeration<RequestPriority> 4816 } else if (name.equals("code")) { 4817 this.getCode().add(castToCodeableConcept(value)); 4818 } else if (name.equals("reason")) { 4819 this.getReason().add(castToCodeableConcept(value)); 4820 } else if (name.equals("documentation")) { 4821 this.getDocumentation().add(castToRelatedArtifact(value)); 4822 } else if (name.equals("goalId")) { 4823 this.getGoalId().add(castToId(value)); 4824 } else if (name.equals("subject[x]")) { 4825 this.subject = castToType(value); // Type 4826 } else if (name.equals("trigger")) { 4827 this.getTrigger().add(castToTriggerDefinition(value)); 4828 } else if (name.equals("condition")) { 4829 this.getCondition().add((PlanDefinitionActionConditionComponent) value); 4830 } else if (name.equals("input")) { 4831 this.getInput().add(castToDataRequirement(value)); 4832 } else if (name.equals("output")) { 4833 this.getOutput().add(castToDataRequirement(value)); 4834 } else if (name.equals("relatedAction")) { 4835 this.getRelatedAction().add((PlanDefinitionActionRelatedActionComponent) value); 4836 } else if (name.equals("timing[x]")) { 4837 this.timing = castToType(value); // Type 4838 } else if (name.equals("participant")) { 4839 this.getParticipant().add((PlanDefinitionActionParticipantComponent) value); 4840 } else if (name.equals("type")) { 4841 this.type = castToCodeableConcept(value); // CodeableConcept 4842 } else if (name.equals("groupingBehavior")) { 4843 value = new ActionGroupingBehaviorEnumFactory().fromType(castToCode(value)); 4844 this.groupingBehavior = (Enumeration) value; // Enumeration<ActionGroupingBehavior> 4845 } else if (name.equals("selectionBehavior")) { 4846 value = new ActionSelectionBehaviorEnumFactory().fromType(castToCode(value)); 4847 this.selectionBehavior = (Enumeration) value; // Enumeration<ActionSelectionBehavior> 4848 } else if (name.equals("requiredBehavior")) { 4849 value = new ActionRequiredBehaviorEnumFactory().fromType(castToCode(value)); 4850 this.requiredBehavior = (Enumeration) value; // Enumeration<ActionRequiredBehavior> 4851 } else if (name.equals("precheckBehavior")) { 4852 value = new ActionPrecheckBehaviorEnumFactory().fromType(castToCode(value)); 4853 this.precheckBehavior = (Enumeration) value; // Enumeration<ActionPrecheckBehavior> 4854 } else if (name.equals("cardinalityBehavior")) { 4855 value = new ActionCardinalityBehaviorEnumFactory().fromType(castToCode(value)); 4856 this.cardinalityBehavior = (Enumeration) value; // Enumeration<ActionCardinalityBehavior> 4857 } else if (name.equals("definition[x]")) { 4858 this.definition = castToType(value); // Type 4859 } else if (name.equals("transform")) { 4860 this.transform = castToCanonical(value); // CanonicalType 4861 } else if (name.equals("dynamicValue")) { 4862 this.getDynamicValue().add((PlanDefinitionActionDynamicValueComponent) value); 4863 } else if (name.equals("action")) { 4864 this.getAction().add((PlanDefinitionActionComponent) value); 4865 } else 4866 return super.setProperty(name, value); 4867 return value; 4868 } 4869 4870 @Override 4871 public void removeChild(String name, Base value) throws FHIRException { 4872 if (name.equals("prefix")) { 4873 this.prefix = null; 4874 } else if (name.equals("title")) { 4875 this.title = null; 4876 } else if (name.equals("description")) { 4877 this.description = null; 4878 } else if (name.equals("textEquivalent")) { 4879 this.textEquivalent = null; 4880 } else if (name.equals("priority")) { 4881 this.priority = null; 4882 } else if (name.equals("code")) { 4883 this.getCode().remove(castToCodeableConcept(value)); 4884 } else if (name.equals("reason")) { 4885 this.getReason().remove(castToCodeableConcept(value)); 4886 } else if (name.equals("documentation")) { 4887 this.getDocumentation().remove(castToRelatedArtifact(value)); 4888 } else if (name.equals("goalId")) { 4889 this.getGoalId().remove(castToId(value)); 4890 } else if (name.equals("subject[x]")) { 4891 this.subject = null; 4892 } else if (name.equals("trigger")) { 4893 this.getTrigger().remove(castToTriggerDefinition(value)); 4894 } else if (name.equals("condition")) { 4895 this.getCondition().remove((PlanDefinitionActionConditionComponent) value); 4896 } else if (name.equals("input")) { 4897 this.getInput().remove(castToDataRequirement(value)); 4898 } else if (name.equals("output")) { 4899 this.getOutput().remove(castToDataRequirement(value)); 4900 } else if (name.equals("relatedAction")) { 4901 this.getRelatedAction().remove((PlanDefinitionActionRelatedActionComponent) value); 4902 } else if (name.equals("timing[x]")) { 4903 this.timing = null; 4904 } else if (name.equals("participant")) { 4905 this.getParticipant().remove((PlanDefinitionActionParticipantComponent) value); 4906 } else if (name.equals("type")) { 4907 this.type = null; 4908 } else if (name.equals("groupingBehavior")) { 4909 this.groupingBehavior = null; 4910 } else if (name.equals("selectionBehavior")) { 4911 this.selectionBehavior = null; 4912 } else if (name.equals("requiredBehavior")) { 4913 this.requiredBehavior = null; 4914 } else if (name.equals("precheckBehavior")) { 4915 this.precheckBehavior = null; 4916 } else if (name.equals("cardinalityBehavior")) { 4917 this.cardinalityBehavior = null; 4918 } else if (name.equals("definition[x]")) { 4919 this.definition = null; 4920 } else if (name.equals("transform")) { 4921 this.transform = null; 4922 } else if (name.equals("dynamicValue")) { 4923 this.getDynamicValue().remove((PlanDefinitionActionDynamicValueComponent) value); 4924 } else if (name.equals("action")) { 4925 this.getAction().remove((PlanDefinitionActionComponent) value); 4926 } else 4927 super.removeChild(name, value); 4928 4929 } 4930 4931 @Override 4932 public Base makeProperty(int hash, String name) throws FHIRException { 4933 switch (hash) { 4934 case -980110702: 4935 return getPrefixElement(); 4936 case 110371416: 4937 return getTitleElement(); 4938 case -1724546052: 4939 return getDescriptionElement(); 4940 case -900391049: 4941 return getTextEquivalentElement(); 4942 case -1165461084: 4943 return getPriorityElement(); 4944 case 3059181: 4945 return addCode(); 4946 case -934964668: 4947 return addReason(); 4948 case 1587405498: 4949 return addDocumentation(); 4950 case -1240658034: 4951 return addGoalIdElement(); 4952 case -573640748: 4953 return getSubject(); 4954 case -1867885268: 4955 return getSubject(); 4956 case -1059891784: 4957 return addTrigger(); 4958 case -861311717: 4959 return addCondition(); 4960 case 100358090: 4961 return addInput(); 4962 case -1005512447: 4963 return addOutput(); 4964 case -384107967: 4965 return addRelatedAction(); 4966 case 164632566: 4967 return getTiming(); 4968 case -873664438: 4969 return getTiming(); 4970 case 767422259: 4971 return addParticipant(); 4972 case 3575610: 4973 return getType(); 4974 case 586678389: 4975 return getGroupingBehaviorElement(); 4976 case 168639486: 4977 return getSelectionBehaviorElement(); 4978 case -1163906287: 4979 return getRequiredBehaviorElement(); 4980 case -1174249033: 4981 return getPrecheckBehaviorElement(); 4982 case -922577408: 4983 return getCardinalityBehaviorElement(); 4984 case -1139422643: 4985 return getDefinition(); 4986 case -1014418093: 4987 return getDefinition(); 4988 case 1052666732: 4989 return getTransformElement(); 4990 case 572625010: 4991 return addDynamicValue(); 4992 case -1422950858: 4993 return addAction(); 4994 default: 4995 return super.makeProperty(hash, name); 4996 } 4997 4998 } 4999 5000 @Override 5001 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5002 switch (hash) { 5003 case -980110702: 5004 /* prefix */ return new String[] { "string" }; 5005 case 110371416: 5006 /* title */ return new String[] { "string" }; 5007 case -1724546052: 5008 /* description */ return new String[] { "string" }; 5009 case -900391049: 5010 /* textEquivalent */ return new String[] { "string" }; 5011 case -1165461084: 5012 /* priority */ return new String[] { "code" }; 5013 case 3059181: 5014 /* code */ return new String[] { "CodeableConcept" }; 5015 case -934964668: 5016 /* reason */ return new String[] { "CodeableConcept" }; 5017 case 1587405498: 5018 /* documentation */ return new String[] { "RelatedArtifact" }; 5019 case -1240658034: 5020 /* goalId */ return new String[] { "id" }; 5021 case -1867885268: 5022 /* subject */ return new String[] { "CodeableConcept", "Reference" }; 5023 case -1059891784: 5024 /* trigger */ return new String[] { "TriggerDefinition" }; 5025 case -861311717: 5026 /* condition */ return new String[] {}; 5027 case 100358090: 5028 /* input */ return new String[] { "DataRequirement" }; 5029 case -1005512447: 5030 /* output */ return new String[] { "DataRequirement" }; 5031 case -384107967: 5032 /* relatedAction */ return new String[] {}; 5033 case -873664438: 5034 /* timing */ return new String[] { "dateTime", "Age", "Period", "Duration", "Range", "Timing" }; 5035 case 767422259: 5036 /* participant */ return new String[] {}; 5037 case 3575610: 5038 /* type */ return new String[] { "CodeableConcept" }; 5039 case 586678389: 5040 /* groupingBehavior */ return new String[] { "code" }; 5041 case 168639486: 5042 /* selectionBehavior */ return new String[] { "code" }; 5043 case -1163906287: 5044 /* requiredBehavior */ return new String[] { "code" }; 5045 case -1174249033: 5046 /* precheckBehavior */ return new String[] { "code" }; 5047 case -922577408: 5048 /* cardinalityBehavior */ return new String[] { "code" }; 5049 case -1014418093: 5050 /* definition */ return new String[] { "canonical", "uri" }; 5051 case 1052666732: 5052 /* transform */ return new String[] { "canonical" }; 5053 case 572625010: 5054 /* dynamicValue */ return new String[] {}; 5055 case -1422950858: 5056 /* action */ return new String[] { "@PlanDefinition.action" }; 5057 default: 5058 return super.getTypesForProperty(hash, name); 5059 } 5060 5061 } 5062 5063 @Override 5064 public Base addChild(String name) throws FHIRException { 5065 if (name.equals("prefix")) { 5066 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.prefix"); 5067 } else if (name.equals("title")) { 5068 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.title"); 5069 } else if (name.equals("description")) { 5070 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.description"); 5071 } else if (name.equals("textEquivalent")) { 5072 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.textEquivalent"); 5073 } else if (name.equals("priority")) { 5074 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.priority"); 5075 } else if (name.equals("code")) { 5076 return addCode(); 5077 } else if (name.equals("reason")) { 5078 return addReason(); 5079 } else if (name.equals("documentation")) { 5080 return addDocumentation(); 5081 } else if (name.equals("goalId")) { 5082 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.goalId"); 5083 } else if (name.equals("subjectCodeableConcept")) { 5084 this.subject = new CodeableConcept(); 5085 return this.subject; 5086 } else if (name.equals("subjectReference")) { 5087 this.subject = new Reference(); 5088 return this.subject; 5089 } else if (name.equals("trigger")) { 5090 return addTrigger(); 5091 } else if (name.equals("condition")) { 5092 return addCondition(); 5093 } else if (name.equals("input")) { 5094 return addInput(); 5095 } else if (name.equals("output")) { 5096 return addOutput(); 5097 } else if (name.equals("relatedAction")) { 5098 return addRelatedAction(); 5099 } else if (name.equals("timingDateTime")) { 5100 this.timing = new DateTimeType(); 5101 return this.timing; 5102 } else if (name.equals("timingAge")) { 5103 this.timing = new Age(); 5104 return this.timing; 5105 } else if (name.equals("timingPeriod")) { 5106 this.timing = new Period(); 5107 return this.timing; 5108 } else if (name.equals("timingDuration")) { 5109 this.timing = new Duration(); 5110 return this.timing; 5111 } else if (name.equals("timingRange")) { 5112 this.timing = new Range(); 5113 return this.timing; 5114 } else if (name.equals("timingTiming")) { 5115 this.timing = new Timing(); 5116 return this.timing; 5117 } else if (name.equals("participant")) { 5118 return addParticipant(); 5119 } else if (name.equals("type")) { 5120 this.type = new CodeableConcept(); 5121 return this.type; 5122 } else if (name.equals("groupingBehavior")) { 5123 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.groupingBehavior"); 5124 } else if (name.equals("selectionBehavior")) { 5125 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.selectionBehavior"); 5126 } else if (name.equals("requiredBehavior")) { 5127 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.requiredBehavior"); 5128 } else if (name.equals("precheckBehavior")) { 5129 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.precheckBehavior"); 5130 } else if (name.equals("cardinalityBehavior")) { 5131 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.cardinalityBehavior"); 5132 } else if (name.equals("definitionCanonical")) { 5133 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.definition[x]"); 5134 } else if (name.equals("definitionUri")) { 5135 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.definition[x]"); 5136 } else if (name.equals("transform")) { 5137 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.transform"); 5138 } else if (name.equals("dynamicValue")) { 5139 return addDynamicValue(); 5140 } else if (name.equals("action")) { 5141 return addAction(); 5142 } else 5143 return super.addChild(name); 5144 } 5145 5146 public PlanDefinitionActionComponent copy() { 5147 PlanDefinitionActionComponent dst = new PlanDefinitionActionComponent(); 5148 copyValues(dst); 5149 return dst; 5150 } 5151 5152 public void copyValues(PlanDefinitionActionComponent dst) { 5153 super.copyValues(dst); 5154 dst.prefix = prefix == null ? null : prefix.copy(); 5155 dst.title = title == null ? null : title.copy(); 5156 dst.description = description == null ? null : description.copy(); 5157 dst.textEquivalent = textEquivalent == null ? null : textEquivalent.copy(); 5158 dst.priority = priority == null ? null : priority.copy(); 5159 if (code != null) { 5160 dst.code = new ArrayList<CodeableConcept>(); 5161 for (CodeableConcept i : code) 5162 dst.code.add(i.copy()); 5163 } 5164 ; 5165 if (reason != null) { 5166 dst.reason = new ArrayList<CodeableConcept>(); 5167 for (CodeableConcept i : reason) 5168 dst.reason.add(i.copy()); 5169 } 5170 ; 5171 if (documentation != null) { 5172 dst.documentation = new ArrayList<RelatedArtifact>(); 5173 for (RelatedArtifact i : documentation) 5174 dst.documentation.add(i.copy()); 5175 } 5176 ; 5177 if (goalId != null) { 5178 dst.goalId = new ArrayList<IdType>(); 5179 for (IdType i : goalId) 5180 dst.goalId.add(i.copy()); 5181 } 5182 ; 5183 dst.subject = subject == null ? null : subject.copy(); 5184 if (trigger != null) { 5185 dst.trigger = new ArrayList<TriggerDefinition>(); 5186 for (TriggerDefinition i : trigger) 5187 dst.trigger.add(i.copy()); 5188 } 5189 ; 5190 if (condition != null) { 5191 dst.condition = new ArrayList<PlanDefinitionActionConditionComponent>(); 5192 for (PlanDefinitionActionConditionComponent i : condition) 5193 dst.condition.add(i.copy()); 5194 } 5195 ; 5196 if (input != null) { 5197 dst.input = new ArrayList<DataRequirement>(); 5198 for (DataRequirement i : input) 5199 dst.input.add(i.copy()); 5200 } 5201 ; 5202 if (output != null) { 5203 dst.output = new ArrayList<DataRequirement>(); 5204 for (DataRequirement i : output) 5205 dst.output.add(i.copy()); 5206 } 5207 ; 5208 if (relatedAction != null) { 5209 dst.relatedAction = new ArrayList<PlanDefinitionActionRelatedActionComponent>(); 5210 for (PlanDefinitionActionRelatedActionComponent i : relatedAction) 5211 dst.relatedAction.add(i.copy()); 5212 } 5213 ; 5214 dst.timing = timing == null ? null : timing.copy(); 5215 if (participant != null) { 5216 dst.participant = new ArrayList<PlanDefinitionActionParticipantComponent>(); 5217 for (PlanDefinitionActionParticipantComponent i : participant) 5218 dst.participant.add(i.copy()); 5219 } 5220 ; 5221 dst.type = type == null ? null : type.copy(); 5222 dst.groupingBehavior = groupingBehavior == null ? null : groupingBehavior.copy(); 5223 dst.selectionBehavior = selectionBehavior == null ? null : selectionBehavior.copy(); 5224 dst.requiredBehavior = requiredBehavior == null ? null : requiredBehavior.copy(); 5225 dst.precheckBehavior = precheckBehavior == null ? null : precheckBehavior.copy(); 5226 dst.cardinalityBehavior = cardinalityBehavior == null ? null : cardinalityBehavior.copy(); 5227 dst.definition = definition == null ? null : definition.copy(); 5228 dst.transform = transform == null ? null : transform.copy(); 5229 if (dynamicValue != null) { 5230 dst.dynamicValue = new ArrayList<PlanDefinitionActionDynamicValueComponent>(); 5231 for (PlanDefinitionActionDynamicValueComponent i : dynamicValue) 5232 dst.dynamicValue.add(i.copy()); 5233 } 5234 ; 5235 if (action != null) { 5236 dst.action = new ArrayList<PlanDefinitionActionComponent>(); 5237 for (PlanDefinitionActionComponent i : action) 5238 dst.action.add(i.copy()); 5239 } 5240 ; 5241 } 5242 5243 @Override 5244 public boolean equalsDeep(Base other_) { 5245 if (!super.equalsDeep(other_)) 5246 return false; 5247 if (!(other_ instanceof PlanDefinitionActionComponent)) 5248 return false; 5249 PlanDefinitionActionComponent o = (PlanDefinitionActionComponent) other_; 5250 return compareDeep(prefix, o.prefix, true) && compareDeep(title, o.title, true) 5251 && compareDeep(description, o.description, true) && compareDeep(textEquivalent, o.textEquivalent, true) 5252 && compareDeep(priority, o.priority, true) && compareDeep(code, o.code, true) 5253 && compareDeep(reason, o.reason, true) && compareDeep(documentation, o.documentation, true) 5254 && compareDeep(goalId, o.goalId, true) && compareDeep(subject, o.subject, true) 5255 && compareDeep(trigger, o.trigger, true) && compareDeep(condition, o.condition, true) 5256 && compareDeep(input, o.input, true) && compareDeep(output, o.output, true) 5257 && compareDeep(relatedAction, o.relatedAction, true) && compareDeep(timing, o.timing, true) 5258 && compareDeep(participant, o.participant, true) && compareDeep(type, o.type, true) 5259 && compareDeep(groupingBehavior, o.groupingBehavior, true) 5260 && compareDeep(selectionBehavior, o.selectionBehavior, true) 5261 && compareDeep(requiredBehavior, o.requiredBehavior, true) 5262 && compareDeep(precheckBehavior, o.precheckBehavior, true) 5263 && compareDeep(cardinalityBehavior, o.cardinalityBehavior, true) 5264 && compareDeep(definition, o.definition, true) && compareDeep(transform, o.transform, true) 5265 && compareDeep(dynamicValue, o.dynamicValue, true) && compareDeep(action, o.action, true); 5266 } 5267 5268 @Override 5269 public boolean equalsShallow(Base other_) { 5270 if (!super.equalsShallow(other_)) 5271 return false; 5272 if (!(other_ instanceof PlanDefinitionActionComponent)) 5273 return false; 5274 PlanDefinitionActionComponent o = (PlanDefinitionActionComponent) other_; 5275 return compareValues(prefix, o.prefix, true) && compareValues(title, o.title, true) 5276 && compareValues(description, o.description, true) && compareValues(textEquivalent, o.textEquivalent, true) 5277 && compareValues(priority, o.priority, true) && compareValues(goalId, o.goalId, true) 5278 && compareValues(groupingBehavior, o.groupingBehavior, true) 5279 && compareValues(selectionBehavior, o.selectionBehavior, true) 5280 && compareValues(requiredBehavior, o.requiredBehavior, true) 5281 && compareValues(precheckBehavior, o.precheckBehavior, true) 5282 && compareValues(cardinalityBehavior, o.cardinalityBehavior, true); 5283 } 5284 5285 public boolean isEmpty() { 5286 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(prefix, title, description, textEquivalent, 5287 priority, code, reason, documentation, goalId, subject, trigger, condition, input, output, relatedAction, 5288 timing, participant, type, groupingBehavior, selectionBehavior, requiredBehavior, precheckBehavior, 5289 cardinalityBehavior, definition, transform, dynamicValue, action); 5290 } 5291 5292 public String fhirType() { 5293 return "PlanDefinition.action"; 5294 5295 } 5296 5297 } 5298 5299 @Block() 5300 public static class PlanDefinitionActionConditionComponent extends BackboneElement implements IBaseBackboneElement { 5301 /** 5302 * The kind of condition. 5303 */ 5304 @Child(name = "kind", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false) 5305 @Description(shortDefinition = "applicability | start | stop", formalDefinition = "The kind of condition.") 5306 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-condition-kind") 5307 protected Enumeration<ActionConditionKind> kind; 5308 5309 /** 5310 * An expression that returns true or false, indicating whether the condition is 5311 * satisfied. 5312 */ 5313 @Child(name = "expression", type = { 5314 Expression.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 5315 @Description(shortDefinition = "Boolean-valued expression", formalDefinition = "An expression that returns true or false, indicating whether the condition is satisfied.") 5316 protected Expression expression; 5317 5318 private static final long serialVersionUID = -455150438L; 5319 5320 /** 5321 * Constructor 5322 */ 5323 public PlanDefinitionActionConditionComponent() { 5324 super(); 5325 } 5326 5327 /** 5328 * Constructor 5329 */ 5330 public PlanDefinitionActionConditionComponent(Enumeration<ActionConditionKind> kind) { 5331 super(); 5332 this.kind = kind; 5333 } 5334 5335 /** 5336 * @return {@link #kind} (The kind of condition.). This is the underlying object 5337 * with id, value and extensions. The accessor "getKind" gives direct 5338 * access to the value 5339 */ 5340 public Enumeration<ActionConditionKind> getKindElement() { 5341 if (this.kind == null) 5342 if (Configuration.errorOnAutoCreate()) 5343 throw new Error("Attempt to auto-create PlanDefinitionActionConditionComponent.kind"); 5344 else if (Configuration.doAutoCreate()) 5345 this.kind = new Enumeration<ActionConditionKind>(new ActionConditionKindEnumFactory()); // bb 5346 return this.kind; 5347 } 5348 5349 public boolean hasKindElement() { 5350 return this.kind != null && !this.kind.isEmpty(); 5351 } 5352 5353 public boolean hasKind() { 5354 return this.kind != null && !this.kind.isEmpty(); 5355 } 5356 5357 /** 5358 * @param value {@link #kind} (The kind of condition.). This is the underlying 5359 * object with id, value and extensions. The accessor "getKind" 5360 * gives direct access to the value 5361 */ 5362 public PlanDefinitionActionConditionComponent setKindElement(Enumeration<ActionConditionKind> value) { 5363 this.kind = value; 5364 return this; 5365 } 5366 5367 /** 5368 * @return The kind of condition. 5369 */ 5370 public ActionConditionKind getKind() { 5371 return this.kind == null ? null : this.kind.getValue(); 5372 } 5373 5374 /** 5375 * @param value The kind of condition. 5376 */ 5377 public PlanDefinitionActionConditionComponent setKind(ActionConditionKind value) { 5378 if (this.kind == null) 5379 this.kind = new Enumeration<ActionConditionKind>(new ActionConditionKindEnumFactory()); 5380 this.kind.setValue(value); 5381 return this; 5382 } 5383 5384 /** 5385 * @return {@link #expression} (An expression that returns true or false, 5386 * indicating whether the condition is satisfied.) 5387 */ 5388 public Expression getExpression() { 5389 if (this.expression == null) 5390 if (Configuration.errorOnAutoCreate()) 5391 throw new Error("Attempt to auto-create PlanDefinitionActionConditionComponent.expression"); 5392 else if (Configuration.doAutoCreate()) 5393 this.expression = new Expression(); // cc 5394 return this.expression; 5395 } 5396 5397 public boolean hasExpression() { 5398 return this.expression != null && !this.expression.isEmpty(); 5399 } 5400 5401 /** 5402 * @param value {@link #expression} (An expression that returns true or false, 5403 * indicating whether the condition is satisfied.) 5404 */ 5405 public PlanDefinitionActionConditionComponent setExpression(Expression value) { 5406 this.expression = value; 5407 return this; 5408 } 5409 5410 protected void listChildren(List<Property> children) { 5411 super.listChildren(children); 5412 children.add(new Property("kind", "code", "The kind of condition.", 0, 1, kind)); 5413 children.add(new Property("expression", "Expression", 5414 "An expression that returns true or false, indicating whether the condition is satisfied.", 0, 1, 5415 expression)); 5416 } 5417 5418 @Override 5419 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5420 switch (_hash) { 5421 case 3292052: 5422 /* kind */ return new Property("kind", "code", "The kind of condition.", 0, 1, kind); 5423 case -1795452264: 5424 /* expression */ return new Property("expression", "Expression", 5425 "An expression that returns true or false, indicating whether the condition is satisfied.", 0, 1, 5426 expression); 5427 default: 5428 return super.getNamedProperty(_hash, _name, _checkValid); 5429 } 5430 5431 } 5432 5433 @Override 5434 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5435 switch (hash) { 5436 case 3292052: 5437 /* kind */ return this.kind == null ? new Base[0] : new Base[] { this.kind }; // Enumeration<ActionConditionKind> 5438 case -1795452264: 5439 /* expression */ return this.expression == null ? new Base[0] : new Base[] { this.expression }; // Expression 5440 default: 5441 return super.getProperty(hash, name, checkValid); 5442 } 5443 5444 } 5445 5446 @Override 5447 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5448 switch (hash) { 5449 case 3292052: // kind 5450 value = new ActionConditionKindEnumFactory().fromType(castToCode(value)); 5451 this.kind = (Enumeration) value; // Enumeration<ActionConditionKind> 5452 return value; 5453 case -1795452264: // expression 5454 this.expression = castToExpression(value); // Expression 5455 return value; 5456 default: 5457 return super.setProperty(hash, name, value); 5458 } 5459 5460 } 5461 5462 @Override 5463 public Base setProperty(String name, Base value) throws FHIRException { 5464 if (name.equals("kind")) { 5465 value = new ActionConditionKindEnumFactory().fromType(castToCode(value)); 5466 this.kind = (Enumeration) value; // Enumeration<ActionConditionKind> 5467 } else if (name.equals("expression")) { 5468 this.expression = castToExpression(value); // Expression 5469 } else 5470 return super.setProperty(name, value); 5471 return value; 5472 } 5473 5474 @Override 5475 public void removeChild(String name, Base value) throws FHIRException { 5476 if (name.equals("kind")) { 5477 this.kind = null; 5478 } else if (name.equals("expression")) { 5479 this.expression = null; 5480 } else 5481 super.removeChild(name, value); 5482 5483 } 5484 5485 @Override 5486 public Base makeProperty(int hash, String name) throws FHIRException { 5487 switch (hash) { 5488 case 3292052: 5489 return getKindElement(); 5490 case -1795452264: 5491 return getExpression(); 5492 default: 5493 return super.makeProperty(hash, name); 5494 } 5495 5496 } 5497 5498 @Override 5499 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5500 switch (hash) { 5501 case 3292052: 5502 /* kind */ return new String[] { "code" }; 5503 case -1795452264: 5504 /* expression */ return new String[] { "Expression" }; 5505 default: 5506 return super.getTypesForProperty(hash, name); 5507 } 5508 5509 } 5510 5511 @Override 5512 public Base addChild(String name) throws FHIRException { 5513 if (name.equals("kind")) { 5514 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.kind"); 5515 } else if (name.equals("expression")) { 5516 this.expression = new Expression(); 5517 return this.expression; 5518 } else 5519 return super.addChild(name); 5520 } 5521 5522 public PlanDefinitionActionConditionComponent copy() { 5523 PlanDefinitionActionConditionComponent dst = new PlanDefinitionActionConditionComponent(); 5524 copyValues(dst); 5525 return dst; 5526 } 5527 5528 public void copyValues(PlanDefinitionActionConditionComponent dst) { 5529 super.copyValues(dst); 5530 dst.kind = kind == null ? null : kind.copy(); 5531 dst.expression = expression == null ? null : expression.copy(); 5532 } 5533 5534 @Override 5535 public boolean equalsDeep(Base other_) { 5536 if (!super.equalsDeep(other_)) 5537 return false; 5538 if (!(other_ instanceof PlanDefinitionActionConditionComponent)) 5539 return false; 5540 PlanDefinitionActionConditionComponent o = (PlanDefinitionActionConditionComponent) other_; 5541 return compareDeep(kind, o.kind, true) && compareDeep(expression, o.expression, true); 5542 } 5543 5544 @Override 5545 public boolean equalsShallow(Base other_) { 5546 if (!super.equalsShallow(other_)) 5547 return false; 5548 if (!(other_ instanceof PlanDefinitionActionConditionComponent)) 5549 return false; 5550 PlanDefinitionActionConditionComponent o = (PlanDefinitionActionConditionComponent) other_; 5551 return compareValues(kind, o.kind, true); 5552 } 5553 5554 public boolean isEmpty() { 5555 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(kind, expression); 5556 } 5557 5558 public String fhirType() { 5559 return "PlanDefinition.action.condition"; 5560 5561 } 5562 5563 } 5564 5565 @Block() 5566 public static class PlanDefinitionActionRelatedActionComponent extends BackboneElement 5567 implements IBaseBackboneElement { 5568 /** 5569 * The element id of the related action. 5570 */ 5571 @Child(name = "actionId", type = { IdType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false) 5572 @Description(shortDefinition = "What action is this related to", formalDefinition = "The element id of the related action.") 5573 protected IdType actionId; 5574 5575 /** 5576 * The relationship of this action to the related action. 5577 */ 5578 @Child(name = "relationship", type = { 5579 CodeType.class }, order = 2, min = 1, max = 1, modifier = false, summary = false) 5580 @Description(shortDefinition = "before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end", formalDefinition = "The relationship of this action to the related action.") 5581 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-relationship-type") 5582 protected Enumeration<ActionRelationshipType> relationship; 5583 5584 /** 5585 * A duration or range of durations to apply to the relationship. For example, 5586 * 30-60 minutes before. 5587 */ 5588 @Child(name = "offset", type = { Duration.class, 5589 Range.class }, order = 3, min = 0, max = 1, modifier = false, summary = false) 5590 @Description(shortDefinition = "Time offset for the relationship", formalDefinition = "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.") 5591 protected Type offset; 5592 5593 private static final long serialVersionUID = 1063306770L; 5594 5595 /** 5596 * Constructor 5597 */ 5598 public PlanDefinitionActionRelatedActionComponent() { 5599 super(); 5600 } 5601 5602 /** 5603 * Constructor 5604 */ 5605 public PlanDefinitionActionRelatedActionComponent(IdType actionId, 5606 Enumeration<ActionRelationshipType> relationship) { 5607 super(); 5608 this.actionId = actionId; 5609 this.relationship = relationship; 5610 } 5611 5612 /** 5613 * @return {@link #actionId} (The element id of the related action.). This is 5614 * the underlying object with id, value and extensions. The accessor 5615 * "getActionId" gives direct access to the value 5616 */ 5617 public IdType getActionIdElement() { 5618 if (this.actionId == null) 5619 if (Configuration.errorOnAutoCreate()) 5620 throw new Error("Attempt to auto-create PlanDefinitionActionRelatedActionComponent.actionId"); 5621 else if (Configuration.doAutoCreate()) 5622 this.actionId = new IdType(); // bb 5623 return this.actionId; 5624 } 5625 5626 public boolean hasActionIdElement() { 5627 return this.actionId != null && !this.actionId.isEmpty(); 5628 } 5629 5630 public boolean hasActionId() { 5631 return this.actionId != null && !this.actionId.isEmpty(); 5632 } 5633 5634 /** 5635 * @param value {@link #actionId} (The element id of the related action.). This 5636 * is the underlying object with id, value and extensions. The 5637 * accessor "getActionId" gives direct access to the value 5638 */ 5639 public PlanDefinitionActionRelatedActionComponent setActionIdElement(IdType value) { 5640 this.actionId = value; 5641 return this; 5642 } 5643 5644 /** 5645 * @return The element id of the related action. 5646 */ 5647 public String getActionId() { 5648 return this.actionId == null ? null : this.actionId.getValue(); 5649 } 5650 5651 /** 5652 * @param value The element id of the related action. 5653 */ 5654 public PlanDefinitionActionRelatedActionComponent setActionId(String value) { 5655 if (this.actionId == null) 5656 this.actionId = new IdType(); 5657 this.actionId.setValue(value); 5658 return this; 5659 } 5660 5661 /** 5662 * @return {@link #relationship} (The relationship of this action to the related 5663 * action.). This is the underlying object with id, value and 5664 * extensions. The accessor "getRelationship" gives direct access to the 5665 * value 5666 */ 5667 public Enumeration<ActionRelationshipType> getRelationshipElement() { 5668 if (this.relationship == null) 5669 if (Configuration.errorOnAutoCreate()) 5670 throw new Error("Attempt to auto-create PlanDefinitionActionRelatedActionComponent.relationship"); 5671 else if (Configuration.doAutoCreate()) 5672 this.relationship = new Enumeration<ActionRelationshipType>(new ActionRelationshipTypeEnumFactory()); // bb 5673 return this.relationship; 5674 } 5675 5676 public boolean hasRelationshipElement() { 5677 return this.relationship != null && !this.relationship.isEmpty(); 5678 } 5679 5680 public boolean hasRelationship() { 5681 return this.relationship != null && !this.relationship.isEmpty(); 5682 } 5683 5684 /** 5685 * @param value {@link #relationship} (The relationship of this action to the 5686 * related action.). This is the underlying object with id, value 5687 * and extensions. The accessor "getRelationship" gives direct 5688 * access to the value 5689 */ 5690 public PlanDefinitionActionRelatedActionComponent setRelationshipElement( 5691 Enumeration<ActionRelationshipType> value) { 5692 this.relationship = value; 5693 return this; 5694 } 5695 5696 /** 5697 * @return The relationship of this action to the related action. 5698 */ 5699 public ActionRelationshipType getRelationship() { 5700 return this.relationship == null ? null : this.relationship.getValue(); 5701 } 5702 5703 /** 5704 * @param value The relationship of this action to the related action. 5705 */ 5706 public PlanDefinitionActionRelatedActionComponent setRelationship(ActionRelationshipType value) { 5707 if (this.relationship == null) 5708 this.relationship = new Enumeration<ActionRelationshipType>(new ActionRelationshipTypeEnumFactory()); 5709 this.relationship.setValue(value); 5710 return this; 5711 } 5712 5713 /** 5714 * @return {@link #offset} (A duration or range of durations to apply to the 5715 * relationship. For example, 30-60 minutes before.) 5716 */ 5717 public Type getOffset() { 5718 return this.offset; 5719 } 5720 5721 /** 5722 * @return {@link #offset} (A duration or range of durations to apply to the 5723 * relationship. For example, 30-60 minutes before.) 5724 */ 5725 public Duration getOffsetDuration() throws FHIRException { 5726 if (this.offset == null) 5727 this.offset = new Duration(); 5728 if (!(this.offset instanceof Duration)) 5729 throw new FHIRException("Type mismatch: the type Duration was expected, but " + this.offset.getClass().getName() 5730 + " was encountered"); 5731 return (Duration) this.offset; 5732 } 5733 5734 public boolean hasOffsetDuration() { 5735 return this != null && this.offset instanceof Duration; 5736 } 5737 5738 /** 5739 * @return {@link #offset} (A duration or range of durations to apply to the 5740 * relationship. For example, 30-60 minutes before.) 5741 */ 5742 public Range getOffsetRange() throws FHIRException { 5743 if (this.offset == null) 5744 this.offset = new Range(); 5745 if (!(this.offset instanceof Range)) 5746 throw new FHIRException( 5747 "Type mismatch: the type Range was expected, but " + this.offset.getClass().getName() + " was encountered"); 5748 return (Range) this.offset; 5749 } 5750 5751 public boolean hasOffsetRange() { 5752 return this != null && this.offset instanceof Range; 5753 } 5754 5755 public boolean hasOffset() { 5756 return this.offset != null && !this.offset.isEmpty(); 5757 } 5758 5759 /** 5760 * @param value {@link #offset} (A duration or range of durations to apply to 5761 * the relationship. For example, 30-60 minutes before.) 5762 */ 5763 public PlanDefinitionActionRelatedActionComponent setOffset(Type value) { 5764 if (value != null && !(value instanceof Duration || value instanceof Range)) 5765 throw new Error("Not the right type for PlanDefinition.action.relatedAction.offset[x]: " + value.fhirType()); 5766 this.offset = value; 5767 return this; 5768 } 5769 5770 protected void listChildren(List<Property> children) { 5771 super.listChildren(children); 5772 children.add(new Property("actionId", "id", "The element id of the related action.", 0, 1, actionId)); 5773 children.add(new Property("relationship", "code", "The relationship of this action to the related action.", 0, 1, 5774 relationship)); 5775 children.add(new Property("offset[x]", "Duration|Range", 5776 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 5777 offset)); 5778 } 5779 5780 @Override 5781 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5782 switch (_hash) { 5783 case -1656172047: 5784 /* actionId */ return new Property("actionId", "id", "The element id of the related action.", 0, 1, actionId); 5785 case -261851592: 5786 /* relationship */ return new Property("relationship", "code", 5787 "The relationship of this action to the related action.", 0, 1, relationship); 5788 case -1960684787: 5789 /* offset[x] */ return new Property("offset[x]", "Duration|Range", 5790 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 5791 offset); 5792 case -1019779949: 5793 /* offset */ return new Property("offset[x]", "Duration|Range", 5794 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 5795 offset); 5796 case 134075207: 5797 /* offsetDuration */ return new Property("offset[x]", "Duration|Range", 5798 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 5799 offset); 5800 case 1263585386: 5801 /* offsetRange */ return new Property("offset[x]", "Duration|Range", 5802 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 5803 offset); 5804 default: 5805 return super.getNamedProperty(_hash, _name, _checkValid); 5806 } 5807 5808 } 5809 5810 @Override 5811 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5812 switch (hash) { 5813 case -1656172047: 5814 /* actionId */ return this.actionId == null ? new Base[0] : new Base[] { this.actionId }; // IdType 5815 case -261851592: 5816 /* relationship */ return this.relationship == null ? new Base[0] : new Base[] { this.relationship }; // Enumeration<ActionRelationshipType> 5817 case -1019779949: 5818 /* offset */ return this.offset == null ? new Base[0] : new Base[] { this.offset }; // Type 5819 default: 5820 return super.getProperty(hash, name, checkValid); 5821 } 5822 5823 } 5824 5825 @Override 5826 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5827 switch (hash) { 5828 case -1656172047: // actionId 5829 this.actionId = castToId(value); // IdType 5830 return value; 5831 case -261851592: // relationship 5832 value = new ActionRelationshipTypeEnumFactory().fromType(castToCode(value)); 5833 this.relationship = (Enumeration) value; // Enumeration<ActionRelationshipType> 5834 return value; 5835 case -1019779949: // offset 5836 this.offset = castToType(value); // Type 5837 return value; 5838 default: 5839 return super.setProperty(hash, name, value); 5840 } 5841 5842 } 5843 5844 @Override 5845 public Base setProperty(String name, Base value) throws FHIRException { 5846 if (name.equals("actionId")) { 5847 this.actionId = castToId(value); // IdType 5848 } else if (name.equals("relationship")) { 5849 value = new ActionRelationshipTypeEnumFactory().fromType(castToCode(value)); 5850 this.relationship = (Enumeration) value; // Enumeration<ActionRelationshipType> 5851 } else if (name.equals("offset[x]")) { 5852 this.offset = castToType(value); // Type 5853 } else 5854 return super.setProperty(name, value); 5855 return value; 5856 } 5857 5858 @Override 5859 public void removeChild(String name, Base value) throws FHIRException { 5860 if (name.equals("actionId")) { 5861 this.actionId = null; 5862 } else if (name.equals("relationship")) { 5863 this.relationship = null; 5864 } else if (name.equals("offset[x]")) { 5865 this.offset = null; 5866 } else 5867 super.removeChild(name, value); 5868 5869 } 5870 5871 @Override 5872 public Base makeProperty(int hash, String name) throws FHIRException { 5873 switch (hash) { 5874 case -1656172047: 5875 return getActionIdElement(); 5876 case -261851592: 5877 return getRelationshipElement(); 5878 case -1960684787: 5879 return getOffset(); 5880 case -1019779949: 5881 return getOffset(); 5882 default: 5883 return super.makeProperty(hash, name); 5884 } 5885 5886 } 5887 5888 @Override 5889 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5890 switch (hash) { 5891 case -1656172047: 5892 /* actionId */ return new String[] { "id" }; 5893 case -261851592: 5894 /* relationship */ return new String[] { "code" }; 5895 case -1019779949: 5896 /* offset */ return new String[] { "Duration", "Range" }; 5897 default: 5898 return super.getTypesForProperty(hash, name); 5899 } 5900 5901 } 5902 5903 @Override 5904 public Base addChild(String name) throws FHIRException { 5905 if (name.equals("actionId")) { 5906 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.actionId"); 5907 } else if (name.equals("relationship")) { 5908 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.relationship"); 5909 } else if (name.equals("offsetDuration")) { 5910 this.offset = new Duration(); 5911 return this.offset; 5912 } else if (name.equals("offsetRange")) { 5913 this.offset = new Range(); 5914 return this.offset; 5915 } else 5916 return super.addChild(name); 5917 } 5918 5919 public PlanDefinitionActionRelatedActionComponent copy() { 5920 PlanDefinitionActionRelatedActionComponent dst = new PlanDefinitionActionRelatedActionComponent(); 5921 copyValues(dst); 5922 return dst; 5923 } 5924 5925 public void copyValues(PlanDefinitionActionRelatedActionComponent dst) { 5926 super.copyValues(dst); 5927 dst.actionId = actionId == null ? null : actionId.copy(); 5928 dst.relationship = relationship == null ? null : relationship.copy(); 5929 dst.offset = offset == null ? null : offset.copy(); 5930 } 5931 5932 @Override 5933 public boolean equalsDeep(Base other_) { 5934 if (!super.equalsDeep(other_)) 5935 return false; 5936 if (!(other_ instanceof PlanDefinitionActionRelatedActionComponent)) 5937 return false; 5938 PlanDefinitionActionRelatedActionComponent o = (PlanDefinitionActionRelatedActionComponent) other_; 5939 return compareDeep(actionId, o.actionId, true) && compareDeep(relationship, o.relationship, true) 5940 && compareDeep(offset, o.offset, true); 5941 } 5942 5943 @Override 5944 public boolean equalsShallow(Base other_) { 5945 if (!super.equalsShallow(other_)) 5946 return false; 5947 if (!(other_ instanceof PlanDefinitionActionRelatedActionComponent)) 5948 return false; 5949 PlanDefinitionActionRelatedActionComponent o = (PlanDefinitionActionRelatedActionComponent) other_; 5950 return compareValues(actionId, o.actionId, true) && compareValues(relationship, o.relationship, true); 5951 } 5952 5953 public boolean isEmpty() { 5954 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(actionId, relationship, offset); 5955 } 5956 5957 public String fhirType() { 5958 return "PlanDefinition.action.relatedAction"; 5959 5960 } 5961 5962 } 5963 5964 @Block() 5965 public static class PlanDefinitionActionParticipantComponent extends BackboneElement implements IBaseBackboneElement { 5966 /** 5967 * The type of participant in the action. 5968 */ 5969 @Child(name = "type", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false) 5970 @Description(shortDefinition = "patient | practitioner | related-person | device", formalDefinition = "The type of participant in the action.") 5971 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-participant-type") 5972 protected Enumeration<ActionParticipantType> type; 5973 5974 /** 5975 * The role the participant should play in performing the described action. 5976 */ 5977 @Child(name = "role", type = { 5978 CodeableConcept.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 5979 @Description(shortDefinition = "E.g. Nurse, Surgeon, Parent", formalDefinition = "The role the participant should play in performing the described action.") 5980 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-participant-role") 5981 protected CodeableConcept role; 5982 5983 private static final long serialVersionUID = -1152013659L; 5984 5985 /** 5986 * Constructor 5987 */ 5988 public PlanDefinitionActionParticipantComponent() { 5989 super(); 5990 } 5991 5992 /** 5993 * Constructor 5994 */ 5995 public PlanDefinitionActionParticipantComponent(Enumeration<ActionParticipantType> type) { 5996 super(); 5997 this.type = type; 5998 } 5999 6000 /** 6001 * @return {@link #type} (The type of participant in the action.). This is the 6002 * underlying object with id, value and extensions. The accessor 6003 * "getType" gives direct access to the value 6004 */ 6005 public Enumeration<ActionParticipantType> getTypeElement() { 6006 if (this.type == null) 6007 if (Configuration.errorOnAutoCreate()) 6008 throw new Error("Attempt to auto-create PlanDefinitionActionParticipantComponent.type"); 6009 else if (Configuration.doAutoCreate()) 6010 this.type = new Enumeration<ActionParticipantType>(new ActionParticipantTypeEnumFactory()); // bb 6011 return this.type; 6012 } 6013 6014 public boolean hasTypeElement() { 6015 return this.type != null && !this.type.isEmpty(); 6016 } 6017 6018 public boolean hasType() { 6019 return this.type != null && !this.type.isEmpty(); 6020 } 6021 6022 /** 6023 * @param value {@link #type} (The type of participant in the action.). This is 6024 * the underlying object with id, value and extensions. The 6025 * accessor "getType" gives direct access to the value 6026 */ 6027 public PlanDefinitionActionParticipantComponent setTypeElement(Enumeration<ActionParticipantType> value) { 6028 this.type = value; 6029 return this; 6030 } 6031 6032 /** 6033 * @return The type of participant in the action. 6034 */ 6035 public ActionParticipantType getType() { 6036 return this.type == null ? null : this.type.getValue(); 6037 } 6038 6039 /** 6040 * @param value The type of participant in the action. 6041 */ 6042 public PlanDefinitionActionParticipantComponent setType(ActionParticipantType value) { 6043 if (this.type == null) 6044 this.type = new Enumeration<ActionParticipantType>(new ActionParticipantTypeEnumFactory()); 6045 this.type.setValue(value); 6046 return this; 6047 } 6048 6049 /** 6050 * @return {@link #role} (The role the participant should play in performing the 6051 * described action.) 6052 */ 6053 public CodeableConcept getRole() { 6054 if (this.role == null) 6055 if (Configuration.errorOnAutoCreate()) 6056 throw new Error("Attempt to auto-create PlanDefinitionActionParticipantComponent.role"); 6057 else if (Configuration.doAutoCreate()) 6058 this.role = new CodeableConcept(); // cc 6059 return this.role; 6060 } 6061 6062 public boolean hasRole() { 6063 return this.role != null && !this.role.isEmpty(); 6064 } 6065 6066 /** 6067 * @param value {@link #role} (The role the participant should play in 6068 * performing the described action.) 6069 */ 6070 public PlanDefinitionActionParticipantComponent setRole(CodeableConcept value) { 6071 this.role = value; 6072 return this; 6073 } 6074 6075 protected void listChildren(List<Property> children) { 6076 super.listChildren(children); 6077 children.add(new Property("type", "code", "The type of participant in the action.", 0, 1, type)); 6078 children.add(new Property("role", "CodeableConcept", 6079 "The role the participant should play in performing the described action.", 0, 1, role)); 6080 } 6081 6082 @Override 6083 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 6084 switch (_hash) { 6085 case 3575610: 6086 /* type */ return new Property("type", "code", "The type of participant in the action.", 0, 1, type); 6087 case 3506294: 6088 /* role */ return new Property("role", "CodeableConcept", 6089 "The role the participant should play in performing the described action.", 0, 1, role); 6090 default: 6091 return super.getNamedProperty(_hash, _name, _checkValid); 6092 } 6093 6094 } 6095 6096 @Override 6097 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 6098 switch (hash) { 6099 case 3575610: 6100 /* type */ return this.type == null ? new Base[0] : new Base[] { this.type }; // Enumeration<ActionParticipantType> 6101 case 3506294: 6102 /* role */ return this.role == null ? new Base[0] : new Base[] { this.role }; // CodeableConcept 6103 default: 6104 return super.getProperty(hash, name, checkValid); 6105 } 6106 6107 } 6108 6109 @Override 6110 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6111 switch (hash) { 6112 case 3575610: // type 6113 value = new ActionParticipantTypeEnumFactory().fromType(castToCode(value)); 6114 this.type = (Enumeration) value; // Enumeration<ActionParticipantType> 6115 return value; 6116 case 3506294: // role 6117 this.role = castToCodeableConcept(value); // CodeableConcept 6118 return value; 6119 default: 6120 return super.setProperty(hash, name, value); 6121 } 6122 6123 } 6124 6125 @Override 6126 public Base setProperty(String name, Base value) throws FHIRException { 6127 if (name.equals("type")) { 6128 value = new ActionParticipantTypeEnumFactory().fromType(castToCode(value)); 6129 this.type = (Enumeration) value; // Enumeration<ActionParticipantType> 6130 } else if (name.equals("role")) { 6131 this.role = castToCodeableConcept(value); // CodeableConcept 6132 } else 6133 return super.setProperty(name, value); 6134 return value; 6135 } 6136 6137 @Override 6138 public void removeChild(String name, Base value) throws FHIRException { 6139 if (name.equals("type")) { 6140 this.type = null; 6141 } else if (name.equals("role")) { 6142 this.role = null; 6143 } else 6144 super.removeChild(name, value); 6145 6146 } 6147 6148 @Override 6149 public Base makeProperty(int hash, String name) throws FHIRException { 6150 switch (hash) { 6151 case 3575610: 6152 return getTypeElement(); 6153 case 3506294: 6154 return getRole(); 6155 default: 6156 return super.makeProperty(hash, name); 6157 } 6158 6159 } 6160 6161 @Override 6162 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6163 switch (hash) { 6164 case 3575610: 6165 /* type */ return new String[] { "code" }; 6166 case 3506294: 6167 /* role */ return new String[] { "CodeableConcept" }; 6168 default: 6169 return super.getTypesForProperty(hash, name); 6170 } 6171 6172 } 6173 6174 @Override 6175 public Base addChild(String name) throws FHIRException { 6176 if (name.equals("type")) { 6177 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.type"); 6178 } else if (name.equals("role")) { 6179 this.role = new CodeableConcept(); 6180 return this.role; 6181 } else 6182 return super.addChild(name); 6183 } 6184 6185 public PlanDefinitionActionParticipantComponent copy() { 6186 PlanDefinitionActionParticipantComponent dst = new PlanDefinitionActionParticipantComponent(); 6187 copyValues(dst); 6188 return dst; 6189 } 6190 6191 public void copyValues(PlanDefinitionActionParticipantComponent dst) { 6192 super.copyValues(dst); 6193 dst.type = type == null ? null : type.copy(); 6194 dst.role = role == null ? null : role.copy(); 6195 } 6196 6197 @Override 6198 public boolean equalsDeep(Base other_) { 6199 if (!super.equalsDeep(other_)) 6200 return false; 6201 if (!(other_ instanceof PlanDefinitionActionParticipantComponent)) 6202 return false; 6203 PlanDefinitionActionParticipantComponent o = (PlanDefinitionActionParticipantComponent) other_; 6204 return compareDeep(type, o.type, true) && compareDeep(role, o.role, true); 6205 } 6206 6207 @Override 6208 public boolean equalsShallow(Base other_) { 6209 if (!super.equalsShallow(other_)) 6210 return false; 6211 if (!(other_ instanceof PlanDefinitionActionParticipantComponent)) 6212 return false; 6213 PlanDefinitionActionParticipantComponent o = (PlanDefinitionActionParticipantComponent) other_; 6214 return compareValues(type, o.type, true); 6215 } 6216 6217 public boolean isEmpty() { 6218 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, role); 6219 } 6220 6221 public String fhirType() { 6222 return "PlanDefinition.action.participant"; 6223 6224 } 6225 6226 } 6227 6228 @Block() 6229 public static class PlanDefinitionActionDynamicValueComponent extends BackboneElement 6230 implements IBaseBackboneElement { 6231 /** 6232 * The path to the element to be customized. This is the path on the resource 6233 * that will hold the result of the calculation defined by the expression. The 6234 * specified path SHALL be a FHIRPath resolveable on the specified target type 6235 * of the ActivityDefinition, and SHALL consist only of identifiers, constant 6236 * indexers, and a restricted subset of functions. The path is allowed to 6237 * contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to 6238 * traverse multiple-cardinality sub-elements (see the [Simple FHIRPath 6239 * Profile](fhirpath.html#simple) for full details). 6240 */ 6241 @Child(name = "path", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false) 6242 @Description(shortDefinition = "The path to the element to be set dynamically", formalDefinition = "The path to the element to be customized. This is the path on the resource that will hold the result of the calculation defined by the expression. The specified path SHALL be a FHIRPath resolveable on the specified target type of the ActivityDefinition, and SHALL consist only of identifiers, constant indexers, and a restricted subset of functions. The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).") 6243 protected StringType path; 6244 6245 /** 6246 * An expression specifying the value of the customized element. 6247 */ 6248 @Child(name = "expression", type = { 6249 Expression.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 6250 @Description(shortDefinition = "An expression that provides the dynamic value for the customization", formalDefinition = "An expression specifying the value of the customized element.") 6251 protected Expression expression; 6252 6253 private static final long serialVersionUID = 1064529082L; 6254 6255 /** 6256 * Constructor 6257 */ 6258 public PlanDefinitionActionDynamicValueComponent() { 6259 super(); 6260 } 6261 6262 /** 6263 * @return {@link #path} (The path to the element to be customized. This is the 6264 * path on the resource that will hold the result of the calculation 6265 * defined by the expression. The specified path SHALL be a FHIRPath 6266 * resolveable on the specified target type of the ActivityDefinition, 6267 * and SHALL consist only of identifiers, constant indexers, and a 6268 * restricted subset of functions. The path is allowed to contain 6269 * qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to 6270 * traverse multiple-cardinality sub-elements (see the [Simple FHIRPath 6271 * Profile](fhirpath.html#simple) for full details).). This is the 6272 * underlying object with id, value and extensions. The accessor 6273 * "getPath" gives direct access to the value 6274 */ 6275 public StringType getPathElement() { 6276 if (this.path == null) 6277 if (Configuration.errorOnAutoCreate()) 6278 throw new Error("Attempt to auto-create PlanDefinitionActionDynamicValueComponent.path"); 6279 else if (Configuration.doAutoCreate()) 6280 this.path = new StringType(); // bb 6281 return this.path; 6282 } 6283 6284 public boolean hasPathElement() { 6285 return this.path != null && !this.path.isEmpty(); 6286 } 6287 6288 public boolean hasPath() { 6289 return this.path != null && !this.path.isEmpty(); 6290 } 6291 6292 /** 6293 * @param value {@link #path} (The path to the element to be customized. This is 6294 * the path on the resource that will hold the result of the 6295 * calculation defined by the expression. The specified path SHALL 6296 * be a FHIRPath resolveable on the specified target type of the 6297 * ActivityDefinition, and SHALL consist only of identifiers, 6298 * constant indexers, and a restricted subset of functions. The 6299 * path is allowed to contain qualifiers (.) to traverse 6300 * sub-elements, as well as indexers ([x]) to traverse 6301 * multiple-cardinality sub-elements (see the [Simple FHIRPath 6302 * Profile](fhirpath.html#simple) for full details).). This is the 6303 * underlying object with id, value and extensions. The accessor 6304 * "getPath" gives direct access to the value 6305 */ 6306 public PlanDefinitionActionDynamicValueComponent setPathElement(StringType value) { 6307 this.path = value; 6308 return this; 6309 } 6310 6311 /** 6312 * @return The path to the element to be customized. This is the path on the 6313 * resource that will hold the result of the calculation defined by the 6314 * expression. The specified path SHALL be a FHIRPath resolveable on the 6315 * specified target type of the ActivityDefinition, and SHALL consist 6316 * only of identifiers, constant indexers, and a restricted subset of 6317 * functions. The path is allowed to contain qualifiers (.) to traverse 6318 * sub-elements, as well as indexers ([x]) to traverse 6319 * multiple-cardinality sub-elements (see the [Simple FHIRPath 6320 * Profile](fhirpath.html#simple) for full details). 6321 */ 6322 public String getPath() { 6323 return this.path == null ? null : this.path.getValue(); 6324 } 6325 6326 /** 6327 * @param value The path to the element to be customized. This is the path on 6328 * the resource that will hold the result of the calculation 6329 * defined by the expression. The specified path SHALL be a 6330 * FHIRPath resolveable on the specified target type of the 6331 * ActivityDefinition, and SHALL consist only of identifiers, 6332 * constant indexers, and a restricted subset of functions. The 6333 * path is allowed to contain qualifiers (.) to traverse 6334 * sub-elements, as well as indexers ([x]) to traverse 6335 * multiple-cardinality sub-elements (see the [Simple FHIRPath 6336 * Profile](fhirpath.html#simple) for full details). 6337 */ 6338 public PlanDefinitionActionDynamicValueComponent setPath(String value) { 6339 if (Utilities.noString(value)) 6340 this.path = null; 6341 else { 6342 if (this.path == null) 6343 this.path = new StringType(); 6344 this.path.setValue(value); 6345 } 6346 return this; 6347 } 6348 6349 /** 6350 * @return {@link #expression} (An expression specifying the value of the 6351 * customized element.) 6352 */ 6353 public Expression getExpression() { 6354 if (this.expression == null) 6355 if (Configuration.errorOnAutoCreate()) 6356 throw new Error("Attempt to auto-create PlanDefinitionActionDynamicValueComponent.expression"); 6357 else if (Configuration.doAutoCreate()) 6358 this.expression = new Expression(); // cc 6359 return this.expression; 6360 } 6361 6362 public boolean hasExpression() { 6363 return this.expression != null && !this.expression.isEmpty(); 6364 } 6365 6366 /** 6367 * @param value {@link #expression} (An expression specifying the value of the 6368 * customized element.) 6369 */ 6370 public PlanDefinitionActionDynamicValueComponent setExpression(Expression value) { 6371 this.expression = value; 6372 return this; 6373 } 6374 6375 protected void listChildren(List<Property> children) { 6376 super.listChildren(children); 6377 children.add(new Property("path", "string", 6378 "The path to the element to be customized. This is the path on the resource that will hold the result of the calculation defined by the expression. The specified path SHALL be a FHIRPath resolveable on the specified target type of the ActivityDefinition, and SHALL consist only of identifiers, constant indexers, and a restricted subset of functions. The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).", 6379 0, 1, path)); 6380 children.add(new Property("expression", "Expression", 6381 "An expression specifying the value of the customized element.", 0, 1, expression)); 6382 } 6383 6384 @Override 6385 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 6386 switch (_hash) { 6387 case 3433509: 6388 /* path */ return new Property("path", "string", 6389 "The path to the element to be customized. This is the path on the resource that will hold the result of the calculation defined by the expression. The specified path SHALL be a FHIRPath resolveable on the specified target type of the ActivityDefinition, and SHALL consist only of identifiers, constant indexers, and a restricted subset of functions. The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).", 6390 0, 1, path); 6391 case -1795452264: 6392 /* expression */ return new Property("expression", "Expression", 6393 "An expression specifying the value of the customized element.", 0, 1, expression); 6394 default: 6395 return super.getNamedProperty(_hash, _name, _checkValid); 6396 } 6397 6398 } 6399 6400 @Override 6401 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 6402 switch (hash) { 6403 case 3433509: 6404 /* path */ return this.path == null ? new Base[0] : new Base[] { this.path }; // StringType 6405 case -1795452264: 6406 /* expression */ return this.expression == null ? new Base[0] : new Base[] { this.expression }; // Expression 6407 default: 6408 return super.getProperty(hash, name, checkValid); 6409 } 6410 6411 } 6412 6413 @Override 6414 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6415 switch (hash) { 6416 case 3433509: // path 6417 this.path = castToString(value); // StringType 6418 return value; 6419 case -1795452264: // expression 6420 this.expression = castToExpression(value); // Expression 6421 return value; 6422 default: 6423 return super.setProperty(hash, name, value); 6424 } 6425 6426 } 6427 6428 @Override 6429 public Base setProperty(String name, Base value) throws FHIRException { 6430 if (name.equals("path")) { 6431 this.path = castToString(value); // StringType 6432 } else if (name.equals("expression")) { 6433 this.expression = castToExpression(value); // Expression 6434 } else 6435 return super.setProperty(name, value); 6436 return value; 6437 } 6438 6439 @Override 6440 public void removeChild(String name, Base value) throws FHIRException { 6441 if (name.equals("path")) { 6442 this.path = null; 6443 } else if (name.equals("expression")) { 6444 this.expression = null; 6445 } else 6446 super.removeChild(name, value); 6447 6448 } 6449 6450 @Override 6451 public Base makeProperty(int hash, String name) throws FHIRException { 6452 switch (hash) { 6453 case 3433509: 6454 return getPathElement(); 6455 case -1795452264: 6456 return getExpression(); 6457 default: 6458 return super.makeProperty(hash, name); 6459 } 6460 6461 } 6462 6463 @Override 6464 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6465 switch (hash) { 6466 case 3433509: 6467 /* path */ return new String[] { "string" }; 6468 case -1795452264: 6469 /* expression */ return new String[] { "Expression" }; 6470 default: 6471 return super.getTypesForProperty(hash, name); 6472 } 6473 6474 } 6475 6476 @Override 6477 public Base addChild(String name) throws FHIRException { 6478 if (name.equals("path")) { 6479 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.path"); 6480 } else if (name.equals("expression")) { 6481 this.expression = new Expression(); 6482 return this.expression; 6483 } else 6484 return super.addChild(name); 6485 } 6486 6487 public PlanDefinitionActionDynamicValueComponent copy() { 6488 PlanDefinitionActionDynamicValueComponent dst = new PlanDefinitionActionDynamicValueComponent(); 6489 copyValues(dst); 6490 return dst; 6491 } 6492 6493 public void copyValues(PlanDefinitionActionDynamicValueComponent dst) { 6494 super.copyValues(dst); 6495 dst.path = path == null ? null : path.copy(); 6496 dst.expression = expression == null ? null : expression.copy(); 6497 } 6498 6499 @Override 6500 public boolean equalsDeep(Base other_) { 6501 if (!super.equalsDeep(other_)) 6502 return false; 6503 if (!(other_ instanceof PlanDefinitionActionDynamicValueComponent)) 6504 return false; 6505 PlanDefinitionActionDynamicValueComponent o = (PlanDefinitionActionDynamicValueComponent) other_; 6506 return compareDeep(path, o.path, true) && compareDeep(expression, o.expression, true); 6507 } 6508 6509 @Override 6510 public boolean equalsShallow(Base other_) { 6511 if (!super.equalsShallow(other_)) 6512 return false; 6513 if (!(other_ instanceof PlanDefinitionActionDynamicValueComponent)) 6514 return false; 6515 PlanDefinitionActionDynamicValueComponent o = (PlanDefinitionActionDynamicValueComponent) other_; 6516 return compareValues(path, o.path, true); 6517 } 6518 6519 public boolean isEmpty() { 6520 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(path, expression); 6521 } 6522 6523 public String fhirType() { 6524 return "PlanDefinition.action.dynamicValue"; 6525 6526 } 6527 6528 } 6529 6530 /** 6531 * A formal identifier that is used to identify this plan definition when it is 6532 * represented in other formats, or referenced in a specification, model, design 6533 * or an instance. 6534 */ 6535 @Child(name = "identifier", type = { 6536 Identifier.class }, order = 0, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 6537 @Description(shortDefinition = "Additional identifier for the plan definition", formalDefinition = "A formal identifier that is used to identify this plan definition when it is represented in other formats, or referenced in a specification, model, design or an instance.") 6538 protected List<Identifier> identifier; 6539 6540 /** 6541 * An explanatory or alternate title for the plan definition giving additional 6542 * information about its content. 6543 */ 6544 @Child(name = "subtitle", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false) 6545 @Description(shortDefinition = "Subordinate title of the plan definition", formalDefinition = "An explanatory or alternate title for the plan definition giving additional information about its content.") 6546 protected StringType subtitle; 6547 6548 /** 6549 * A high-level category for the plan definition that distinguishes the kinds of 6550 * systems that would be interested in the plan definition. 6551 */ 6552 @Child(name = "type", type = { CodeableConcept.class }, order = 2, min = 0, max = 1, modifier = false, summary = true) 6553 @Description(shortDefinition = "order-set | clinical-protocol | eca-rule | workflow-definition", formalDefinition = "A high-level category for the plan definition that distinguishes the kinds of systems that would be interested in the plan definition.") 6554 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/plan-definition-type") 6555 protected CodeableConcept type; 6556 6557 /** 6558 * A code or group definition that describes the intended subject of the plan 6559 * definition. 6560 */ 6561 @Child(name = "subject", type = { CodeableConcept.class, 6562 Group.class }, order = 3, min = 0, max = 1, modifier = false, summary = false) 6563 @Description(shortDefinition = "Type of individual the plan definition is focused on", formalDefinition = "A code or group definition that describes the intended subject of the plan definition.") 6564 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/subject-type") 6565 protected Type subject; 6566 6567 /** 6568 * Explanation of why this plan definition is needed and why it has been 6569 * designed as it has. 6570 */ 6571 @Child(name = "purpose", type = { 6572 MarkdownType.class }, order = 4, min = 0, max = 1, modifier = false, summary = false) 6573 @Description(shortDefinition = "Why this plan definition is defined", formalDefinition = "Explanation of why this plan definition is needed and why it has been designed as it has.") 6574 protected MarkdownType purpose; 6575 6576 /** 6577 * A detailed description of how the plan definition is used from a clinical 6578 * perspective. 6579 */ 6580 @Child(name = "usage", type = { StringType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false) 6581 @Description(shortDefinition = "Describes the clinical usage of the plan", formalDefinition = "A detailed description of how the plan definition is used from a clinical perspective.") 6582 protected StringType usage; 6583 6584 /** 6585 * A copyright statement relating to the plan definition and/or its contents. 6586 * Copyright statements are generally legal restrictions on the use and 6587 * publishing of the plan definition. 6588 */ 6589 @Child(name = "copyright", type = { 6590 MarkdownType.class }, order = 6, min = 0, max = 1, modifier = false, summary = false) 6591 @Description(shortDefinition = "Use and/or publishing restrictions", formalDefinition = "A copyright statement relating to the plan definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the plan definition.") 6592 protected MarkdownType copyright; 6593 6594 /** 6595 * The date on which the resource content was approved by the publisher. 6596 * Approval happens once when the content is officially approved for usage. 6597 */ 6598 @Child(name = "approvalDate", type = { 6599 DateType.class }, order = 7, min = 0, max = 1, modifier = false, summary = false) 6600 @Description(shortDefinition = "When the plan definition was approved by publisher", formalDefinition = "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.") 6601 protected DateType approvalDate; 6602 6603 /** 6604 * The date on which the resource content was last reviewed. Review happens 6605 * periodically after approval but does not change the original approval date. 6606 */ 6607 @Child(name = "lastReviewDate", type = { 6608 DateType.class }, order = 8, min = 0, max = 1, modifier = false, summary = false) 6609 @Description(shortDefinition = "When the plan definition was last reviewed", formalDefinition = "The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date.") 6610 protected DateType lastReviewDate; 6611 6612 /** 6613 * The period during which the plan definition content was or is planned to be 6614 * in active use. 6615 */ 6616 @Child(name = "effectivePeriod", type = { 6617 Period.class }, order = 9, min = 0, max = 1, modifier = false, summary = true) 6618 @Description(shortDefinition = "When the plan definition is expected to be used", formalDefinition = "The period during which the plan definition content was or is planned to be in active use.") 6619 protected Period effectivePeriod; 6620 6621 /** 6622 * Descriptive topics related to the content of the plan definition. Topics 6623 * provide a high-level categorization of the definition that can be useful for 6624 * filtering and searching. 6625 */ 6626 @Child(name = "topic", type = { 6627 CodeableConcept.class }, order = 10, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6628 @Description(shortDefinition = "E.g. Education, Treatment, Assessment", formalDefinition = "Descriptive topics related to the content of the plan definition. Topics provide a high-level categorization of the definition that can be useful for filtering and searching.") 6629 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/definition-topic") 6630 protected List<CodeableConcept> topic; 6631 6632 /** 6633 * An individiual or organization primarily involved in the creation and 6634 * maintenance of the content. 6635 */ 6636 @Child(name = "author", type = { 6637 ContactDetail.class }, order = 11, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6638 @Description(shortDefinition = "Who authored the content", formalDefinition = "An individiual or organization primarily involved in the creation and maintenance of the content.") 6639 protected List<ContactDetail> author; 6640 6641 /** 6642 * An individual or organization primarily responsible for internal coherence of 6643 * the content. 6644 */ 6645 @Child(name = "editor", type = { 6646 ContactDetail.class }, order = 12, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6647 @Description(shortDefinition = "Who edited the content", formalDefinition = "An individual or organization primarily responsible for internal coherence of the content.") 6648 protected List<ContactDetail> editor; 6649 6650 /** 6651 * An individual or organization primarily responsible for review of some aspect 6652 * of the content. 6653 */ 6654 @Child(name = "reviewer", type = { 6655 ContactDetail.class }, order = 13, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6656 @Description(shortDefinition = "Who reviewed the content", formalDefinition = "An individual or organization primarily responsible for review of some aspect of the content.") 6657 protected List<ContactDetail> reviewer; 6658 6659 /** 6660 * An individual or organization responsible for officially endorsing the 6661 * content for use in some setting. 6662 */ 6663 @Child(name = "endorser", type = { 6664 ContactDetail.class }, order = 14, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6665 @Description(shortDefinition = "Who endorsed the content", formalDefinition = "An individual or organization responsible for officially endorsing the content for use in some setting.") 6666 protected List<ContactDetail> endorser; 6667 6668 /** 6669 * Related artifacts such as additional documentation, justification, or 6670 * bibliographic references. 6671 */ 6672 @Child(name = "relatedArtifact", type = { 6673 RelatedArtifact.class }, order = 15, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6674 @Description(shortDefinition = "Additional documentation, citations", formalDefinition = "Related artifacts such as additional documentation, justification, or bibliographic references.") 6675 protected List<RelatedArtifact> relatedArtifact; 6676 6677 /** 6678 * A reference to a Library resource containing any formal logic used by the 6679 * plan definition. 6680 */ 6681 @Child(name = "library", type = { 6682 CanonicalType.class }, order = 16, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6683 @Description(shortDefinition = "Logic used by the plan definition", formalDefinition = "A reference to a Library resource containing any formal logic used by the plan definition.") 6684 protected List<CanonicalType> library; 6685 6686 /** 6687 * Goals that describe what the activities within the plan are intended to 6688 * achieve. For example, weight loss, restoring an activity of daily living, 6689 * obtaining herd immunity via immunization, meeting a process improvement 6690 * objective, etc. 6691 */ 6692 @Child(name = "goal", type = {}, order = 17, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6693 @Description(shortDefinition = "What the plan is trying to accomplish", formalDefinition = "Goals that describe what the activities within the plan are intended to achieve. For example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.") 6694 protected List<PlanDefinitionGoalComponent> goal; 6695 6696 /** 6697 * An action or group of actions to be taken as part of the plan. 6698 */ 6699 @Child(name = "action", type = {}, order = 18, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 6700 @Description(shortDefinition = "Action defined by the plan", formalDefinition = "An action or group of actions to be taken as part of the plan.") 6701 protected List<PlanDefinitionActionComponent> action; 6702 6703 private static final long serialVersionUID = -1725695645L; 6704 6705 /** 6706 * Constructor 6707 */ 6708 public PlanDefinition() { 6709 super(); 6710 } 6711 6712 /** 6713 * Constructor 6714 */ 6715 public PlanDefinition(Enumeration<PublicationStatus> status) { 6716 super(); 6717 this.status = status; 6718 } 6719 6720 /** 6721 * @return {@link #url} (An absolute URI that is used to identify this plan 6722 * definition when it is referenced in a specification, model, design or 6723 * an instance; also called its canonical identifier. This SHOULD be 6724 * globally unique and SHOULD be a literal address at which at which an 6725 * authoritative instance of this plan definition is (or will be) 6726 * published. This URL can be the target of a canonical reference. It 6727 * SHALL remain the same when the plan definition is stored on different 6728 * servers.). This is the underlying object with id, value and 6729 * extensions. The accessor "getUrl" gives direct access to the value 6730 */ 6731 public UriType getUrlElement() { 6732 if (this.url == null) 6733 if (Configuration.errorOnAutoCreate()) 6734 throw new Error("Attempt to auto-create PlanDefinition.url"); 6735 else if (Configuration.doAutoCreate()) 6736 this.url = new UriType(); // bb 6737 return this.url; 6738 } 6739 6740 public boolean hasUrlElement() { 6741 return this.url != null && !this.url.isEmpty(); 6742 } 6743 6744 public boolean hasUrl() { 6745 return this.url != null && !this.url.isEmpty(); 6746 } 6747 6748 /** 6749 * @param value {@link #url} (An absolute URI that is used to identify this plan 6750 * definition when it is referenced in a specification, model, 6751 * design or an instance; also called its canonical identifier. 6752 * This SHOULD be globally unique and SHOULD be a literal address 6753 * at which at which an authoritative instance of this plan 6754 * definition is (or will be) published. This URL can be the target 6755 * of a canonical reference. It SHALL remain the same when the plan 6756 * definition is stored on different servers.). This is the 6757 * underlying object with id, value and extensions. The accessor 6758 * "getUrl" gives direct access to the value 6759 */ 6760 public PlanDefinition setUrlElement(UriType value) { 6761 this.url = value; 6762 return this; 6763 } 6764 6765 /** 6766 * @return An absolute URI that is used to identify this plan definition when it 6767 * is referenced in a specification, model, design or an instance; also 6768 * called its canonical identifier. This SHOULD be globally unique and 6769 * SHOULD be a literal address at which at which an authoritative 6770 * instance of this plan definition is (or will be) published. This URL 6771 * can be the target of a canonical reference. It SHALL remain the same 6772 * when the plan definition is stored on different servers. 6773 */ 6774 public String getUrl() { 6775 return this.url == null ? null : this.url.getValue(); 6776 } 6777 6778 /** 6779 * @param value An absolute URI that is used to identify this plan definition 6780 * when it is referenced in a specification, model, design or an 6781 * instance; also called its canonical identifier. This SHOULD be 6782 * globally unique and SHOULD be a literal address at which at 6783 * which an authoritative instance of this plan definition is (or 6784 * will be) published. This URL can be the target of a canonical 6785 * reference. It SHALL remain the same when the plan definition is 6786 * stored on different servers. 6787 */ 6788 public PlanDefinition setUrl(String value) { 6789 if (Utilities.noString(value)) 6790 this.url = null; 6791 else { 6792 if (this.url == null) 6793 this.url = new UriType(); 6794 this.url.setValue(value); 6795 } 6796 return this; 6797 } 6798 6799 /** 6800 * @return {@link #identifier} (A formal identifier that is used to identify 6801 * this plan definition when it is represented in other formats, or 6802 * referenced in a specification, model, design or an instance.) 6803 */ 6804 public List<Identifier> getIdentifier() { 6805 if (this.identifier == null) 6806 this.identifier = new ArrayList<Identifier>(); 6807 return this.identifier; 6808 } 6809 6810 /** 6811 * @return Returns a reference to <code>this</code> for easy method chaining 6812 */ 6813 public PlanDefinition setIdentifier(List<Identifier> theIdentifier) { 6814 this.identifier = theIdentifier; 6815 return this; 6816 } 6817 6818 public boolean hasIdentifier() { 6819 if (this.identifier == null) 6820 return false; 6821 for (Identifier item : this.identifier) 6822 if (!item.isEmpty()) 6823 return true; 6824 return false; 6825 } 6826 6827 public Identifier addIdentifier() { // 3 6828 Identifier t = new Identifier(); 6829 if (this.identifier == null) 6830 this.identifier = new ArrayList<Identifier>(); 6831 this.identifier.add(t); 6832 return t; 6833 } 6834 6835 public PlanDefinition addIdentifier(Identifier t) { // 3 6836 if (t == null) 6837 return this; 6838 if (this.identifier == null) 6839 this.identifier = new ArrayList<Identifier>(); 6840 this.identifier.add(t); 6841 return this; 6842 } 6843 6844 /** 6845 * @return The first repetition of repeating field {@link #identifier}, creating 6846 * it if it does not already exist 6847 */ 6848 public Identifier getIdentifierFirstRep() { 6849 if (getIdentifier().isEmpty()) { 6850 addIdentifier(); 6851 } 6852 return getIdentifier().get(0); 6853 } 6854 6855 /** 6856 * @return {@link #version} (The identifier that is used to identify this 6857 * version of the plan definition when it is referenced in a 6858 * specification, model, design or instance. This is an arbitrary value 6859 * managed by the plan definition author and is not expected to be 6860 * globally unique. For example, it might be a timestamp (e.g. yyyymmdd) 6861 * if a managed version is not available. There is also no expectation 6862 * that versions can be placed in a lexicographical sequence. To provide 6863 * a version consistent with the Decision Support Service specification, 6864 * use the format Major.Minor.Revision (e.g. 1.0.0). For more 6865 * information on versioning knowledge assets, refer to the Decision 6866 * Support Service specification. Note that a version is required for 6867 * non-experimental active artifacts.). This is the underlying object 6868 * with id, value and extensions. The accessor "getVersion" gives direct 6869 * access to the value 6870 */ 6871 public StringType getVersionElement() { 6872 if (this.version == null) 6873 if (Configuration.errorOnAutoCreate()) 6874 throw new Error("Attempt to auto-create PlanDefinition.version"); 6875 else if (Configuration.doAutoCreate()) 6876 this.version = new StringType(); // bb 6877 return this.version; 6878 } 6879 6880 public boolean hasVersionElement() { 6881 return this.version != null && !this.version.isEmpty(); 6882 } 6883 6884 public boolean hasVersion() { 6885 return this.version != null && !this.version.isEmpty(); 6886 } 6887 6888 /** 6889 * @param value {@link #version} (The identifier that is used to identify this 6890 * version of the plan definition when it is referenced in a 6891 * specification, model, design or instance. This is an arbitrary 6892 * value managed by the plan definition author and is not expected 6893 * to be globally unique. For example, it might be a timestamp 6894 * (e.g. yyyymmdd) if a managed version is not available. There is 6895 * also no expectation that versions can be placed in a 6896 * lexicographical sequence. To provide a version consistent with 6897 * the Decision Support Service specification, use the format 6898 * Major.Minor.Revision (e.g. 1.0.0). For more information on 6899 * versioning knowledge assets, refer to the Decision Support 6900 * Service specification. Note that a version is required for 6901 * non-experimental active artifacts.). This is the underlying 6902 * object with id, value and extensions. The accessor "getVersion" 6903 * gives direct access to the value 6904 */ 6905 public PlanDefinition setVersionElement(StringType value) { 6906 this.version = value; 6907 return this; 6908 } 6909 6910 /** 6911 * @return The identifier that is used to identify this version of the plan 6912 * definition when it is referenced in a specification, model, design or 6913 * instance. This is an arbitrary value managed by the plan definition 6914 * author and is not expected to be globally unique. For example, it 6915 * might be a timestamp (e.g. yyyymmdd) if a managed version is not 6916 * available. There is also no expectation that versions can be placed 6917 * in a lexicographical sequence. To provide a version consistent with 6918 * the Decision Support Service specification, use the format 6919 * Major.Minor.Revision (e.g. 1.0.0). For more information on versioning 6920 * knowledge assets, refer to the Decision Support Service 6921 * specification. Note that a version is required for non-experimental 6922 * active artifacts. 6923 */ 6924 public String getVersion() { 6925 return this.version == null ? null : this.version.getValue(); 6926 } 6927 6928 /** 6929 * @param value The identifier that is used to identify this version of the plan 6930 * definition when it is referenced in a specification, model, 6931 * design or instance. This is an arbitrary value managed by the 6932 * plan definition author and is not expected to be globally 6933 * unique. For example, it might be a timestamp (e.g. yyyymmdd) if 6934 * a managed version is not available. There is also no expectation 6935 * that versions can be placed in a lexicographical sequence. To 6936 * provide a version consistent with the Decision Support Service 6937 * specification, use the format Major.Minor.Revision (e.g. 1.0.0). 6938 * For more information on versioning knowledge assets, refer to 6939 * the Decision Support Service specification. Note that a version 6940 * is required for non-experimental active artifacts. 6941 */ 6942 public PlanDefinition setVersion(String value) { 6943 if (Utilities.noString(value)) 6944 this.version = null; 6945 else { 6946 if (this.version == null) 6947 this.version = new StringType(); 6948 this.version.setValue(value); 6949 } 6950 return this; 6951 } 6952 6953 /** 6954 * @return {@link #name} (A natural language name identifying the plan 6955 * definition. This name should be usable as an identifier for the 6956 * module by machine processing applications such as code generation.). 6957 * This is the underlying object with id, value and extensions. The 6958 * accessor "getName" gives direct access to the value 6959 */ 6960 public StringType getNameElement() { 6961 if (this.name == null) 6962 if (Configuration.errorOnAutoCreate()) 6963 throw new Error("Attempt to auto-create PlanDefinition.name"); 6964 else if (Configuration.doAutoCreate()) 6965 this.name = new StringType(); // bb 6966 return this.name; 6967 } 6968 6969 public boolean hasNameElement() { 6970 return this.name != null && !this.name.isEmpty(); 6971 } 6972 6973 public boolean hasName() { 6974 return this.name != null && !this.name.isEmpty(); 6975 } 6976 6977 /** 6978 * @param value {@link #name} (A natural language name identifying the plan 6979 * definition. This name should be usable as an identifier for the 6980 * module by machine processing applications such as code 6981 * generation.). This is the underlying object with id, value and 6982 * extensions. The accessor "getName" gives direct access to the 6983 * value 6984 */ 6985 public PlanDefinition setNameElement(StringType value) { 6986 this.name = value; 6987 return this; 6988 } 6989 6990 /** 6991 * @return A natural language name identifying the plan definition. This name 6992 * should be usable as an identifier for the module by machine 6993 * processing applications such as code generation. 6994 */ 6995 public String getName() { 6996 return this.name == null ? null : this.name.getValue(); 6997 } 6998 6999 /** 7000 * @param value A natural language name identifying the plan definition. This 7001 * name should be usable as an identifier for the module by machine 7002 * processing applications such as code generation. 7003 */ 7004 public PlanDefinition setName(String value) { 7005 if (Utilities.noString(value)) 7006 this.name = null; 7007 else { 7008 if (this.name == null) 7009 this.name = new StringType(); 7010 this.name.setValue(value); 7011 } 7012 return this; 7013 } 7014 7015 /** 7016 * @return {@link #title} (A short, descriptive, user-friendly title for the 7017 * plan definition.). This is the underlying object with id, value and 7018 * extensions. The accessor "getTitle" gives direct access to the value 7019 */ 7020 public StringType getTitleElement() { 7021 if (this.title == null) 7022 if (Configuration.errorOnAutoCreate()) 7023 throw new Error("Attempt to auto-create PlanDefinition.title"); 7024 else if (Configuration.doAutoCreate()) 7025 this.title = new StringType(); // bb 7026 return this.title; 7027 } 7028 7029 public boolean hasTitleElement() { 7030 return this.title != null && !this.title.isEmpty(); 7031 } 7032 7033 public boolean hasTitle() { 7034 return this.title != null && !this.title.isEmpty(); 7035 } 7036 7037 /** 7038 * @param value {@link #title} (A short, descriptive, user-friendly title for 7039 * the plan definition.). This is the underlying object with id, 7040 * value and extensions. The accessor "getTitle" gives direct 7041 * access to the value 7042 */ 7043 public PlanDefinition setTitleElement(StringType value) { 7044 this.title = value; 7045 return this; 7046 } 7047 7048 /** 7049 * @return A short, descriptive, user-friendly title for the plan definition. 7050 */ 7051 public String getTitle() { 7052 return this.title == null ? null : this.title.getValue(); 7053 } 7054 7055 /** 7056 * @param value A short, descriptive, user-friendly title for the plan 7057 * definition. 7058 */ 7059 public PlanDefinition setTitle(String value) { 7060 if (Utilities.noString(value)) 7061 this.title = null; 7062 else { 7063 if (this.title == null) 7064 this.title = new StringType(); 7065 this.title.setValue(value); 7066 } 7067 return this; 7068 } 7069 7070 /** 7071 * @return {@link #subtitle} (An explanatory or alternate title for the plan 7072 * definition giving additional information about its content.). This is 7073 * the underlying object with id, value and extensions. The accessor 7074 * "getSubtitle" gives direct access to the value 7075 */ 7076 public StringType getSubtitleElement() { 7077 if (this.subtitle == null) 7078 if (Configuration.errorOnAutoCreate()) 7079 throw new Error("Attempt to auto-create PlanDefinition.subtitle"); 7080 else if (Configuration.doAutoCreate()) 7081 this.subtitle = new StringType(); // bb 7082 return this.subtitle; 7083 } 7084 7085 public boolean hasSubtitleElement() { 7086 return this.subtitle != null && !this.subtitle.isEmpty(); 7087 } 7088 7089 public boolean hasSubtitle() { 7090 return this.subtitle != null && !this.subtitle.isEmpty(); 7091 } 7092 7093 /** 7094 * @param value {@link #subtitle} (An explanatory or alternate title for the 7095 * plan definition giving additional information about its 7096 * content.). This is the underlying object with id, value and 7097 * extensions. The accessor "getSubtitle" gives direct access to 7098 * the value 7099 */ 7100 public PlanDefinition setSubtitleElement(StringType value) { 7101 this.subtitle = value; 7102 return this; 7103 } 7104 7105 /** 7106 * @return An explanatory or alternate title for the plan definition giving 7107 * additional information about its content. 7108 */ 7109 public String getSubtitle() { 7110 return this.subtitle == null ? null : this.subtitle.getValue(); 7111 } 7112 7113 /** 7114 * @param value An explanatory or alternate title for the plan definition giving 7115 * additional information about its content. 7116 */ 7117 public PlanDefinition setSubtitle(String value) { 7118 if (Utilities.noString(value)) 7119 this.subtitle = null; 7120 else { 7121 if (this.subtitle == null) 7122 this.subtitle = new StringType(); 7123 this.subtitle.setValue(value); 7124 } 7125 return this; 7126 } 7127 7128 /** 7129 * @return {@link #type} (A high-level category for the plan definition that 7130 * distinguishes the kinds of systems that would be interested in the 7131 * plan definition.) 7132 */ 7133 public CodeableConcept getType() { 7134 if (this.type == null) 7135 if (Configuration.errorOnAutoCreate()) 7136 throw new Error("Attempt to auto-create PlanDefinition.type"); 7137 else if (Configuration.doAutoCreate()) 7138 this.type = new CodeableConcept(); // cc 7139 return this.type; 7140 } 7141 7142 public boolean hasType() { 7143 return this.type != null && !this.type.isEmpty(); 7144 } 7145 7146 /** 7147 * @param value {@link #type} (A high-level category for the plan definition 7148 * that distinguishes the kinds of systems that would be interested 7149 * in the plan definition.) 7150 */ 7151 public PlanDefinition setType(CodeableConcept value) { 7152 this.type = value; 7153 return this; 7154 } 7155 7156 /** 7157 * @return {@link #status} (The status of this plan definition. Enables tracking 7158 * the life-cycle of the content.). This is the underlying object with 7159 * id, value and extensions. The accessor "getStatus" gives direct 7160 * access to the value 7161 */ 7162 public Enumeration<PublicationStatus> getStatusElement() { 7163 if (this.status == null) 7164 if (Configuration.errorOnAutoCreate()) 7165 throw new Error("Attempt to auto-create PlanDefinition.status"); 7166 else if (Configuration.doAutoCreate()) 7167 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 7168 return this.status; 7169 } 7170 7171 public boolean hasStatusElement() { 7172 return this.status != null && !this.status.isEmpty(); 7173 } 7174 7175 public boolean hasStatus() { 7176 return this.status != null && !this.status.isEmpty(); 7177 } 7178 7179 /** 7180 * @param value {@link #status} (The status of this plan definition. Enables 7181 * tracking the life-cycle of the content.). This is the underlying 7182 * object with id, value and extensions. The accessor "getStatus" 7183 * gives direct access to the value 7184 */ 7185 public PlanDefinition setStatusElement(Enumeration<PublicationStatus> value) { 7186 this.status = value; 7187 return this; 7188 } 7189 7190 /** 7191 * @return The status of this plan definition. Enables tracking the life-cycle 7192 * of the content. 7193 */ 7194 public PublicationStatus getStatus() { 7195 return this.status == null ? null : this.status.getValue(); 7196 } 7197 7198 /** 7199 * @param value The status of this plan definition. Enables tracking the 7200 * life-cycle of the content. 7201 */ 7202 public PlanDefinition setStatus(PublicationStatus value) { 7203 if (this.status == null) 7204 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 7205 this.status.setValue(value); 7206 return this; 7207 } 7208 7209 /** 7210 * @return {@link #experimental} (A Boolean value to indicate that this plan 7211 * definition is authored for testing purposes (or 7212 * education/evaluation/marketing) and is not intended to be used for 7213 * genuine usage.). This is the underlying object with id, value and 7214 * extensions. The accessor "getExperimental" gives direct access to the 7215 * value 7216 */ 7217 public BooleanType getExperimentalElement() { 7218 if (this.experimental == null) 7219 if (Configuration.errorOnAutoCreate()) 7220 throw new Error("Attempt to auto-create PlanDefinition.experimental"); 7221 else if (Configuration.doAutoCreate()) 7222 this.experimental = new BooleanType(); // bb 7223 return this.experimental; 7224 } 7225 7226 public boolean hasExperimentalElement() { 7227 return this.experimental != null && !this.experimental.isEmpty(); 7228 } 7229 7230 public boolean hasExperimental() { 7231 return this.experimental != null && !this.experimental.isEmpty(); 7232 } 7233 7234 /** 7235 * @param value {@link #experimental} (A Boolean value to indicate that this 7236 * plan definition is authored for testing purposes (or 7237 * education/evaluation/marketing) and is not intended to be used 7238 * for genuine usage.). This is the underlying object with id, 7239 * value and extensions. The accessor "getExperimental" gives 7240 * direct access to the value 7241 */ 7242 public PlanDefinition setExperimentalElement(BooleanType value) { 7243 this.experimental = value; 7244 return this; 7245 } 7246 7247 /** 7248 * @return A Boolean value to indicate that this plan definition is authored for 7249 * testing purposes (or education/evaluation/marketing) and is not 7250 * intended to be used for genuine usage. 7251 */ 7252 public boolean getExperimental() { 7253 return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue(); 7254 } 7255 7256 /** 7257 * @param value A Boolean value to indicate that this plan definition is 7258 * authored for testing purposes (or 7259 * education/evaluation/marketing) and is not intended to be used 7260 * for genuine usage. 7261 */ 7262 public PlanDefinition setExperimental(boolean value) { 7263 if (this.experimental == null) 7264 this.experimental = new BooleanType(); 7265 this.experimental.setValue(value); 7266 return this; 7267 } 7268 7269 /** 7270 * @return {@link #subject} (A code or group definition that describes the 7271 * intended subject of the plan definition.) 7272 */ 7273 public Type getSubject() { 7274 return this.subject; 7275 } 7276 7277 /** 7278 * @return {@link #subject} (A code or group definition that describes the 7279 * intended subject of the plan definition.) 7280 */ 7281 public CodeableConcept getSubjectCodeableConcept() throws FHIRException { 7282 if (this.subject == null) 7283 this.subject = new CodeableConcept(); 7284 if (!(this.subject instanceof CodeableConcept)) 7285 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but " 7286 + this.subject.getClass().getName() + " was encountered"); 7287 return (CodeableConcept) this.subject; 7288 } 7289 7290 public boolean hasSubjectCodeableConcept() { 7291 return this != null && this.subject instanceof CodeableConcept; 7292 } 7293 7294 /** 7295 * @return {@link #subject} (A code or group definition that describes the 7296 * intended subject of the plan definition.) 7297 */ 7298 public Reference getSubjectReference() throws FHIRException { 7299 if (this.subject == null) 7300 this.subject = new Reference(); 7301 if (!(this.subject instanceof Reference)) 7302 throw new FHIRException("Type mismatch: the type Reference was expected, but " + this.subject.getClass().getName() 7303 + " was encountered"); 7304 return (Reference) this.subject; 7305 } 7306 7307 public boolean hasSubjectReference() { 7308 return this != null && this.subject instanceof Reference; 7309 } 7310 7311 public boolean hasSubject() { 7312 return this.subject != null && !this.subject.isEmpty(); 7313 } 7314 7315 /** 7316 * @param value {@link #subject} (A code or group definition that describes the 7317 * intended subject of the plan definition.) 7318 */ 7319 public PlanDefinition setSubject(Type value) { 7320 if (value != null && !(value instanceof CodeableConcept || value instanceof Reference)) 7321 throw new Error("Not the right type for PlanDefinition.subject[x]: " + value.fhirType()); 7322 this.subject = value; 7323 return this; 7324 } 7325 7326 /** 7327 * @return {@link #date} (The date (and optionally time) when the plan 7328 * definition was published. The date must change when the business 7329 * version changes and it must change if the status code changes. In 7330 * addition, it should change when the substantive content of the plan 7331 * definition changes.). This is the underlying object with id, value 7332 * and extensions. The accessor "getDate" gives direct access to the 7333 * value 7334 */ 7335 public DateTimeType getDateElement() { 7336 if (this.date == null) 7337 if (Configuration.errorOnAutoCreate()) 7338 throw new Error("Attempt to auto-create PlanDefinition.date"); 7339 else if (Configuration.doAutoCreate()) 7340 this.date = new DateTimeType(); // bb 7341 return this.date; 7342 } 7343 7344 public boolean hasDateElement() { 7345 return this.date != null && !this.date.isEmpty(); 7346 } 7347 7348 public boolean hasDate() { 7349 return this.date != null && !this.date.isEmpty(); 7350 } 7351 7352 /** 7353 * @param value {@link #date} (The date (and optionally time) when the plan 7354 * definition was published. The date must change when the business 7355 * version changes and it must change if the status code changes. 7356 * In addition, it should change when the substantive content of 7357 * the plan definition changes.). This is the underlying object 7358 * with id, value and extensions. The accessor "getDate" gives 7359 * direct access to the value 7360 */ 7361 public PlanDefinition setDateElement(DateTimeType value) { 7362 this.date = value; 7363 return this; 7364 } 7365 7366 /** 7367 * @return The date (and optionally time) when the plan definition was 7368 * published. The date must change when the business version changes and 7369 * it must change if the status code changes. In addition, it should 7370 * change when the substantive content of the plan definition changes. 7371 */ 7372 public Date getDate() { 7373 return this.date == null ? null : this.date.getValue(); 7374 } 7375 7376 /** 7377 * @param value The date (and optionally time) when the plan definition was 7378 * published. The date must change when the business version 7379 * changes and it must change if the status code changes. In 7380 * addition, it should change when the substantive content of the 7381 * plan definition changes. 7382 */ 7383 public PlanDefinition setDate(Date value) { 7384 if (value == null) 7385 this.date = null; 7386 else { 7387 if (this.date == null) 7388 this.date = new DateTimeType(); 7389 this.date.setValue(value); 7390 } 7391 return this; 7392 } 7393 7394 /** 7395 * @return {@link #publisher} (The name of the organization or individual that 7396 * published the plan definition.). This is the underlying object with 7397 * id, value and extensions. The accessor "getPublisher" gives direct 7398 * access to the value 7399 */ 7400 public StringType getPublisherElement() { 7401 if (this.publisher == null) 7402 if (Configuration.errorOnAutoCreate()) 7403 throw new Error("Attempt to auto-create PlanDefinition.publisher"); 7404 else if (Configuration.doAutoCreate()) 7405 this.publisher = new StringType(); // bb 7406 return this.publisher; 7407 } 7408 7409 public boolean hasPublisherElement() { 7410 return this.publisher != null && !this.publisher.isEmpty(); 7411 } 7412 7413 public boolean hasPublisher() { 7414 return this.publisher != null && !this.publisher.isEmpty(); 7415 } 7416 7417 /** 7418 * @param value {@link #publisher} (The name of the organization or individual 7419 * that published the plan definition.). This is the underlying 7420 * object with id, value and extensions. The accessor 7421 * "getPublisher" gives direct access to the value 7422 */ 7423 public PlanDefinition setPublisherElement(StringType value) { 7424 this.publisher = value; 7425 return this; 7426 } 7427 7428 /** 7429 * @return The name of the organization or individual that published the plan 7430 * definition. 7431 */ 7432 public String getPublisher() { 7433 return this.publisher == null ? null : this.publisher.getValue(); 7434 } 7435 7436 /** 7437 * @param value The name of the organization or individual that published the 7438 * plan definition. 7439 */ 7440 public PlanDefinition setPublisher(String value) { 7441 if (Utilities.noString(value)) 7442 this.publisher = null; 7443 else { 7444 if (this.publisher == null) 7445 this.publisher = new StringType(); 7446 this.publisher.setValue(value); 7447 } 7448 return this; 7449 } 7450 7451 /** 7452 * @return {@link #contact} (Contact details to assist a user in finding and 7453 * communicating with the publisher.) 7454 */ 7455 public List<ContactDetail> getContact() { 7456 if (this.contact == null) 7457 this.contact = new ArrayList<ContactDetail>(); 7458 return this.contact; 7459 } 7460 7461 /** 7462 * @return Returns a reference to <code>this</code> for easy method chaining 7463 */ 7464 public PlanDefinition setContact(List<ContactDetail> theContact) { 7465 this.contact = theContact; 7466 return this; 7467 } 7468 7469 public boolean hasContact() { 7470 if (this.contact == null) 7471 return false; 7472 for (ContactDetail item : this.contact) 7473 if (!item.isEmpty()) 7474 return true; 7475 return false; 7476 } 7477 7478 public ContactDetail addContact() { // 3 7479 ContactDetail t = new ContactDetail(); 7480 if (this.contact == null) 7481 this.contact = new ArrayList<ContactDetail>(); 7482 this.contact.add(t); 7483 return t; 7484 } 7485 7486 public PlanDefinition addContact(ContactDetail t) { // 3 7487 if (t == null) 7488 return this; 7489 if (this.contact == null) 7490 this.contact = new ArrayList<ContactDetail>(); 7491 this.contact.add(t); 7492 return this; 7493 } 7494 7495 /** 7496 * @return The first repetition of repeating field {@link #contact}, creating it 7497 * if it does not already exist 7498 */ 7499 public ContactDetail getContactFirstRep() { 7500 if (getContact().isEmpty()) { 7501 addContact(); 7502 } 7503 return getContact().get(0); 7504 } 7505 7506 /** 7507 * @return {@link #description} (A free text natural language description of the 7508 * plan definition from a consumer's perspective.). This is the 7509 * underlying object with id, value and extensions. The accessor 7510 * "getDescription" gives direct access to the value 7511 */ 7512 public MarkdownType getDescriptionElement() { 7513 if (this.description == null) 7514 if (Configuration.errorOnAutoCreate()) 7515 throw new Error("Attempt to auto-create PlanDefinition.description"); 7516 else if (Configuration.doAutoCreate()) 7517 this.description = new MarkdownType(); // bb 7518 return this.description; 7519 } 7520 7521 public boolean hasDescriptionElement() { 7522 return this.description != null && !this.description.isEmpty(); 7523 } 7524 7525 public boolean hasDescription() { 7526 return this.description != null && !this.description.isEmpty(); 7527 } 7528 7529 /** 7530 * @param value {@link #description} (A free text natural language description 7531 * of the plan definition from a consumer's perspective.). This is 7532 * the underlying object with id, value and extensions. The 7533 * accessor "getDescription" gives direct access to the value 7534 */ 7535 public PlanDefinition setDescriptionElement(MarkdownType value) { 7536 this.description = value; 7537 return this; 7538 } 7539 7540 /** 7541 * @return A free text natural language description of the plan definition from 7542 * a consumer's perspective. 7543 */ 7544 public String getDescription() { 7545 return this.description == null ? null : this.description.getValue(); 7546 } 7547 7548 /** 7549 * @param value A free text natural language description of the plan definition 7550 * from a consumer's perspective. 7551 */ 7552 public PlanDefinition setDescription(String value) { 7553 if (value == null) 7554 this.description = null; 7555 else { 7556 if (this.description == null) 7557 this.description = new MarkdownType(); 7558 this.description.setValue(value); 7559 } 7560 return this; 7561 } 7562 7563 /** 7564 * @return {@link #useContext} (The content was developed with a focus and 7565 * intent of supporting the contexts that are listed. These contexts may 7566 * be general categories (gender, age, ...) or may be references to 7567 * specific programs (insurance plans, studies, ...) and may be used to 7568 * assist with indexing and searching for appropriate plan definition 7569 * instances.) 7570 */ 7571 public List<UsageContext> getUseContext() { 7572 if (this.useContext == null) 7573 this.useContext = new ArrayList<UsageContext>(); 7574 return this.useContext; 7575 } 7576 7577 /** 7578 * @return Returns a reference to <code>this</code> for easy method chaining 7579 */ 7580 public PlanDefinition setUseContext(List<UsageContext> theUseContext) { 7581 this.useContext = theUseContext; 7582 return this; 7583 } 7584 7585 public boolean hasUseContext() { 7586 if (this.useContext == null) 7587 return false; 7588 for (UsageContext item : this.useContext) 7589 if (!item.isEmpty()) 7590 return true; 7591 return false; 7592 } 7593 7594 public UsageContext addUseContext() { // 3 7595 UsageContext t = new UsageContext(); 7596 if (this.useContext == null) 7597 this.useContext = new ArrayList<UsageContext>(); 7598 this.useContext.add(t); 7599 return t; 7600 } 7601 7602 public PlanDefinition addUseContext(UsageContext t) { // 3 7603 if (t == null) 7604 return this; 7605 if (this.useContext == null) 7606 this.useContext = new ArrayList<UsageContext>(); 7607 this.useContext.add(t); 7608 return this; 7609 } 7610 7611 /** 7612 * @return The first repetition of repeating field {@link #useContext}, creating 7613 * it if it does not already exist 7614 */ 7615 public UsageContext getUseContextFirstRep() { 7616 if (getUseContext().isEmpty()) { 7617 addUseContext(); 7618 } 7619 return getUseContext().get(0); 7620 } 7621 7622 /** 7623 * @return {@link #jurisdiction} (A legal or geographic region in which the plan 7624 * definition is intended to be used.) 7625 */ 7626 public List<CodeableConcept> getJurisdiction() { 7627 if (this.jurisdiction == null) 7628 this.jurisdiction = new ArrayList<CodeableConcept>(); 7629 return this.jurisdiction; 7630 } 7631 7632 /** 7633 * @return Returns a reference to <code>this</code> for easy method chaining 7634 */ 7635 public PlanDefinition setJurisdiction(List<CodeableConcept> theJurisdiction) { 7636 this.jurisdiction = theJurisdiction; 7637 return this; 7638 } 7639 7640 public boolean hasJurisdiction() { 7641 if (this.jurisdiction == null) 7642 return false; 7643 for (CodeableConcept item : this.jurisdiction) 7644 if (!item.isEmpty()) 7645 return true; 7646 return false; 7647 } 7648 7649 public CodeableConcept addJurisdiction() { // 3 7650 CodeableConcept t = new CodeableConcept(); 7651 if (this.jurisdiction == null) 7652 this.jurisdiction = new ArrayList<CodeableConcept>(); 7653 this.jurisdiction.add(t); 7654 return t; 7655 } 7656 7657 public PlanDefinition addJurisdiction(CodeableConcept t) { // 3 7658 if (t == null) 7659 return this; 7660 if (this.jurisdiction == null) 7661 this.jurisdiction = new ArrayList<CodeableConcept>(); 7662 this.jurisdiction.add(t); 7663 return this; 7664 } 7665 7666 /** 7667 * @return The first repetition of repeating field {@link #jurisdiction}, 7668 * creating it if it does not already exist 7669 */ 7670 public CodeableConcept getJurisdictionFirstRep() { 7671 if (getJurisdiction().isEmpty()) { 7672 addJurisdiction(); 7673 } 7674 return getJurisdiction().get(0); 7675 } 7676 7677 /** 7678 * @return {@link #purpose} (Explanation of why this plan definition is needed 7679 * and why it has been designed as it has.). This is the underlying 7680 * object with id, value and extensions. The accessor "getPurpose" gives 7681 * direct access to the value 7682 */ 7683 public MarkdownType getPurposeElement() { 7684 if (this.purpose == null) 7685 if (Configuration.errorOnAutoCreate()) 7686 throw new Error("Attempt to auto-create PlanDefinition.purpose"); 7687 else if (Configuration.doAutoCreate()) 7688 this.purpose = new MarkdownType(); // bb 7689 return this.purpose; 7690 } 7691 7692 public boolean hasPurposeElement() { 7693 return this.purpose != null && !this.purpose.isEmpty(); 7694 } 7695 7696 public boolean hasPurpose() { 7697 return this.purpose != null && !this.purpose.isEmpty(); 7698 } 7699 7700 /** 7701 * @param value {@link #purpose} (Explanation of why this plan definition is 7702 * needed and why it has been designed as it has.). This is the 7703 * underlying object with id, value and extensions. The accessor 7704 * "getPurpose" gives direct access to the value 7705 */ 7706 public PlanDefinition setPurposeElement(MarkdownType value) { 7707 this.purpose = value; 7708 return this; 7709 } 7710 7711 /** 7712 * @return Explanation of why this plan definition is needed and why it has been 7713 * designed as it has. 7714 */ 7715 public String getPurpose() { 7716 return this.purpose == null ? null : this.purpose.getValue(); 7717 } 7718 7719 /** 7720 * @param value Explanation of why this plan definition is needed and why it has 7721 * been designed as it has. 7722 */ 7723 public PlanDefinition setPurpose(String value) { 7724 if (value == null) 7725 this.purpose = null; 7726 else { 7727 if (this.purpose == null) 7728 this.purpose = new MarkdownType(); 7729 this.purpose.setValue(value); 7730 } 7731 return this; 7732 } 7733 7734 /** 7735 * @return {@link #usage} (A detailed description of how the plan definition is 7736 * used from a clinical perspective.). This is the underlying object 7737 * with id, value and extensions. The accessor "getUsage" gives direct 7738 * access to the value 7739 */ 7740 public StringType getUsageElement() { 7741 if (this.usage == null) 7742 if (Configuration.errorOnAutoCreate()) 7743 throw new Error("Attempt to auto-create PlanDefinition.usage"); 7744 else if (Configuration.doAutoCreate()) 7745 this.usage = new StringType(); // bb 7746 return this.usage; 7747 } 7748 7749 public boolean hasUsageElement() { 7750 return this.usage != null && !this.usage.isEmpty(); 7751 } 7752 7753 public boolean hasUsage() { 7754 return this.usage != null && !this.usage.isEmpty(); 7755 } 7756 7757 /** 7758 * @param value {@link #usage} (A detailed description of how the plan 7759 * definition is used from a clinical perspective.). This is the 7760 * underlying object with id, value and extensions. The accessor 7761 * "getUsage" gives direct access to the value 7762 */ 7763 public PlanDefinition setUsageElement(StringType value) { 7764 this.usage = value; 7765 return this; 7766 } 7767 7768 /** 7769 * @return A detailed description of how the plan definition is used from a 7770 * clinical perspective. 7771 */ 7772 public String getUsage() { 7773 return this.usage == null ? null : this.usage.getValue(); 7774 } 7775 7776 /** 7777 * @param value A detailed description of how the plan definition is used from a 7778 * clinical perspective. 7779 */ 7780 public PlanDefinition setUsage(String value) { 7781 if (Utilities.noString(value)) 7782 this.usage = null; 7783 else { 7784 if (this.usage == null) 7785 this.usage = new StringType(); 7786 this.usage.setValue(value); 7787 } 7788 return this; 7789 } 7790 7791 /** 7792 * @return {@link #copyright} (A copyright statement relating to the plan 7793 * definition and/or its contents. Copyright statements are generally 7794 * legal restrictions on the use and publishing of the plan 7795 * definition.). This is the underlying object with id, value and 7796 * extensions. The accessor "getCopyright" gives direct access to the 7797 * value 7798 */ 7799 public MarkdownType getCopyrightElement() { 7800 if (this.copyright == null) 7801 if (Configuration.errorOnAutoCreate()) 7802 throw new Error("Attempt to auto-create PlanDefinition.copyright"); 7803 else if (Configuration.doAutoCreate()) 7804 this.copyright = new MarkdownType(); // bb 7805 return this.copyright; 7806 } 7807 7808 public boolean hasCopyrightElement() { 7809 return this.copyright != null && !this.copyright.isEmpty(); 7810 } 7811 7812 public boolean hasCopyright() { 7813 return this.copyright != null && !this.copyright.isEmpty(); 7814 } 7815 7816 /** 7817 * @param value {@link #copyright} (A copyright statement relating to the plan 7818 * definition and/or its contents. Copyright statements are 7819 * generally legal restrictions on the use and publishing of the 7820 * plan definition.). This is the underlying object with id, value 7821 * and extensions. The accessor "getCopyright" gives direct access 7822 * to the value 7823 */ 7824 public PlanDefinition setCopyrightElement(MarkdownType value) { 7825 this.copyright = value; 7826 return this; 7827 } 7828 7829 /** 7830 * @return A copyright statement relating to the plan definition and/or its 7831 * contents. Copyright statements are generally legal restrictions on 7832 * the use and publishing of the plan definition. 7833 */ 7834 public String getCopyright() { 7835 return this.copyright == null ? null : this.copyright.getValue(); 7836 } 7837 7838 /** 7839 * @param value A copyright statement relating to the plan definition and/or its 7840 * contents. Copyright statements are generally legal restrictions 7841 * on the use and publishing of the plan definition. 7842 */ 7843 public PlanDefinition setCopyright(String value) { 7844 if (value == null) 7845 this.copyright = null; 7846 else { 7847 if (this.copyright == null) 7848 this.copyright = new MarkdownType(); 7849 this.copyright.setValue(value); 7850 } 7851 return this; 7852 } 7853 7854 /** 7855 * @return {@link #approvalDate} (The date on which the resource content was 7856 * approved by the publisher. Approval happens once when the content is 7857 * officially approved for usage.). This is the underlying object with 7858 * id, value and extensions. The accessor "getApprovalDate" gives direct 7859 * access to the value 7860 */ 7861 public DateType getApprovalDateElement() { 7862 if (this.approvalDate == null) 7863 if (Configuration.errorOnAutoCreate()) 7864 throw new Error("Attempt to auto-create PlanDefinition.approvalDate"); 7865 else if (Configuration.doAutoCreate()) 7866 this.approvalDate = new DateType(); // bb 7867 return this.approvalDate; 7868 } 7869 7870 public boolean hasApprovalDateElement() { 7871 return this.approvalDate != null && !this.approvalDate.isEmpty(); 7872 } 7873 7874 public boolean hasApprovalDate() { 7875 return this.approvalDate != null && !this.approvalDate.isEmpty(); 7876 } 7877 7878 /** 7879 * @param value {@link #approvalDate} (The date on which the resource content 7880 * was approved by the publisher. Approval happens once when the 7881 * content is officially approved for usage.). This is the 7882 * underlying object with id, value and extensions. The accessor 7883 * "getApprovalDate" gives direct access to the value 7884 */ 7885 public PlanDefinition setApprovalDateElement(DateType value) { 7886 this.approvalDate = value; 7887 return this; 7888 } 7889 7890 /** 7891 * @return The date on which the resource content was approved by the publisher. 7892 * Approval happens once when the content is officially approved for 7893 * usage. 7894 */ 7895 public Date getApprovalDate() { 7896 return this.approvalDate == null ? null : this.approvalDate.getValue(); 7897 } 7898 7899 /** 7900 * @param value The date on which the resource content was approved by the 7901 * publisher. Approval happens once when the content is officially 7902 * approved for usage. 7903 */ 7904 public PlanDefinition setApprovalDate(Date value) { 7905 if (value == null) 7906 this.approvalDate = null; 7907 else { 7908 if (this.approvalDate == null) 7909 this.approvalDate = new DateType(); 7910 this.approvalDate.setValue(value); 7911 } 7912 return this; 7913 } 7914 7915 /** 7916 * @return {@link #lastReviewDate} (The date on which the resource content was 7917 * last reviewed. Review happens periodically after approval but does 7918 * not change the original approval date.). This is the underlying 7919 * object with id, value and extensions. The accessor 7920 * "getLastReviewDate" gives direct access to the value 7921 */ 7922 public DateType getLastReviewDateElement() { 7923 if (this.lastReviewDate == null) 7924 if (Configuration.errorOnAutoCreate()) 7925 throw new Error("Attempt to auto-create PlanDefinition.lastReviewDate"); 7926 else if (Configuration.doAutoCreate()) 7927 this.lastReviewDate = new DateType(); // bb 7928 return this.lastReviewDate; 7929 } 7930 7931 public boolean hasLastReviewDateElement() { 7932 return this.lastReviewDate != null && !this.lastReviewDate.isEmpty(); 7933 } 7934 7935 public boolean hasLastReviewDate() { 7936 return this.lastReviewDate != null && !this.lastReviewDate.isEmpty(); 7937 } 7938 7939 /** 7940 * @param value {@link #lastReviewDate} (The date on which the resource content 7941 * was last reviewed. Review happens periodically after approval 7942 * but does not change the original approval date.). This is the 7943 * underlying object with id, value and extensions. The accessor 7944 * "getLastReviewDate" gives direct access to the value 7945 */ 7946 public PlanDefinition setLastReviewDateElement(DateType value) { 7947 this.lastReviewDate = value; 7948 return this; 7949 } 7950 7951 /** 7952 * @return The date on which the resource content was last reviewed. Review 7953 * happens periodically after approval but does not change the original 7954 * approval date. 7955 */ 7956 public Date getLastReviewDate() { 7957 return this.lastReviewDate == null ? null : this.lastReviewDate.getValue(); 7958 } 7959 7960 /** 7961 * @param value The date on which the resource content was last reviewed. Review 7962 * happens periodically after approval but does not change the 7963 * original approval date. 7964 */ 7965 public PlanDefinition setLastReviewDate(Date value) { 7966 if (value == null) 7967 this.lastReviewDate = null; 7968 else { 7969 if (this.lastReviewDate == null) 7970 this.lastReviewDate = new DateType(); 7971 this.lastReviewDate.setValue(value); 7972 } 7973 return this; 7974 } 7975 7976 /** 7977 * @return {@link #effectivePeriod} (The period during which the plan definition 7978 * content was or is planned to be in active use.) 7979 */ 7980 public Period getEffectivePeriod() { 7981 if (this.effectivePeriod == null) 7982 if (Configuration.errorOnAutoCreate()) 7983 throw new Error("Attempt to auto-create PlanDefinition.effectivePeriod"); 7984 else if (Configuration.doAutoCreate()) 7985 this.effectivePeriod = new Period(); // cc 7986 return this.effectivePeriod; 7987 } 7988 7989 public boolean hasEffectivePeriod() { 7990 return this.effectivePeriod != null && !this.effectivePeriod.isEmpty(); 7991 } 7992 7993 /** 7994 * @param value {@link #effectivePeriod} (The period during which the plan 7995 * definition content was or is planned to be in active use.) 7996 */ 7997 public PlanDefinition setEffectivePeriod(Period value) { 7998 this.effectivePeriod = value; 7999 return this; 8000 } 8001 8002 /** 8003 * @return {@link #topic} (Descriptive topics related to the content of the plan 8004 * definition. Topics provide a high-level categorization of the 8005 * definition that can be useful for filtering and searching.) 8006 */ 8007 public List<CodeableConcept> getTopic() { 8008 if (this.topic == null) 8009 this.topic = new ArrayList<CodeableConcept>(); 8010 return this.topic; 8011 } 8012 8013 /** 8014 * @return Returns a reference to <code>this</code> for easy method chaining 8015 */ 8016 public PlanDefinition setTopic(List<CodeableConcept> theTopic) { 8017 this.topic = theTopic; 8018 return this; 8019 } 8020 8021 public boolean hasTopic() { 8022 if (this.topic == null) 8023 return false; 8024 for (CodeableConcept item : this.topic) 8025 if (!item.isEmpty()) 8026 return true; 8027 return false; 8028 } 8029 8030 public CodeableConcept addTopic() { // 3 8031 CodeableConcept t = new CodeableConcept(); 8032 if (this.topic == null) 8033 this.topic = new ArrayList<CodeableConcept>(); 8034 this.topic.add(t); 8035 return t; 8036 } 8037 8038 public PlanDefinition addTopic(CodeableConcept t) { // 3 8039 if (t == null) 8040 return this; 8041 if (this.topic == null) 8042 this.topic = new ArrayList<CodeableConcept>(); 8043 this.topic.add(t); 8044 return this; 8045 } 8046 8047 /** 8048 * @return The first repetition of repeating field {@link #topic}, creating it 8049 * if it does not already exist 8050 */ 8051 public CodeableConcept getTopicFirstRep() { 8052 if (getTopic().isEmpty()) { 8053 addTopic(); 8054 } 8055 return getTopic().get(0); 8056 } 8057 8058 /** 8059 * @return {@link #author} (An individiual or organization primarily involved in 8060 * the creation and maintenance of the content.) 8061 */ 8062 public List<ContactDetail> getAuthor() { 8063 if (this.author == null) 8064 this.author = new ArrayList<ContactDetail>(); 8065 return this.author; 8066 } 8067 8068 /** 8069 * @return Returns a reference to <code>this</code> for easy method chaining 8070 */ 8071 public PlanDefinition setAuthor(List<ContactDetail> theAuthor) { 8072 this.author = theAuthor; 8073 return this; 8074 } 8075 8076 public boolean hasAuthor() { 8077 if (this.author == null) 8078 return false; 8079 for (ContactDetail item : this.author) 8080 if (!item.isEmpty()) 8081 return true; 8082 return false; 8083 } 8084 8085 public ContactDetail addAuthor() { // 3 8086 ContactDetail t = new ContactDetail(); 8087 if (this.author == null) 8088 this.author = new ArrayList<ContactDetail>(); 8089 this.author.add(t); 8090 return t; 8091 } 8092 8093 public PlanDefinition addAuthor(ContactDetail t) { // 3 8094 if (t == null) 8095 return this; 8096 if (this.author == null) 8097 this.author = new ArrayList<ContactDetail>(); 8098 this.author.add(t); 8099 return this; 8100 } 8101 8102 /** 8103 * @return The first repetition of repeating field {@link #author}, creating it 8104 * if it does not already exist 8105 */ 8106 public ContactDetail getAuthorFirstRep() { 8107 if (getAuthor().isEmpty()) { 8108 addAuthor(); 8109 } 8110 return getAuthor().get(0); 8111 } 8112 8113 /** 8114 * @return {@link #editor} (An individual or organization primarily responsible 8115 * for internal coherence of the content.) 8116 */ 8117 public List<ContactDetail> getEditor() { 8118 if (this.editor == null) 8119 this.editor = new ArrayList<ContactDetail>(); 8120 return this.editor; 8121 } 8122 8123 /** 8124 * @return Returns a reference to <code>this</code> for easy method chaining 8125 */ 8126 public PlanDefinition setEditor(List<ContactDetail> theEditor) { 8127 this.editor = theEditor; 8128 return this; 8129 } 8130 8131 public boolean hasEditor() { 8132 if (this.editor == null) 8133 return false; 8134 for (ContactDetail item : this.editor) 8135 if (!item.isEmpty()) 8136 return true; 8137 return false; 8138 } 8139 8140 public ContactDetail addEditor() { // 3 8141 ContactDetail t = new ContactDetail(); 8142 if (this.editor == null) 8143 this.editor = new ArrayList<ContactDetail>(); 8144 this.editor.add(t); 8145 return t; 8146 } 8147 8148 public PlanDefinition addEditor(ContactDetail t) { // 3 8149 if (t == null) 8150 return this; 8151 if (this.editor == null) 8152 this.editor = new ArrayList<ContactDetail>(); 8153 this.editor.add(t); 8154 return this; 8155 } 8156 8157 /** 8158 * @return The first repetition of repeating field {@link #editor}, creating it 8159 * if it does not already exist 8160 */ 8161 public ContactDetail getEditorFirstRep() { 8162 if (getEditor().isEmpty()) { 8163 addEditor(); 8164 } 8165 return getEditor().get(0); 8166 } 8167 8168 /** 8169 * @return {@link #reviewer} (An individual or organization primarily 8170 * responsible for review of some aspect of the content.) 8171 */ 8172 public List<ContactDetail> getReviewer() { 8173 if (this.reviewer == null) 8174 this.reviewer = new ArrayList<ContactDetail>(); 8175 return this.reviewer; 8176 } 8177 8178 /** 8179 * @return Returns a reference to <code>this</code> for easy method chaining 8180 */ 8181 public PlanDefinition setReviewer(List<ContactDetail> theReviewer) { 8182 this.reviewer = theReviewer; 8183 return this; 8184 } 8185 8186 public boolean hasReviewer() { 8187 if (this.reviewer == null) 8188 return false; 8189 for (ContactDetail item : this.reviewer) 8190 if (!item.isEmpty()) 8191 return true; 8192 return false; 8193 } 8194 8195 public ContactDetail addReviewer() { // 3 8196 ContactDetail t = new ContactDetail(); 8197 if (this.reviewer == null) 8198 this.reviewer = new ArrayList<ContactDetail>(); 8199 this.reviewer.add(t); 8200 return t; 8201 } 8202 8203 public PlanDefinition addReviewer(ContactDetail t) { // 3 8204 if (t == null) 8205 return this; 8206 if (this.reviewer == null) 8207 this.reviewer = new ArrayList<ContactDetail>(); 8208 this.reviewer.add(t); 8209 return this; 8210 } 8211 8212 /** 8213 * @return The first repetition of repeating field {@link #reviewer}, creating 8214 * it if it does not already exist 8215 */ 8216 public ContactDetail getReviewerFirstRep() { 8217 if (getReviewer().isEmpty()) { 8218 addReviewer(); 8219 } 8220 return getReviewer().get(0); 8221 } 8222 8223 /** 8224 * @return {@link #endorser} (An individual or organization responsible for 8225 * officially endorsing the content for use in some setting.) 8226 */ 8227 public List<ContactDetail> getEndorser() { 8228 if (this.endorser == null) 8229 this.endorser = new ArrayList<ContactDetail>(); 8230 return this.endorser; 8231 } 8232 8233 /** 8234 * @return Returns a reference to <code>this</code> for easy method chaining 8235 */ 8236 public PlanDefinition setEndorser(List<ContactDetail> theEndorser) { 8237 this.endorser = theEndorser; 8238 return this; 8239 } 8240 8241 public boolean hasEndorser() { 8242 if (this.endorser == null) 8243 return false; 8244 for (ContactDetail item : this.endorser) 8245 if (!item.isEmpty()) 8246 return true; 8247 return false; 8248 } 8249 8250 public ContactDetail addEndorser() { // 3 8251 ContactDetail t = new ContactDetail(); 8252 if (this.endorser == null) 8253 this.endorser = new ArrayList<ContactDetail>(); 8254 this.endorser.add(t); 8255 return t; 8256 } 8257 8258 public PlanDefinition addEndorser(ContactDetail t) { // 3 8259 if (t == null) 8260 return this; 8261 if (this.endorser == null) 8262 this.endorser = new ArrayList<ContactDetail>(); 8263 this.endorser.add(t); 8264 return this; 8265 } 8266 8267 /** 8268 * @return The first repetition of repeating field {@link #endorser}, creating 8269 * it if it does not already exist 8270 */ 8271 public ContactDetail getEndorserFirstRep() { 8272 if (getEndorser().isEmpty()) { 8273 addEndorser(); 8274 } 8275 return getEndorser().get(0); 8276 } 8277 8278 /** 8279 * @return {@link #relatedArtifact} (Related artifacts such as additional 8280 * documentation, justification, or bibliographic references.) 8281 */ 8282 public List<RelatedArtifact> getRelatedArtifact() { 8283 if (this.relatedArtifact == null) 8284 this.relatedArtifact = new ArrayList<RelatedArtifact>(); 8285 return this.relatedArtifact; 8286 } 8287 8288 /** 8289 * @return Returns a reference to <code>this</code> for easy method chaining 8290 */ 8291 public PlanDefinition setRelatedArtifact(List<RelatedArtifact> theRelatedArtifact) { 8292 this.relatedArtifact = theRelatedArtifact; 8293 return this; 8294 } 8295 8296 public boolean hasRelatedArtifact() { 8297 if (this.relatedArtifact == null) 8298 return false; 8299 for (RelatedArtifact item : this.relatedArtifact) 8300 if (!item.isEmpty()) 8301 return true; 8302 return false; 8303 } 8304 8305 public RelatedArtifact addRelatedArtifact() { // 3 8306 RelatedArtifact t = new RelatedArtifact(); 8307 if (this.relatedArtifact == null) 8308 this.relatedArtifact = new ArrayList<RelatedArtifact>(); 8309 this.relatedArtifact.add(t); 8310 return t; 8311 } 8312 8313 public PlanDefinition addRelatedArtifact(RelatedArtifact t) { // 3 8314 if (t == null) 8315 return this; 8316 if (this.relatedArtifact == null) 8317 this.relatedArtifact = new ArrayList<RelatedArtifact>(); 8318 this.relatedArtifact.add(t); 8319 return this; 8320 } 8321 8322 /** 8323 * @return The first repetition of repeating field {@link #relatedArtifact}, 8324 * creating it if it does not already exist 8325 */ 8326 public RelatedArtifact getRelatedArtifactFirstRep() { 8327 if (getRelatedArtifact().isEmpty()) { 8328 addRelatedArtifact(); 8329 } 8330 return getRelatedArtifact().get(0); 8331 } 8332 8333 /** 8334 * @return {@link #library} (A reference to a Library resource containing any 8335 * formal logic used by the plan definition.) 8336 */ 8337 public List<CanonicalType> getLibrary() { 8338 if (this.library == null) 8339 this.library = new ArrayList<CanonicalType>(); 8340 return this.library; 8341 } 8342 8343 /** 8344 * @return Returns a reference to <code>this</code> for easy method chaining 8345 */ 8346 public PlanDefinition setLibrary(List<CanonicalType> theLibrary) { 8347 this.library = theLibrary; 8348 return this; 8349 } 8350 8351 public boolean hasLibrary() { 8352 if (this.library == null) 8353 return false; 8354 for (CanonicalType item : this.library) 8355 if (!item.isEmpty()) 8356 return true; 8357 return false; 8358 } 8359 8360 /** 8361 * @return {@link #library} (A reference to a Library resource containing any 8362 * formal logic used by the plan definition.) 8363 */ 8364 public CanonicalType addLibraryElement() {// 2 8365 CanonicalType t = new CanonicalType(); 8366 if (this.library == null) 8367 this.library = new ArrayList<CanonicalType>(); 8368 this.library.add(t); 8369 return t; 8370 } 8371 8372 /** 8373 * @param value {@link #library} (A reference to a Library resource containing 8374 * any formal logic used by the plan definition.) 8375 */ 8376 public PlanDefinition addLibrary(String value) { // 1 8377 CanonicalType t = new CanonicalType(); 8378 t.setValue(value); 8379 if (this.library == null) 8380 this.library = new ArrayList<CanonicalType>(); 8381 this.library.add(t); 8382 return this; 8383 } 8384 8385 /** 8386 * @param value {@link #library} (A reference to a Library resource containing 8387 * any formal logic used by the plan definition.) 8388 */ 8389 public boolean hasLibrary(String value) { 8390 if (this.library == null) 8391 return false; 8392 for (CanonicalType v : this.library) 8393 if (v.getValue().equals(value)) // canonical(Library) 8394 return true; 8395 return false; 8396 } 8397 8398 /** 8399 * @return {@link #goal} (Goals that describe what the activities within the 8400 * plan are intended to achieve. For example, weight loss, restoring an 8401 * activity of daily living, obtaining herd immunity via immunization, 8402 * meeting a process improvement objective, etc.) 8403 */ 8404 public List<PlanDefinitionGoalComponent> getGoal() { 8405 if (this.goal == null) 8406 this.goal = new ArrayList<PlanDefinitionGoalComponent>(); 8407 return this.goal; 8408 } 8409 8410 /** 8411 * @return Returns a reference to <code>this</code> for easy method chaining 8412 */ 8413 public PlanDefinition setGoal(List<PlanDefinitionGoalComponent> theGoal) { 8414 this.goal = theGoal; 8415 return this; 8416 } 8417 8418 public boolean hasGoal() { 8419 if (this.goal == null) 8420 return false; 8421 for (PlanDefinitionGoalComponent item : this.goal) 8422 if (!item.isEmpty()) 8423 return true; 8424 return false; 8425 } 8426 8427 public PlanDefinitionGoalComponent addGoal() { // 3 8428 PlanDefinitionGoalComponent t = new PlanDefinitionGoalComponent(); 8429 if (this.goal == null) 8430 this.goal = new ArrayList<PlanDefinitionGoalComponent>(); 8431 this.goal.add(t); 8432 return t; 8433 } 8434 8435 public PlanDefinition addGoal(PlanDefinitionGoalComponent t) { // 3 8436 if (t == null) 8437 return this; 8438 if (this.goal == null) 8439 this.goal = new ArrayList<PlanDefinitionGoalComponent>(); 8440 this.goal.add(t); 8441 return this; 8442 } 8443 8444 /** 8445 * @return The first repetition of repeating field {@link #goal}, creating it if 8446 * it does not already exist 8447 */ 8448 public PlanDefinitionGoalComponent getGoalFirstRep() { 8449 if (getGoal().isEmpty()) { 8450 addGoal(); 8451 } 8452 return getGoal().get(0); 8453 } 8454 8455 /** 8456 * @return {@link #action} (An action or group of actions to be taken as part of 8457 * the plan.) 8458 */ 8459 public List<PlanDefinitionActionComponent> getAction() { 8460 if (this.action == null) 8461 this.action = new ArrayList<PlanDefinitionActionComponent>(); 8462 return this.action; 8463 } 8464 8465 /** 8466 * @return Returns a reference to <code>this</code> for easy method chaining 8467 */ 8468 public PlanDefinition setAction(List<PlanDefinitionActionComponent> theAction) { 8469 this.action = theAction; 8470 return this; 8471 } 8472 8473 public boolean hasAction() { 8474 if (this.action == null) 8475 return false; 8476 for (PlanDefinitionActionComponent item : this.action) 8477 if (!item.isEmpty()) 8478 return true; 8479 return false; 8480 } 8481 8482 public PlanDefinitionActionComponent addAction() { // 3 8483 PlanDefinitionActionComponent t = new PlanDefinitionActionComponent(); 8484 if (this.action == null) 8485 this.action = new ArrayList<PlanDefinitionActionComponent>(); 8486 this.action.add(t); 8487 return t; 8488 } 8489 8490 public PlanDefinition addAction(PlanDefinitionActionComponent t) { // 3 8491 if (t == null) 8492 return this; 8493 if (this.action == null) 8494 this.action = new ArrayList<PlanDefinitionActionComponent>(); 8495 this.action.add(t); 8496 return this; 8497 } 8498 8499 /** 8500 * @return The first repetition of repeating field {@link #action}, creating it 8501 * if it does not already exist 8502 */ 8503 public PlanDefinitionActionComponent getActionFirstRep() { 8504 if (getAction().isEmpty()) { 8505 addAction(); 8506 } 8507 return getAction().get(0); 8508 } 8509 8510 protected void listChildren(List<Property> children) { 8511 super.listChildren(children); 8512 children.add(new Property("url", "uri", 8513 "An absolute URI that is used to identify this plan definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this plan definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the plan definition is stored on different servers.", 8514 0, 1, url)); 8515 children.add(new Property("identifier", "Identifier", 8516 "A formal identifier that is used to identify this plan definition when it is represented in other formats, or referenced in a specification, model, design or an instance.", 8517 0, java.lang.Integer.MAX_VALUE, identifier)); 8518 children.add(new Property("version", "string", 8519 "The identifier that is used to identify this version of the plan definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the plan definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge assets, refer to the Decision Support Service specification. Note that a version is required for non-experimental active artifacts.", 8520 0, 1, version)); 8521 children.add(new Property("name", "string", 8522 "A natural language name identifying the plan definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 8523 0, 1, name)); 8524 children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the plan definition.", 8525 0, 1, title)); 8526 children.add(new Property("subtitle", "string", 8527 "An explanatory or alternate title for the plan definition giving additional information about its content.", 0, 8528 1, subtitle)); 8529 children.add(new Property("type", "CodeableConcept", 8530 "A high-level category for the plan definition that distinguishes the kinds of systems that would be interested in the plan definition.", 8531 0, 1, type)); 8532 children.add(new Property("status", "code", 8533 "The status of this plan definition. Enables tracking the life-cycle of the content.", 0, 1, status)); 8534 children.add(new Property("experimental", "boolean", 8535 "A Boolean value to indicate that this plan definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 8536 0, 1, experimental)); 8537 children.add(new Property("subject[x]", "CodeableConcept|Reference(Group)", 8538 "A code or group definition that describes the intended subject of the plan definition.", 0, 1, subject)); 8539 children.add(new Property("date", "dateTime", 8540 "The date (and optionally time) when the plan definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the plan definition changes.", 8541 0, 1, date)); 8542 children.add(new Property("publisher", "string", 8543 "The name of the organization or individual that published the plan definition.", 0, 1, publisher)); 8544 children.add(new Property("contact", "ContactDetail", 8545 "Contact details to assist a user in finding and communicating with the publisher.", 0, 8546 java.lang.Integer.MAX_VALUE, contact)); 8547 children.add(new Property("description", "markdown", 8548 "A free text natural language description of the plan definition from a consumer's perspective.", 0, 1, 8549 description)); 8550 children.add(new Property("useContext", "UsageContext", 8551 "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate plan definition instances.", 8552 0, java.lang.Integer.MAX_VALUE, useContext)); 8553 children.add(new Property("jurisdiction", "CodeableConcept", 8554 "A legal or geographic region in which the plan definition is intended to be used.", 0, 8555 java.lang.Integer.MAX_VALUE, jurisdiction)); 8556 children.add(new Property("purpose", "markdown", 8557 "Explanation of why this plan definition is needed and why it has been designed as it has.", 0, 1, purpose)); 8558 children.add(new Property("usage", "string", 8559 "A detailed description of how the plan definition is used from a clinical perspective.", 0, 1, usage)); 8560 children.add(new Property("copyright", "markdown", 8561 "A copyright statement relating to the plan definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the plan definition.", 8562 0, 1, copyright)); 8563 children.add(new Property("approvalDate", "date", 8564 "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.", 8565 0, 1, approvalDate)); 8566 children.add(new Property("lastReviewDate", "date", 8567 "The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date.", 8568 0, 1, lastReviewDate)); 8569 children.add(new Property("effectivePeriod", "Period", 8570 "The period during which the plan definition content was or is planned to be in active use.", 0, 1, 8571 effectivePeriod)); 8572 children.add(new Property("topic", "CodeableConcept", 8573 "Descriptive topics related to the content of the plan definition. Topics provide a high-level categorization of the definition that can be useful for filtering and searching.", 8574 0, java.lang.Integer.MAX_VALUE, topic)); 8575 children.add(new Property("author", "ContactDetail", 8576 "An individiual or organization primarily involved in the creation and maintenance of the content.", 0, 8577 java.lang.Integer.MAX_VALUE, author)); 8578 children.add(new Property("editor", "ContactDetail", 8579 "An individual or organization primarily responsible for internal coherence of the content.", 0, 8580 java.lang.Integer.MAX_VALUE, editor)); 8581 children.add(new Property("reviewer", "ContactDetail", 8582 "An individual or organization primarily responsible for review of some aspect of the content.", 0, 8583 java.lang.Integer.MAX_VALUE, reviewer)); 8584 children.add(new Property("endorser", "ContactDetail", 8585 "An individual or organization responsible for officially endorsing the content for use in some setting.", 0, 8586 java.lang.Integer.MAX_VALUE, endorser)); 8587 children.add(new Property("relatedArtifact", "RelatedArtifact", 8588 "Related artifacts such as additional documentation, justification, or bibliographic references.", 0, 8589 java.lang.Integer.MAX_VALUE, relatedArtifact)); 8590 children.add(new Property("library", "canonical(Library)", 8591 "A reference to a Library resource containing any formal logic used by the plan definition.", 0, 8592 java.lang.Integer.MAX_VALUE, library)); 8593 children.add(new Property("goal", "", 8594 "Goals that describe what the activities within the plan are intended to achieve. For example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.", 8595 0, java.lang.Integer.MAX_VALUE, goal)); 8596 children.add(new Property("action", "", "An action or group of actions to be taken as part of the plan.", 0, 8597 java.lang.Integer.MAX_VALUE, action)); 8598 } 8599 8600 @Override 8601 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 8602 switch (_hash) { 8603 case 116079: 8604 /* url */ return new Property("url", "uri", 8605 "An absolute URI that is used to identify this plan definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this plan definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the plan definition is stored on different servers.", 8606 0, 1, url); 8607 case -1618432855: 8608 /* identifier */ return new Property("identifier", "Identifier", 8609 "A formal identifier that is used to identify this plan definition when it is represented in other formats, or referenced in a specification, model, design or an instance.", 8610 0, java.lang.Integer.MAX_VALUE, identifier); 8611 case 351608024: 8612 /* version */ return new Property("version", "string", 8613 "The identifier that is used to identify this version of the plan definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the plan definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge assets, refer to the Decision Support Service specification. Note that a version is required for non-experimental active artifacts.", 8614 0, 1, version); 8615 case 3373707: 8616 /* name */ return new Property("name", "string", 8617 "A natural language name identifying the plan definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 8618 0, 1, name); 8619 case 110371416: 8620 /* title */ return new Property("title", "string", 8621 "A short, descriptive, user-friendly title for the plan definition.", 0, 1, title); 8622 case -2060497896: 8623 /* subtitle */ return new Property("subtitle", "string", 8624 "An explanatory or alternate title for the plan definition giving additional information about its content.", 8625 0, 1, subtitle); 8626 case 3575610: 8627 /* type */ return new Property("type", "CodeableConcept", 8628 "A high-level category for the plan definition that distinguishes the kinds of systems that would be interested in the plan definition.", 8629 0, 1, type); 8630 case -892481550: 8631 /* status */ return new Property("status", "code", 8632 "The status of this plan definition. Enables tracking the life-cycle of the content.", 0, 1, status); 8633 case -404562712: 8634 /* experimental */ return new Property("experimental", "boolean", 8635 "A Boolean value to indicate that this plan definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 8636 0, 1, experimental); 8637 case -573640748: 8638 /* subject[x] */ return new Property("subject[x]", "CodeableConcept|Reference(Group)", 8639 "A code or group definition that describes the intended subject of the plan definition.", 0, 1, subject); 8640 case -1867885268: 8641 /* subject */ return new Property("subject[x]", "CodeableConcept|Reference(Group)", 8642 "A code or group definition that describes the intended subject of the plan definition.", 0, 1, subject); 8643 case -1257122603: 8644 /* subjectCodeableConcept */ return new Property("subject[x]", "CodeableConcept|Reference(Group)", 8645 "A code or group definition that describes the intended subject of the plan definition.", 0, 1, subject); 8646 case 772938623: 8647 /* subjectReference */ return new Property("subject[x]", "CodeableConcept|Reference(Group)", 8648 "A code or group definition that describes the intended subject of the plan definition.", 0, 1, subject); 8649 case 3076014: 8650 /* date */ return new Property("date", "dateTime", 8651 "The date (and optionally time) when the plan definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the plan definition changes.", 8652 0, 1, date); 8653 case 1447404028: 8654 /* publisher */ return new Property("publisher", "string", 8655 "The name of the organization or individual that published the plan definition.", 0, 1, publisher); 8656 case 951526432: 8657 /* contact */ return new Property("contact", "ContactDetail", 8658 "Contact details to assist a user in finding and communicating with the publisher.", 0, 8659 java.lang.Integer.MAX_VALUE, contact); 8660 case -1724546052: 8661 /* description */ return new Property("description", "markdown", 8662 "A free text natural language description of the plan definition from a consumer's perspective.", 0, 1, 8663 description); 8664 case -669707736: 8665 /* useContext */ return new Property("useContext", "UsageContext", 8666 "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate plan definition instances.", 8667 0, java.lang.Integer.MAX_VALUE, useContext); 8668 case -507075711: 8669 /* jurisdiction */ return new Property("jurisdiction", "CodeableConcept", 8670 "A legal or geographic region in which the plan definition is intended to be used.", 0, 8671 java.lang.Integer.MAX_VALUE, jurisdiction); 8672 case -220463842: 8673 /* purpose */ return new Property("purpose", "markdown", 8674 "Explanation of why this plan definition is needed and why it has been designed as it has.", 0, 1, purpose); 8675 case 111574433: 8676 /* usage */ return new Property("usage", "string", 8677 "A detailed description of how the plan definition is used from a clinical perspective.", 0, 1, usage); 8678 case 1522889671: 8679 /* copyright */ return new Property("copyright", "markdown", 8680 "A copyright statement relating to the plan definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the plan definition.", 8681 0, 1, copyright); 8682 case 223539345: 8683 /* approvalDate */ return new Property("approvalDate", "date", 8684 "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.", 8685 0, 1, approvalDate); 8686 case -1687512484: 8687 /* lastReviewDate */ return new Property("lastReviewDate", "date", 8688 "The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date.", 8689 0, 1, lastReviewDate); 8690 case -403934648: 8691 /* effectivePeriod */ return new Property("effectivePeriod", "Period", 8692 "The period during which the plan definition content was or is planned to be in active use.", 0, 1, 8693 effectivePeriod); 8694 case 110546223: 8695 /* topic */ return new Property("topic", "CodeableConcept", 8696 "Descriptive topics related to the content of the plan definition. Topics provide a high-level categorization of the definition that can be useful for filtering and searching.", 8697 0, java.lang.Integer.MAX_VALUE, topic); 8698 case -1406328437: 8699 /* author */ return new Property("author", "ContactDetail", 8700 "An individiual or organization primarily involved in the creation and maintenance of the content.", 0, 8701 java.lang.Integer.MAX_VALUE, author); 8702 case -1307827859: 8703 /* editor */ return new Property("editor", "ContactDetail", 8704 "An individual or organization primarily responsible for internal coherence of the content.", 0, 8705 java.lang.Integer.MAX_VALUE, editor); 8706 case -261190139: 8707 /* reviewer */ return new Property("reviewer", "ContactDetail", 8708 "An individual or organization primarily responsible for review of some aspect of the content.", 0, 8709 java.lang.Integer.MAX_VALUE, reviewer); 8710 case 1740277666: 8711 /* endorser */ return new Property("endorser", "ContactDetail", 8712 "An individual or organization responsible for officially endorsing the content for use in some setting.", 0, 8713 java.lang.Integer.MAX_VALUE, endorser); 8714 case 666807069: 8715 /* relatedArtifact */ return new Property("relatedArtifact", "RelatedArtifact", 8716 "Related artifacts such as additional documentation, justification, or bibliographic references.", 0, 8717 java.lang.Integer.MAX_VALUE, relatedArtifact); 8718 case 166208699: 8719 /* library */ return new Property("library", "canonical(Library)", 8720 "A reference to a Library resource containing any formal logic used by the plan definition.", 0, 8721 java.lang.Integer.MAX_VALUE, library); 8722 case 3178259: 8723 /* goal */ return new Property("goal", "", 8724 "Goals that describe what the activities within the plan are intended to achieve. For example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.", 8725 0, java.lang.Integer.MAX_VALUE, goal); 8726 case -1422950858: 8727 /* action */ return new Property("action", "", "An action or group of actions to be taken as part of the plan.", 8728 0, java.lang.Integer.MAX_VALUE, action); 8729 default: 8730 return super.getNamedProperty(_hash, _name, _checkValid); 8731 } 8732 8733 } 8734 8735 @Override 8736 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 8737 switch (hash) { 8738 case 116079: 8739 /* url */ return this.url == null ? new Base[0] : new Base[] { this.url }; // UriType 8740 case -1618432855: 8741 /* identifier */ return this.identifier == null ? new Base[0] 8742 : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 8743 case 351608024: 8744 /* version */ return this.version == null ? new Base[0] : new Base[] { this.version }; // StringType 8745 case 3373707: 8746 /* name */ return this.name == null ? new Base[0] : new Base[] { this.name }; // StringType 8747 case 110371416: 8748 /* title */ return this.title == null ? new Base[0] : new Base[] { this.title }; // StringType 8749 case -2060497896: 8750 /* subtitle */ return this.subtitle == null ? new Base[0] : new Base[] { this.subtitle }; // StringType 8751 case 3575610: 8752 /* type */ return this.type == null ? new Base[0] : new Base[] { this.type }; // CodeableConcept 8753 case -892481550: 8754 /* status */ return this.status == null ? new Base[0] : new Base[] { this.status }; // Enumeration<PublicationStatus> 8755 case -404562712: 8756 /* experimental */ return this.experimental == null ? new Base[0] : new Base[] { this.experimental }; // BooleanType 8757 case -1867885268: 8758 /* subject */ return this.subject == null ? new Base[0] : new Base[] { this.subject }; // Type 8759 case 3076014: 8760 /* date */ return this.date == null ? new Base[0] : new Base[] { this.date }; // DateTimeType 8761 case 1447404028: 8762 /* publisher */ return this.publisher == null ? new Base[0] : new Base[] { this.publisher }; // StringType 8763 case 951526432: 8764 /* contact */ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 8765 case -1724546052: 8766 /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // MarkdownType 8767 case -669707736: 8768 /* useContext */ return this.useContext == null ? new Base[0] 8769 : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 8770 case -507075711: 8771 /* jurisdiction */ return this.jurisdiction == null ? new Base[0] 8772 : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 8773 case -220463842: 8774 /* purpose */ return this.purpose == null ? new Base[0] : new Base[] { this.purpose }; // MarkdownType 8775 case 111574433: 8776 /* usage */ return this.usage == null ? new Base[0] : new Base[] { this.usage }; // StringType 8777 case 1522889671: 8778 /* copyright */ return this.copyright == null ? new Base[0] : new Base[] { this.copyright }; // MarkdownType 8779 case 223539345: 8780 /* approvalDate */ return this.approvalDate == null ? new Base[0] : new Base[] { this.approvalDate }; // DateType 8781 case -1687512484: 8782 /* lastReviewDate */ return this.lastReviewDate == null ? new Base[0] : new Base[] { this.lastReviewDate }; // DateType 8783 case -403934648: 8784 /* effectivePeriod */ return this.effectivePeriod == null ? new Base[0] : new Base[] { this.effectivePeriod }; // Period 8785 case 110546223: 8786 /* topic */ return this.topic == null ? new Base[0] : this.topic.toArray(new Base[this.topic.size()]); // CodeableConcept 8787 case -1406328437: 8788 /* author */ return this.author == null ? new Base[0] : this.author.toArray(new Base[this.author.size()]); // ContactDetail 8789 case -1307827859: 8790 /* editor */ return this.editor == null ? new Base[0] : this.editor.toArray(new Base[this.editor.size()]); // ContactDetail 8791 case -261190139: 8792 /* reviewer */ return this.reviewer == null ? new Base[0] : this.reviewer.toArray(new Base[this.reviewer.size()]); // ContactDetail 8793 case 1740277666: 8794 /* endorser */ return this.endorser == null ? new Base[0] : this.endorser.toArray(new Base[this.endorser.size()]); // ContactDetail 8795 case 666807069: 8796 /* relatedArtifact */ return this.relatedArtifact == null ? new Base[0] 8797 : this.relatedArtifact.toArray(new Base[this.relatedArtifact.size()]); // RelatedArtifact 8798 case 166208699: 8799 /* library */ return this.library == null ? new Base[0] : this.library.toArray(new Base[this.library.size()]); // CanonicalType 8800 case 3178259: 8801 /* goal */ return this.goal == null ? new Base[0] : this.goal.toArray(new Base[this.goal.size()]); // PlanDefinitionGoalComponent 8802 case -1422950858: 8803 /* action */ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // PlanDefinitionActionComponent 8804 default: 8805 return super.getProperty(hash, name, checkValid); 8806 } 8807 8808 } 8809 8810 @Override 8811 public Base setProperty(int hash, String name, Base value) throws FHIRException { 8812 switch (hash) { 8813 case 116079: // url 8814 this.url = castToUri(value); // UriType 8815 return value; 8816 case -1618432855: // identifier 8817 this.getIdentifier().add(castToIdentifier(value)); // Identifier 8818 return value; 8819 case 351608024: // version 8820 this.version = castToString(value); // StringType 8821 return value; 8822 case 3373707: // name 8823 this.name = castToString(value); // StringType 8824 return value; 8825 case 110371416: // title 8826 this.title = castToString(value); // StringType 8827 return value; 8828 case -2060497896: // subtitle 8829 this.subtitle = castToString(value); // StringType 8830 return value; 8831 case 3575610: // type 8832 this.type = castToCodeableConcept(value); // CodeableConcept 8833 return value; 8834 case -892481550: // status 8835 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 8836 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 8837 return value; 8838 case -404562712: // experimental 8839 this.experimental = castToBoolean(value); // BooleanType 8840 return value; 8841 case -1867885268: // subject 8842 this.subject = castToType(value); // Type 8843 return value; 8844 case 3076014: // date 8845 this.date = castToDateTime(value); // DateTimeType 8846 return value; 8847 case 1447404028: // publisher 8848 this.publisher = castToString(value); // StringType 8849 return value; 8850 case 951526432: // contact 8851 this.getContact().add(castToContactDetail(value)); // ContactDetail 8852 return value; 8853 case -1724546052: // description 8854 this.description = castToMarkdown(value); // MarkdownType 8855 return value; 8856 case -669707736: // useContext 8857 this.getUseContext().add(castToUsageContext(value)); // UsageContext 8858 return value; 8859 case -507075711: // jurisdiction 8860 this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept 8861 return value; 8862 case -220463842: // purpose 8863 this.purpose = castToMarkdown(value); // MarkdownType 8864 return value; 8865 case 111574433: // usage 8866 this.usage = castToString(value); // StringType 8867 return value; 8868 case 1522889671: // copyright 8869 this.copyright = castToMarkdown(value); // MarkdownType 8870 return value; 8871 case 223539345: // approvalDate 8872 this.approvalDate = castToDate(value); // DateType 8873 return value; 8874 case -1687512484: // lastReviewDate 8875 this.lastReviewDate = castToDate(value); // DateType 8876 return value; 8877 case -403934648: // effectivePeriod 8878 this.effectivePeriod = castToPeriod(value); // Period 8879 return value; 8880 case 110546223: // topic 8881 this.getTopic().add(castToCodeableConcept(value)); // CodeableConcept 8882 return value; 8883 case -1406328437: // author 8884 this.getAuthor().add(castToContactDetail(value)); // ContactDetail 8885 return value; 8886 case -1307827859: // editor 8887 this.getEditor().add(castToContactDetail(value)); // ContactDetail 8888 return value; 8889 case -261190139: // reviewer 8890 this.getReviewer().add(castToContactDetail(value)); // ContactDetail 8891 return value; 8892 case 1740277666: // endorser 8893 this.getEndorser().add(castToContactDetail(value)); // ContactDetail 8894 return value; 8895 case 666807069: // relatedArtifact 8896 this.getRelatedArtifact().add(castToRelatedArtifact(value)); // RelatedArtifact 8897 return value; 8898 case 166208699: // library 8899 this.getLibrary().add(castToCanonical(value)); // CanonicalType 8900 return value; 8901 case 3178259: // goal 8902 this.getGoal().add((PlanDefinitionGoalComponent) value); // PlanDefinitionGoalComponent 8903 return value; 8904 case -1422950858: // action 8905 this.getAction().add((PlanDefinitionActionComponent) value); // PlanDefinitionActionComponent 8906 return value; 8907 default: 8908 return super.setProperty(hash, name, value); 8909 } 8910 8911 } 8912 8913 @Override 8914 public Base setProperty(String name, Base value) throws FHIRException { 8915 if (name.equals("url")) { 8916 this.url = castToUri(value); // UriType 8917 } else if (name.equals("identifier")) { 8918 this.getIdentifier().add(castToIdentifier(value)); 8919 } else if (name.equals("version")) { 8920 this.version = castToString(value); // StringType 8921 } else if (name.equals("name")) { 8922 this.name = castToString(value); // StringType 8923 } else if (name.equals("title")) { 8924 this.title = castToString(value); // StringType 8925 } else if (name.equals("subtitle")) { 8926 this.subtitle = castToString(value); // StringType 8927 } else if (name.equals("type")) { 8928 this.type = castToCodeableConcept(value); // CodeableConcept 8929 } else if (name.equals("status")) { 8930 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 8931 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 8932 } else if (name.equals("experimental")) { 8933 this.experimental = castToBoolean(value); // BooleanType 8934 } else if (name.equals("subject[x]")) { 8935 this.subject = castToType(value); // Type 8936 } else if (name.equals("date")) { 8937 this.date = castToDateTime(value); // DateTimeType 8938 } else if (name.equals("publisher")) { 8939 this.publisher = castToString(value); // StringType 8940 } else if (name.equals("contact")) { 8941 this.getContact().add(castToContactDetail(value)); 8942 } else if (name.equals("description")) { 8943 this.description = castToMarkdown(value); // MarkdownType 8944 } else if (name.equals("useContext")) { 8945 this.getUseContext().add(castToUsageContext(value)); 8946 } else if (name.equals("jurisdiction")) { 8947 this.getJurisdiction().add(castToCodeableConcept(value)); 8948 } else if (name.equals("purpose")) { 8949 this.purpose = castToMarkdown(value); // MarkdownType 8950 } else if (name.equals("usage")) { 8951 this.usage = castToString(value); // StringType 8952 } else if (name.equals("copyright")) { 8953 this.copyright = castToMarkdown(value); // MarkdownType 8954 } else if (name.equals("approvalDate")) { 8955 this.approvalDate = castToDate(value); // DateType 8956 } else if (name.equals("lastReviewDate")) { 8957 this.lastReviewDate = castToDate(value); // DateType 8958 } else if (name.equals("effectivePeriod")) { 8959 this.effectivePeriod = castToPeriod(value); // Period 8960 } else if (name.equals("topic")) { 8961 this.getTopic().add(castToCodeableConcept(value)); 8962 } else if (name.equals("author")) { 8963 this.getAuthor().add(castToContactDetail(value)); 8964 } else if (name.equals("editor")) { 8965 this.getEditor().add(castToContactDetail(value)); 8966 } else if (name.equals("reviewer")) { 8967 this.getReviewer().add(castToContactDetail(value)); 8968 } else if (name.equals("endorser")) { 8969 this.getEndorser().add(castToContactDetail(value)); 8970 } else if (name.equals("relatedArtifact")) { 8971 this.getRelatedArtifact().add(castToRelatedArtifact(value)); 8972 } else if (name.equals("library")) { 8973 this.getLibrary().add(castToCanonical(value)); 8974 } else if (name.equals("goal")) { 8975 this.getGoal().add((PlanDefinitionGoalComponent) value); 8976 } else if (name.equals("action")) { 8977 this.getAction().add((PlanDefinitionActionComponent) value); 8978 } else 8979 return super.setProperty(name, value); 8980 return value; 8981 } 8982 8983 @Override 8984 public void removeChild(String name, Base value) throws FHIRException { 8985 if (name.equals("url")) { 8986 this.url = null; 8987 } else if (name.equals("identifier")) { 8988 this.getIdentifier().remove(castToIdentifier(value)); 8989 } else if (name.equals("version")) { 8990 this.version = null; 8991 } else if (name.equals("name")) { 8992 this.name = null; 8993 } else if (name.equals("title")) { 8994 this.title = null; 8995 } else if (name.equals("subtitle")) { 8996 this.subtitle = null; 8997 } else if (name.equals("type")) { 8998 this.type = null; 8999 } else if (name.equals("status")) { 9000 this.status = null; 9001 } else if (name.equals("experimental")) { 9002 this.experimental = null; 9003 } else if (name.equals("subject[x]")) { 9004 this.subject = null; 9005 } else if (name.equals("date")) { 9006 this.date = null; 9007 } else if (name.equals("publisher")) { 9008 this.publisher = null; 9009 } else if (name.equals("contact")) { 9010 this.getContact().remove(castToContactDetail(value)); 9011 } else if (name.equals("description")) { 9012 this.description = null; 9013 } else if (name.equals("useContext")) { 9014 this.getUseContext().remove(castToUsageContext(value)); 9015 } else if (name.equals("jurisdiction")) { 9016 this.getJurisdiction().remove(castToCodeableConcept(value)); 9017 } else if (name.equals("purpose")) { 9018 this.purpose = null; 9019 } else if (name.equals("usage")) { 9020 this.usage = null; 9021 } else if (name.equals("copyright")) { 9022 this.copyright = null; 9023 } else if (name.equals("approvalDate")) { 9024 this.approvalDate = null; 9025 } else if (name.equals("lastReviewDate")) { 9026 this.lastReviewDate = null; 9027 } else if (name.equals("effectivePeriod")) { 9028 this.effectivePeriod = null; 9029 } else if (name.equals("topic")) { 9030 this.getTopic().remove(castToCodeableConcept(value)); 9031 } else if (name.equals("author")) { 9032 this.getAuthor().remove(castToContactDetail(value)); 9033 } else if (name.equals("editor")) { 9034 this.getEditor().remove(castToContactDetail(value)); 9035 } else if (name.equals("reviewer")) { 9036 this.getReviewer().remove(castToContactDetail(value)); 9037 } else if (name.equals("endorser")) { 9038 this.getEndorser().remove(castToContactDetail(value)); 9039 } else if (name.equals("relatedArtifact")) { 9040 this.getRelatedArtifact().remove(castToRelatedArtifact(value)); 9041 } else if (name.equals("library")) { 9042 this.getLibrary().remove(castToCanonical(value)); 9043 } else if (name.equals("goal")) { 9044 this.getGoal().remove((PlanDefinitionGoalComponent) value); 9045 } else if (name.equals("action")) { 9046 this.getAction().remove((PlanDefinitionActionComponent) value); 9047 } else 9048 super.removeChild(name, value); 9049 9050 } 9051 9052 @Override 9053 public Base makeProperty(int hash, String name) throws FHIRException { 9054 switch (hash) { 9055 case 116079: 9056 return getUrlElement(); 9057 case -1618432855: 9058 return addIdentifier(); 9059 case 351608024: 9060 return getVersionElement(); 9061 case 3373707: 9062 return getNameElement(); 9063 case 110371416: 9064 return getTitleElement(); 9065 case -2060497896: 9066 return getSubtitleElement(); 9067 case 3575610: 9068 return getType(); 9069 case -892481550: 9070 return getStatusElement(); 9071 case -404562712: 9072 return getExperimentalElement(); 9073 case -573640748: 9074 return getSubject(); 9075 case -1867885268: 9076 return getSubject(); 9077 case 3076014: 9078 return getDateElement(); 9079 case 1447404028: 9080 return getPublisherElement(); 9081 case 951526432: 9082 return addContact(); 9083 case -1724546052: 9084 return getDescriptionElement(); 9085 case -669707736: 9086 return addUseContext(); 9087 case -507075711: 9088 return addJurisdiction(); 9089 case -220463842: 9090 return getPurposeElement(); 9091 case 111574433: 9092 return getUsageElement(); 9093 case 1522889671: 9094 return getCopyrightElement(); 9095 case 223539345: 9096 return getApprovalDateElement(); 9097 case -1687512484: 9098 return getLastReviewDateElement(); 9099 case -403934648: 9100 return getEffectivePeriod(); 9101 case 110546223: 9102 return addTopic(); 9103 case -1406328437: 9104 return addAuthor(); 9105 case -1307827859: 9106 return addEditor(); 9107 case -261190139: 9108 return addReviewer(); 9109 case 1740277666: 9110 return addEndorser(); 9111 case 666807069: 9112 return addRelatedArtifact(); 9113 case 166208699: 9114 return addLibraryElement(); 9115 case 3178259: 9116 return addGoal(); 9117 case -1422950858: 9118 return addAction(); 9119 default: 9120 return super.makeProperty(hash, name); 9121 } 9122 9123 } 9124 9125 @Override 9126 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 9127 switch (hash) { 9128 case 116079: 9129 /* url */ return new String[] { "uri" }; 9130 case -1618432855: 9131 /* identifier */ return new String[] { "Identifier" }; 9132 case 351608024: 9133 /* version */ return new String[] { "string" }; 9134 case 3373707: 9135 /* name */ return new String[] { "string" }; 9136 case 110371416: 9137 /* title */ return new String[] { "string" }; 9138 case -2060497896: 9139 /* subtitle */ return new String[] { "string" }; 9140 case 3575610: 9141 /* type */ return new String[] { "CodeableConcept" }; 9142 case -892481550: 9143 /* status */ return new String[] { "code" }; 9144 case -404562712: 9145 /* experimental */ return new String[] { "boolean" }; 9146 case -1867885268: 9147 /* subject */ return new String[] { "CodeableConcept", "Reference" }; 9148 case 3076014: 9149 /* date */ return new String[] { "dateTime" }; 9150 case 1447404028: 9151 /* publisher */ return new String[] { "string" }; 9152 case 951526432: 9153 /* contact */ return new String[] { "ContactDetail" }; 9154 case -1724546052: 9155 /* description */ return new String[] { "markdown" }; 9156 case -669707736: 9157 /* useContext */ return new String[] { "UsageContext" }; 9158 case -507075711: 9159 /* jurisdiction */ return new String[] { "CodeableConcept" }; 9160 case -220463842: 9161 /* purpose */ return new String[] { "markdown" }; 9162 case 111574433: 9163 /* usage */ return new String[] { "string" }; 9164 case 1522889671: 9165 /* copyright */ return new String[] { "markdown" }; 9166 case 223539345: 9167 /* approvalDate */ return new String[] { "date" }; 9168 case -1687512484: 9169 /* lastReviewDate */ return new String[] { "date" }; 9170 case -403934648: 9171 /* effectivePeriod */ return new String[] { "Period" }; 9172 case 110546223: 9173 /* topic */ return new String[] { "CodeableConcept" }; 9174 case -1406328437: 9175 /* author */ return new String[] { "ContactDetail" }; 9176 case -1307827859: 9177 /* editor */ return new String[] { "ContactDetail" }; 9178 case -261190139: 9179 /* reviewer */ return new String[] { "ContactDetail" }; 9180 case 1740277666: 9181 /* endorser */ return new String[] { "ContactDetail" }; 9182 case 666807069: 9183 /* relatedArtifact */ return new String[] { "RelatedArtifact" }; 9184 case 166208699: 9185 /* library */ return new String[] { "canonical" }; 9186 case 3178259: 9187 /* goal */ return new String[] {}; 9188 case -1422950858: 9189 /* action */ return new String[] {}; 9190 default: 9191 return super.getTypesForProperty(hash, name); 9192 } 9193 9194 } 9195 9196 @Override 9197 public Base addChild(String name) throws FHIRException { 9198 if (name.equals("url")) { 9199 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.url"); 9200 } else if (name.equals("identifier")) { 9201 return addIdentifier(); 9202 } else if (name.equals("version")) { 9203 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.version"); 9204 } else if (name.equals("name")) { 9205 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.name"); 9206 } else if (name.equals("title")) { 9207 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.title"); 9208 } else if (name.equals("subtitle")) { 9209 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.subtitle"); 9210 } else if (name.equals("type")) { 9211 this.type = new CodeableConcept(); 9212 return this.type; 9213 } else if (name.equals("status")) { 9214 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.status"); 9215 } else if (name.equals("experimental")) { 9216 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.experimental"); 9217 } else if (name.equals("subjectCodeableConcept")) { 9218 this.subject = new CodeableConcept(); 9219 return this.subject; 9220 } else if (name.equals("subjectReference")) { 9221 this.subject = new Reference(); 9222 return this.subject; 9223 } else if (name.equals("date")) { 9224 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.date"); 9225 } else if (name.equals("publisher")) { 9226 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.publisher"); 9227 } else if (name.equals("contact")) { 9228 return addContact(); 9229 } else if (name.equals("description")) { 9230 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.description"); 9231 } else if (name.equals("useContext")) { 9232 return addUseContext(); 9233 } else if (name.equals("jurisdiction")) { 9234 return addJurisdiction(); 9235 } else if (name.equals("purpose")) { 9236 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.purpose"); 9237 } else if (name.equals("usage")) { 9238 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.usage"); 9239 } else if (name.equals("copyright")) { 9240 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.copyright"); 9241 } else if (name.equals("approvalDate")) { 9242 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.approvalDate"); 9243 } else if (name.equals("lastReviewDate")) { 9244 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.lastReviewDate"); 9245 } else if (name.equals("effectivePeriod")) { 9246 this.effectivePeriod = new Period(); 9247 return this.effectivePeriod; 9248 } else if (name.equals("topic")) { 9249 return addTopic(); 9250 } else if (name.equals("author")) { 9251 return addAuthor(); 9252 } else if (name.equals("editor")) { 9253 return addEditor(); 9254 } else if (name.equals("reviewer")) { 9255 return addReviewer(); 9256 } else if (name.equals("endorser")) { 9257 return addEndorser(); 9258 } else if (name.equals("relatedArtifact")) { 9259 return addRelatedArtifact(); 9260 } else if (name.equals("library")) { 9261 throw new FHIRException("Cannot call addChild on a singleton property PlanDefinition.library"); 9262 } else if (name.equals("goal")) { 9263 return addGoal(); 9264 } else if (name.equals("action")) { 9265 return addAction(); 9266 } else 9267 return super.addChild(name); 9268 } 9269 9270 public String fhirType() { 9271 return "PlanDefinition"; 9272 9273 } 9274 9275 public PlanDefinition copy() { 9276 PlanDefinition dst = new PlanDefinition(); 9277 copyValues(dst); 9278 return dst; 9279 } 9280 9281 public void copyValues(PlanDefinition dst) { 9282 super.copyValues(dst); 9283 dst.url = url == null ? null : url.copy(); 9284 if (identifier != null) { 9285 dst.identifier = new ArrayList<Identifier>(); 9286 for (Identifier i : identifier) 9287 dst.identifier.add(i.copy()); 9288 } 9289 ; 9290 dst.version = version == null ? null : version.copy(); 9291 dst.name = name == null ? null : name.copy(); 9292 dst.title = title == null ? null : title.copy(); 9293 dst.subtitle = subtitle == null ? null : subtitle.copy(); 9294 dst.type = type == null ? null : type.copy(); 9295 dst.status = status == null ? null : status.copy(); 9296 dst.experimental = experimental == null ? null : experimental.copy(); 9297 dst.subject = subject == null ? null : subject.copy(); 9298 dst.date = date == null ? null : date.copy(); 9299 dst.publisher = publisher == null ? null : publisher.copy(); 9300 if (contact != null) { 9301 dst.contact = new ArrayList<ContactDetail>(); 9302 for (ContactDetail i : contact) 9303 dst.contact.add(i.copy()); 9304 } 9305 ; 9306 dst.description = description == null ? null : description.copy(); 9307 if (useContext != null) { 9308 dst.useContext = new ArrayList<UsageContext>(); 9309 for (UsageContext i : useContext) 9310 dst.useContext.add(i.copy()); 9311 } 9312 ; 9313 if (jurisdiction != null) { 9314 dst.jurisdiction = new ArrayList<CodeableConcept>(); 9315 for (CodeableConcept i : jurisdiction) 9316 dst.jurisdiction.add(i.copy()); 9317 } 9318 ; 9319 dst.purpose = purpose == null ? null : purpose.copy(); 9320 dst.usage = usage == null ? null : usage.copy(); 9321 dst.copyright = copyright == null ? null : copyright.copy(); 9322 dst.approvalDate = approvalDate == null ? null : approvalDate.copy(); 9323 dst.lastReviewDate = lastReviewDate == null ? null : lastReviewDate.copy(); 9324 dst.effectivePeriod = effectivePeriod == null ? null : effectivePeriod.copy(); 9325 if (topic != null) { 9326 dst.topic = new ArrayList<CodeableConcept>(); 9327 for (CodeableConcept i : topic) 9328 dst.topic.add(i.copy()); 9329 } 9330 ; 9331 if (author != null) { 9332 dst.author = new ArrayList<ContactDetail>(); 9333 for (ContactDetail i : author) 9334 dst.author.add(i.copy()); 9335 } 9336 ; 9337 if (editor != null) { 9338 dst.editor = new ArrayList<ContactDetail>(); 9339 for (ContactDetail i : editor) 9340 dst.editor.add(i.copy()); 9341 } 9342 ; 9343 if (reviewer != null) { 9344 dst.reviewer = new ArrayList<ContactDetail>(); 9345 for (ContactDetail i : reviewer) 9346 dst.reviewer.add(i.copy()); 9347 } 9348 ; 9349 if (endorser != null) { 9350 dst.endorser = new ArrayList<ContactDetail>(); 9351 for (ContactDetail i : endorser) 9352 dst.endorser.add(i.copy()); 9353 } 9354 ; 9355 if (relatedArtifact != null) { 9356 dst.relatedArtifact = new ArrayList<RelatedArtifact>(); 9357 for (RelatedArtifact i : relatedArtifact) 9358 dst.relatedArtifact.add(i.copy()); 9359 } 9360 ; 9361 if (library != null) { 9362 dst.library = new ArrayList<CanonicalType>(); 9363 for (CanonicalType i : library) 9364 dst.library.add(i.copy()); 9365 } 9366 ; 9367 if (goal != null) { 9368 dst.goal = new ArrayList<PlanDefinitionGoalComponent>(); 9369 for (PlanDefinitionGoalComponent i : goal) 9370 dst.goal.add(i.copy()); 9371 } 9372 ; 9373 if (action != null) { 9374 dst.action = new ArrayList<PlanDefinitionActionComponent>(); 9375 for (PlanDefinitionActionComponent i : action) 9376 dst.action.add(i.copy()); 9377 } 9378 ; 9379 } 9380 9381 protected PlanDefinition typedCopy() { 9382 return copy(); 9383 } 9384 9385 @Override 9386 public boolean equalsDeep(Base other_) { 9387 if (!super.equalsDeep(other_)) 9388 return false; 9389 if (!(other_ instanceof PlanDefinition)) 9390 return false; 9391 PlanDefinition o = (PlanDefinition) other_; 9392 return compareDeep(identifier, o.identifier, true) && compareDeep(subtitle, o.subtitle, true) 9393 && compareDeep(type, o.type, true) && compareDeep(subject, o.subject, true) 9394 && compareDeep(purpose, o.purpose, true) && compareDeep(usage, o.usage, true) 9395 && compareDeep(copyright, o.copyright, true) && compareDeep(approvalDate, o.approvalDate, true) 9396 && compareDeep(lastReviewDate, o.lastReviewDate, true) && compareDeep(effectivePeriod, o.effectivePeriod, true) 9397 && compareDeep(topic, o.topic, true) && compareDeep(author, o.author, true) 9398 && compareDeep(editor, o.editor, true) && compareDeep(reviewer, o.reviewer, true) 9399 && compareDeep(endorser, o.endorser, true) && compareDeep(relatedArtifact, o.relatedArtifact, true) 9400 && compareDeep(library, o.library, true) && compareDeep(goal, o.goal, true) 9401 && compareDeep(action, o.action, true); 9402 } 9403 9404 @Override 9405 public boolean equalsShallow(Base other_) { 9406 if (!super.equalsShallow(other_)) 9407 return false; 9408 if (!(other_ instanceof PlanDefinition)) 9409 return false; 9410 PlanDefinition o = (PlanDefinition) other_; 9411 return compareValues(subtitle, o.subtitle, true) && compareValues(purpose, o.purpose, true) 9412 && compareValues(usage, o.usage, true) && compareValues(copyright, o.copyright, true) 9413 && compareValues(approvalDate, o.approvalDate, true) && compareValues(lastReviewDate, o.lastReviewDate, true); 9414 } 9415 9416 public boolean isEmpty() { 9417 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, subtitle, type, subject, purpose, usage, 9418 copyright, approvalDate, lastReviewDate, effectivePeriod, topic, author, editor, reviewer, endorser, 9419 relatedArtifact, library, goal, action); 9420 } 9421 9422 @Override 9423 public ResourceType getResourceType() { 9424 return ResourceType.PlanDefinition; 9425 } 9426 9427 /** 9428 * Search parameter: <b>date</b> 9429 * <p> 9430 * Description: <b>The plan definition publication date</b><br> 9431 * Type: <b>date</b><br> 9432 * Path: <b>PlanDefinition.date</b><br> 9433 * </p> 9434 */ 9435 @SearchParamDefinition(name = "date", path = "PlanDefinition.date", description = "The plan definition publication date", type = "date") 9436 public static final String SP_DATE = "date"; 9437 /** 9438 * <b>Fluent Client</b> search parameter constant for <b>date</b> 9439 * <p> 9440 * Description: <b>The plan definition publication date</b><br> 9441 * Type: <b>date</b><br> 9442 * Path: <b>PlanDefinition.date</b><br> 9443 * </p> 9444 */ 9445 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam( 9446 SP_DATE); 9447 9448 /** 9449 * Search parameter: <b>identifier</b> 9450 * <p> 9451 * Description: <b>External identifier for the plan definition</b><br> 9452 * Type: <b>token</b><br> 9453 * Path: <b>PlanDefinition.identifier</b><br> 9454 * </p> 9455 */ 9456 @SearchParamDefinition(name = "identifier", path = "PlanDefinition.identifier", description = "External identifier for the plan definition", type = "token") 9457 public static final String SP_IDENTIFIER = "identifier"; 9458 /** 9459 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 9460 * <p> 9461 * Description: <b>External identifier for the plan definition</b><br> 9462 * Type: <b>token</b><br> 9463 * Path: <b>PlanDefinition.identifier</b><br> 9464 * </p> 9465 */ 9466 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam( 9467 SP_IDENTIFIER); 9468 9469 /** 9470 * Search parameter: <b>successor</b> 9471 * <p> 9472 * Description: <b>What resource is being referenced</b><br> 9473 * Type: <b>reference</b><br> 9474 * Path: <b>PlanDefinition.relatedArtifact.resource</b><br> 9475 * </p> 9476 */ 9477 @SearchParamDefinition(name = "successor", path = "PlanDefinition.relatedArtifact.where(type='successor').resource", description = "What resource is being referenced", type = "reference") 9478 public static final String SP_SUCCESSOR = "successor"; 9479 /** 9480 * <b>Fluent Client</b> search parameter constant for <b>successor</b> 9481 * <p> 9482 * Description: <b>What resource is being referenced</b><br> 9483 * Type: <b>reference</b><br> 9484 * Path: <b>PlanDefinition.relatedArtifact.resource</b><br> 9485 * </p> 9486 */ 9487 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUCCESSOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 9488 SP_SUCCESSOR); 9489 9490 /** 9491 * Constant for fluent queries to be used to add include statements. Specifies 9492 * the path value of "<b>PlanDefinition:successor</b>". 9493 */ 9494 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUCCESSOR = new ca.uhn.fhir.model.api.Include( 9495 "PlanDefinition:successor").toLocked(); 9496 9497 /** 9498 * Search parameter: <b>context-type-value</b> 9499 * <p> 9500 * Description: <b>A use context type and value assigned to the plan 9501 * definition</b><br> 9502 * Type: <b>composite</b><br> 9503 * Path: <b></b><br> 9504 * </p> 9505 */ 9506 @SearchParamDefinition(name = "context-type-value", path = "PlanDefinition.useContext", description = "A use context type and value assigned to the plan definition", type = "composite", compositeOf = { 9507 "context-type", "context" }) 9508 public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value"; 9509 /** 9510 * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b> 9511 * <p> 9512 * Description: <b>A use context type and value assigned to the plan 9513 * definition</b><br> 9514 * Type: <b>composite</b><br> 9515 * Path: <b></b><br> 9516 * </p> 9517 */ 9518 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CONTEXT_TYPE_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>( 9519 SP_CONTEXT_TYPE_VALUE); 9520 9521 /** 9522 * Search parameter: <b>jurisdiction</b> 9523 * <p> 9524 * Description: <b>Intended jurisdiction for the plan definition</b><br> 9525 * Type: <b>token</b><br> 9526 * Path: <b>PlanDefinition.jurisdiction</b><br> 9527 * </p> 9528 */ 9529 @SearchParamDefinition(name = "jurisdiction", path = "PlanDefinition.jurisdiction", description = "Intended jurisdiction for the plan definition", type = "token") 9530 public static final String SP_JURISDICTION = "jurisdiction"; 9531 /** 9532 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 9533 * <p> 9534 * Description: <b>Intended jurisdiction for the plan definition</b><br> 9535 * Type: <b>token</b><br> 9536 * Path: <b>PlanDefinition.jurisdiction</b><br> 9537 * </p> 9538 */ 9539 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam( 9540 SP_JURISDICTION); 9541 9542 /** 9543 * Search parameter: <b>description</b> 9544 * <p> 9545 * Description: <b>The description of the plan definition</b><br> 9546 * Type: <b>string</b><br> 9547 * Path: <b>PlanDefinition.description</b><br> 9548 * </p> 9549 */ 9550 @SearchParamDefinition(name = "description", path = "PlanDefinition.description", description = "The description of the plan definition", type = "string") 9551 public static final String SP_DESCRIPTION = "description"; 9552 /** 9553 * <b>Fluent Client</b> search parameter constant for <b>description</b> 9554 * <p> 9555 * Description: <b>The description of the plan definition</b><br> 9556 * Type: <b>string</b><br> 9557 * Path: <b>PlanDefinition.description</b><br> 9558 * </p> 9559 */ 9560 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam( 9561 SP_DESCRIPTION); 9562 9563 /** 9564 * Search parameter: <b>derived-from</b> 9565 * <p> 9566 * Description: <b>What resource is being referenced</b><br> 9567 * Type: <b>reference</b><br> 9568 * Path: <b>PlanDefinition.relatedArtifact.resource</b><br> 9569 * </p> 9570 */ 9571 @SearchParamDefinition(name = "derived-from", path = "PlanDefinition.relatedArtifact.where(type='derived-from').resource", description = "What resource is being referenced", type = "reference") 9572 public static final String SP_DERIVED_FROM = "derived-from"; 9573 /** 9574 * <b>Fluent Client</b> search parameter constant for <b>derived-from</b> 9575 * <p> 9576 * Description: <b>What resource is being referenced</b><br> 9577 * Type: <b>reference</b><br> 9578 * Path: <b>PlanDefinition.relatedArtifact.resource</b><br> 9579 * </p> 9580 */ 9581 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam DERIVED_FROM = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 9582 SP_DERIVED_FROM); 9583 9584 /** 9585 * Constant for fluent queries to be used to add include statements. Specifies 9586 * the path value of "<b>PlanDefinition:derived-from</b>". 9587 */ 9588 public static final ca.uhn.fhir.model.api.Include INCLUDE_DERIVED_FROM = new ca.uhn.fhir.model.api.Include( 9589 "PlanDefinition:derived-from").toLocked(); 9590 9591 /** 9592 * Search parameter: <b>context-type</b> 9593 * <p> 9594 * Description: <b>A type of use context assigned to the plan definition</b><br> 9595 * Type: <b>token</b><br> 9596 * Path: <b>PlanDefinition.useContext.code</b><br> 9597 * </p> 9598 */ 9599 @SearchParamDefinition(name = "context-type", path = "PlanDefinition.useContext.code", description = "A type of use context assigned to the plan definition", type = "token") 9600 public static final String SP_CONTEXT_TYPE = "context-type"; 9601 /** 9602