![](/hapi-fhir/images/logos/raccoon-forwards.png)
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.utilities.Utilities; 040 041import ca.uhn.fhir.model.api.annotation.Block; 042import ca.uhn.fhir.model.api.annotation.Child; 043import ca.uhn.fhir.model.api.annotation.Description; 044import ca.uhn.fhir.model.api.annotation.ResourceDef; 045import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 046 047/** 048 * A group of related requests that can be used to capture intended activities 049 * that have inter-dependencies such as "give this medication after that one". 050 */ 051@ResourceDef(name = "RequestGroup", profile = "http://hl7.org/fhir/StructureDefinition/RequestGroup") 052public class RequestGroup extends DomainResource { 053 054 public enum RequestStatus { 055 /** 056 * The request has been created but is not yet complete or ready for action. 057 */ 058 DRAFT, 059 /** 060 * The request is in force and ready to be acted upon. 061 */ 062 ACTIVE, 063 /** 064 * The request (and any implicit authorization to act) has been temporarily 065 * withdrawn but is expected to resume in the future. 066 */ 067 ONHOLD, 068 /** 069 * The request (and any implicit authorization to act) has been terminated prior 070 * to the known full completion of the intended actions. No further activity 071 * should occur. 072 */ 073 REVOKED, 074 /** 075 * The activity described by the request has been fully performed. No further 076 * activity will occur. 077 */ 078 COMPLETED, 079 /** 080 * This request should never have existed and should be considered 'void'. (It 081 * is possible that real-world decisions were based on it. If real-world 082 * activity has occurred, the status should be "revoked" rather than 083 * "entered-in-error".). 084 */ 085 ENTEREDINERROR, 086 /** 087 * The authoring/source system does not know which of the status values 088 * currently applies for this request. Note: This concept is not to be used for 089 * "other" - one of the listed statuses is presumed to apply, but the 090 * authoring/source system does not know which. 091 */ 092 UNKNOWN, 093 /** 094 * added to help the parsers with the generic types 095 */ 096 NULL; 097 098 public static RequestStatus fromCode(String codeString) throws FHIRException { 099 if (codeString == null || "".equals(codeString)) 100 return null; 101 if ("draft".equals(codeString)) 102 return DRAFT; 103 if ("active".equals(codeString)) 104 return ACTIVE; 105 if ("on-hold".equals(codeString)) 106 return ONHOLD; 107 if ("revoked".equals(codeString)) 108 return REVOKED; 109 if ("completed".equals(codeString)) 110 return COMPLETED; 111 if ("entered-in-error".equals(codeString)) 112 return ENTEREDINERROR; 113 if ("unknown".equals(codeString)) 114 return UNKNOWN; 115 if (Configuration.isAcceptInvalidEnums()) 116 return null; 117 else 118 throw new FHIRException("Unknown RequestStatus code '" + codeString + "'"); 119 } 120 121 public String toCode() { 122 switch (this) { 123 case DRAFT: 124 return "draft"; 125 case ACTIVE: 126 return "active"; 127 case ONHOLD: 128 return "on-hold"; 129 case REVOKED: 130 return "revoked"; 131 case COMPLETED: 132 return "completed"; 133 case ENTEREDINERROR: 134 return "entered-in-error"; 135 case UNKNOWN: 136 return "unknown"; 137 case NULL: 138 return null; 139 default: 140 return "?"; 141 } 142 } 143 144 public String getSystem() { 145 switch (this) { 146 case DRAFT: 147 return "http://hl7.org/fhir/request-status"; 148 case ACTIVE: 149 return "http://hl7.org/fhir/request-status"; 150 case ONHOLD: 151 return "http://hl7.org/fhir/request-status"; 152 case REVOKED: 153 return "http://hl7.org/fhir/request-status"; 154 case COMPLETED: 155 return "http://hl7.org/fhir/request-status"; 156 case ENTEREDINERROR: 157 return "http://hl7.org/fhir/request-status"; 158 case UNKNOWN: 159 return "http://hl7.org/fhir/request-status"; 160 case NULL: 161 return null; 162 default: 163 return "?"; 164 } 165 } 166 167 public String getDefinition() { 168 switch (this) { 169 case DRAFT: 170 return "The request has been created but is not yet complete or ready for action."; 171 case ACTIVE: 172 return "The request is in force and ready to be acted upon."; 173 case ONHOLD: 174 return "The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future."; 175 case REVOKED: 176 return "The request (and any implicit authorization to act) has been terminated prior to the known full completion of the intended actions. No further activity should occur."; 177 case COMPLETED: 178 return "The activity described by the request has been fully performed. No further activity will occur."; 179 case ENTEREDINERROR: 180 return "This request should never have existed and should be considered 'void'. (It is possible that real-world decisions were based on it. If real-world activity has occurred, the status should be \"revoked\" rather than \"entered-in-error\".)."; 181 case UNKNOWN: 182 return "The authoring/source system does not know which of the status values currently applies for this request. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which."; 183 case NULL: 184 return null; 185 default: 186 return "?"; 187 } 188 } 189 190 public String getDisplay() { 191 switch (this) { 192 case DRAFT: 193 return "Draft"; 194 case ACTIVE: 195 return "Active"; 196 case ONHOLD: 197 return "On Hold"; 198 case REVOKED: 199 return "Revoked"; 200 case COMPLETED: 201 return "Completed"; 202 case ENTEREDINERROR: 203 return "Entered in Error"; 204 case UNKNOWN: 205 return "Unknown"; 206 case NULL: 207 return null; 208 default: 209 return "?"; 210 } 211 } 212 } 213 214 public static class RequestStatusEnumFactory implements EnumFactory<RequestStatus> { 215 public RequestStatus fromCode(String codeString) throws IllegalArgumentException { 216 if (codeString == null || "".equals(codeString)) 217 if (codeString == null || "".equals(codeString)) 218 return null; 219 if ("draft".equals(codeString)) 220 return RequestStatus.DRAFT; 221 if ("active".equals(codeString)) 222 return RequestStatus.ACTIVE; 223 if ("on-hold".equals(codeString)) 224 return RequestStatus.ONHOLD; 225 if ("revoked".equals(codeString)) 226 return RequestStatus.REVOKED; 227 if ("completed".equals(codeString)) 228 return RequestStatus.COMPLETED; 229 if ("entered-in-error".equals(codeString)) 230 return RequestStatus.ENTEREDINERROR; 231 if ("unknown".equals(codeString)) 232 return RequestStatus.UNKNOWN; 233 throw new IllegalArgumentException("Unknown RequestStatus code '" + codeString + "'"); 234 } 235 236 public Enumeration<RequestStatus> fromType(PrimitiveType<?> code) throws FHIRException { 237 if (code == null) 238 return null; 239 if (code.isEmpty()) 240 return new Enumeration<RequestStatus>(this, RequestStatus.NULL, code); 241 String codeString = code.asStringValue(); 242 if (codeString == null || "".equals(codeString)) 243 return new Enumeration<RequestStatus>(this, RequestStatus.NULL, code); 244 if ("draft".equals(codeString)) 245 return new Enumeration<RequestStatus>(this, RequestStatus.DRAFT, code); 246 if ("active".equals(codeString)) 247 return new Enumeration<RequestStatus>(this, RequestStatus.ACTIVE, code); 248 if ("on-hold".equals(codeString)) 249 return new Enumeration<RequestStatus>(this, RequestStatus.ONHOLD, code); 250 if ("revoked".equals(codeString)) 251 return new Enumeration<RequestStatus>(this, RequestStatus.REVOKED, code); 252 if ("completed".equals(codeString)) 253 return new Enumeration<RequestStatus>(this, RequestStatus.COMPLETED, code); 254 if ("entered-in-error".equals(codeString)) 255 return new Enumeration<RequestStatus>(this, RequestStatus.ENTEREDINERROR, code); 256 if ("unknown".equals(codeString)) 257 return new Enumeration<RequestStatus>(this, RequestStatus.UNKNOWN, code); 258 throw new FHIRException("Unknown RequestStatus code '" + codeString + "'"); 259 } 260 261 public String toCode(RequestStatus code) { 262 if (code == RequestStatus.DRAFT) 263 return "draft"; 264 if (code == RequestStatus.ACTIVE) 265 return "active"; 266 if (code == RequestStatus.ONHOLD) 267 return "on-hold"; 268 if (code == RequestStatus.REVOKED) 269 return "revoked"; 270 if (code == RequestStatus.COMPLETED) 271 return "completed"; 272 if (code == RequestStatus.ENTEREDINERROR) 273 return "entered-in-error"; 274 if (code == RequestStatus.UNKNOWN) 275 return "unknown"; 276 return "?"; 277 } 278 279 public String toSystem(RequestStatus code) { 280 return code.getSystem(); 281 } 282 } 283 284 public enum RequestIntent { 285 /** 286 * The request is a suggestion made by someone/something that does not have an 287 * intention to ensure it occurs and without providing an authorization to act. 288 */ 289 PROPOSAL, 290 /** 291 * The request represents an intention to ensure something occurs without 292 * providing an authorization for others to act. 293 */ 294 PLAN, 295 /** 296 * The request represents a legally binding instruction authored by a Patient or 297 * RelatedPerson. 298 */ 299 DIRECTIVE, 300 /** 301 * The request represents a request/demand and authorization for action by a 302 * Practitioner. 303 */ 304 ORDER, 305 /** 306 * The request represents an original authorization for action. 307 */ 308 ORIGINALORDER, 309 /** 310 * The request represents an automatically generated supplemental authorization 311 * for action based on a parent authorization together with initial results of 312 * the action taken against that parent authorization. 313 */ 314 REFLEXORDER, 315 /** 316 * The request represents the view of an authorization instantiated by a 317 * fulfilling system representing the details of the fulfiller's intention to 318 * act upon a submitted order. 319 */ 320 FILLERORDER, 321 /** 322 * An order created in fulfillment of a broader order that represents the 323 * authorization for a single activity occurrence. E.g. The administration of a 324 * single dose of a drug. 325 */ 326 INSTANCEORDER, 327 /** 328 * The request represents a component or option for a RequestGroup that 329 * establishes timing, conditionality and/or other constraints among a set of 330 * requests. Refer to [[[RequestGroup]]] for additional information on how this 331 * status is used. 332 */ 333 OPTION, 334 /** 335 * added to help the parsers with the generic types 336 */ 337 NULL; 338 339 public static RequestIntent fromCode(String codeString) throws FHIRException { 340 if (codeString == null || "".equals(codeString)) 341 return null; 342 if ("proposal".equals(codeString)) 343 return PROPOSAL; 344 if ("plan".equals(codeString)) 345 return PLAN; 346 if ("directive".equals(codeString)) 347 return DIRECTIVE; 348 if ("order".equals(codeString)) 349 return ORDER; 350 if ("original-order".equals(codeString)) 351 return ORIGINALORDER; 352 if ("reflex-order".equals(codeString)) 353 return REFLEXORDER; 354 if ("filler-order".equals(codeString)) 355 return FILLERORDER; 356 if ("instance-order".equals(codeString)) 357 return INSTANCEORDER; 358 if ("option".equals(codeString)) 359 return OPTION; 360 if (Configuration.isAcceptInvalidEnums()) 361 return null; 362 else 363 throw new FHIRException("Unknown RequestIntent code '" + codeString + "'"); 364 } 365 366 public String toCode() { 367 switch (this) { 368 case PROPOSAL: 369 return "proposal"; 370 case PLAN: 371 return "plan"; 372 case DIRECTIVE: 373 return "directive"; 374 case ORDER: 375 return "order"; 376 case ORIGINALORDER: 377 return "original-order"; 378 case REFLEXORDER: 379 return "reflex-order"; 380 case FILLERORDER: 381 return "filler-order"; 382 case INSTANCEORDER: 383 return "instance-order"; 384 case OPTION: 385 return "option"; 386 case NULL: 387 return null; 388 default: 389 return "?"; 390 } 391 } 392 393 public String getSystem() { 394 switch (this) { 395 case PROPOSAL: 396 return "http://hl7.org/fhir/request-intent"; 397 case PLAN: 398 return "http://hl7.org/fhir/request-intent"; 399 case DIRECTIVE: 400 return "http://hl7.org/fhir/request-intent"; 401 case ORDER: 402 return "http://hl7.org/fhir/request-intent"; 403 case ORIGINALORDER: 404 return "http://hl7.org/fhir/request-intent"; 405 case REFLEXORDER: 406 return "http://hl7.org/fhir/request-intent"; 407 case FILLERORDER: 408 return "http://hl7.org/fhir/request-intent"; 409 case INSTANCEORDER: 410 return "http://hl7.org/fhir/request-intent"; 411 case OPTION: 412 return "http://hl7.org/fhir/request-intent"; 413 case NULL: 414 return null; 415 default: 416 return "?"; 417 } 418 } 419 420 public String getDefinition() { 421 switch (this) { 422 case PROPOSAL: 423 return "The request is a suggestion made by someone/something that does not have an intention to ensure it occurs and without providing an authorization to act."; 424 case PLAN: 425 return "The request represents an intention to ensure something occurs without providing an authorization for others to act."; 426 case DIRECTIVE: 427 return "The request represents a legally binding instruction authored by a Patient or RelatedPerson."; 428 case ORDER: 429 return "The request represents a request/demand and authorization for action by a Practitioner."; 430 case ORIGINALORDER: 431 return "The request represents an original authorization for action."; 432 case REFLEXORDER: 433 return "The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization."; 434 case FILLERORDER: 435 return "The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order."; 436 case INSTANCEORDER: 437 return "An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence. E.g. The administration of a single dose of a drug."; 438 case OPTION: 439 return "The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests. Refer to [[[RequestGroup]]] for additional information on how this status is used."; 440 case NULL: 441 return null; 442 default: 443 return "?"; 444 } 445 } 446 447 public String getDisplay() { 448 switch (this) { 449 case PROPOSAL: 450 return "Proposal"; 451 case PLAN: 452 return "Plan"; 453 case DIRECTIVE: 454 return "Directive"; 455 case ORDER: 456 return "Order"; 457 case ORIGINALORDER: 458 return "Original Order"; 459 case REFLEXORDER: 460 return "Reflex Order"; 461 case FILLERORDER: 462 return "Filler Order"; 463 case INSTANCEORDER: 464 return "Instance Order"; 465 case OPTION: 466 return "Option"; 467 case NULL: 468 return null; 469 default: 470 return "?"; 471 } 472 } 473 } 474 475 public static class RequestIntentEnumFactory implements EnumFactory<RequestIntent> { 476 public RequestIntent fromCode(String codeString) throws IllegalArgumentException { 477 if (codeString == null || "".equals(codeString)) 478 if (codeString == null || "".equals(codeString)) 479 return null; 480 if ("proposal".equals(codeString)) 481 return RequestIntent.PROPOSAL; 482 if ("plan".equals(codeString)) 483 return RequestIntent.PLAN; 484 if ("directive".equals(codeString)) 485 return RequestIntent.DIRECTIVE; 486 if ("order".equals(codeString)) 487 return RequestIntent.ORDER; 488 if ("original-order".equals(codeString)) 489 return RequestIntent.ORIGINALORDER; 490 if ("reflex-order".equals(codeString)) 491 return RequestIntent.REFLEXORDER; 492 if ("filler-order".equals(codeString)) 493 return RequestIntent.FILLERORDER; 494 if ("instance-order".equals(codeString)) 495 return RequestIntent.INSTANCEORDER; 496 if ("option".equals(codeString)) 497 return RequestIntent.OPTION; 498 throw new IllegalArgumentException("Unknown RequestIntent code '" + codeString + "'"); 499 } 500 501 public Enumeration<RequestIntent> fromType(PrimitiveType<?> code) throws FHIRException { 502 if (code == null) 503 return null; 504 if (code.isEmpty()) 505 return new Enumeration<RequestIntent>(this, RequestIntent.NULL, code); 506 String codeString = code.asStringValue(); 507 if (codeString == null || "".equals(codeString)) 508 return new Enumeration<RequestIntent>(this, RequestIntent.NULL, code); 509 if ("proposal".equals(codeString)) 510 return new Enumeration<RequestIntent>(this, RequestIntent.PROPOSAL, code); 511 if ("plan".equals(codeString)) 512 return new Enumeration<RequestIntent>(this, RequestIntent.PLAN, code); 513 if ("directive".equals(codeString)) 514 return new Enumeration<RequestIntent>(this, RequestIntent.DIRECTIVE, code); 515 if ("order".equals(codeString)) 516 return new Enumeration<RequestIntent>(this, RequestIntent.ORDER, code); 517 if ("original-order".equals(codeString)) 518 return new Enumeration<RequestIntent>(this, RequestIntent.ORIGINALORDER, code); 519 if ("reflex-order".equals(codeString)) 520 return new Enumeration<RequestIntent>(this, RequestIntent.REFLEXORDER, code); 521 if ("filler-order".equals(codeString)) 522 return new Enumeration<RequestIntent>(this, RequestIntent.FILLERORDER, code); 523 if ("instance-order".equals(codeString)) 524 return new Enumeration<RequestIntent>(this, RequestIntent.INSTANCEORDER, code); 525 if ("option".equals(codeString)) 526 return new Enumeration<RequestIntent>(this, RequestIntent.OPTION, code); 527 throw new FHIRException("Unknown RequestIntent code '" + codeString + "'"); 528 } 529 530 public String toCode(RequestIntent code) { 531 if (code == RequestIntent.PROPOSAL) 532 return "proposal"; 533 if (code == RequestIntent.PLAN) 534 return "plan"; 535 if (code == RequestIntent.DIRECTIVE) 536 return "directive"; 537 if (code == RequestIntent.ORDER) 538 return "order"; 539 if (code == RequestIntent.ORIGINALORDER) 540 return "original-order"; 541 if (code == RequestIntent.REFLEXORDER) 542 return "reflex-order"; 543 if (code == RequestIntent.FILLERORDER) 544 return "filler-order"; 545 if (code == RequestIntent.INSTANCEORDER) 546 return "instance-order"; 547 if (code == RequestIntent.OPTION) 548 return "option"; 549 return "?"; 550 } 551 552 public String toSystem(RequestIntent code) { 553 return code.getSystem(); 554 } 555 } 556 557 public enum RequestPriority { 558 /** 559 * The request has normal priority. 560 */ 561 ROUTINE, 562 /** 563 * The request should be actioned promptly - higher priority than routine. 564 */ 565 URGENT, 566 /** 567 * The request should be actioned as soon as possible - higher priority than 568 * urgent. 569 */ 570 ASAP, 571 /** 572 * The request should be actioned immediately - highest possible priority. E.g. 573 * an emergency. 574 */ 575 STAT, 576 /** 577 * added to help the parsers with the generic types 578 */ 579 NULL; 580 581 public static RequestPriority fromCode(String codeString) throws FHIRException { 582 if (codeString == null || "".equals(codeString)) 583 return null; 584 if ("routine".equals(codeString)) 585 return ROUTINE; 586 if ("urgent".equals(codeString)) 587 return URGENT; 588 if ("asap".equals(codeString)) 589 return ASAP; 590 if ("stat".equals(codeString)) 591 return STAT; 592 if (Configuration.isAcceptInvalidEnums()) 593 return null; 594 else 595 throw new FHIRException("Unknown RequestPriority code '" + codeString + "'"); 596 } 597 598 public String toCode() { 599 switch (this) { 600 case ROUTINE: 601 return "routine"; 602 case URGENT: 603 return "urgent"; 604 case ASAP: 605 return "asap"; 606 case STAT: 607 return "stat"; 608 case NULL: 609 return null; 610 default: 611 return "?"; 612 } 613 } 614 615 public String getSystem() { 616 switch (this) { 617 case ROUTINE: 618 return "http://hl7.org/fhir/request-priority"; 619 case URGENT: 620 return "http://hl7.org/fhir/request-priority"; 621 case ASAP: 622 return "http://hl7.org/fhir/request-priority"; 623 case STAT: 624 return "http://hl7.org/fhir/request-priority"; 625 case NULL: 626 return null; 627 default: 628 return "?"; 629 } 630 } 631 632 public String getDefinition() { 633 switch (this) { 634 case ROUTINE: 635 return "The request has normal priority."; 636 case URGENT: 637 return "The request should be actioned promptly - higher priority than routine."; 638 case ASAP: 639 return "The request should be actioned as soon as possible - higher priority than urgent."; 640 case STAT: 641 return "The request should be actioned immediately - highest possible priority. E.g. an emergency."; 642 case NULL: 643 return null; 644 default: 645 return "?"; 646 } 647 } 648 649 public String getDisplay() { 650 switch (this) { 651 case ROUTINE: 652 return "Routine"; 653 case URGENT: 654 return "Urgent"; 655 case ASAP: 656 return "ASAP"; 657 case STAT: 658 return "STAT"; 659 case NULL: 660 return null; 661 default: 662 return "?"; 663 } 664 } 665 } 666 667 public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> { 668 public RequestPriority fromCode(String codeString) throws IllegalArgumentException { 669 if (codeString == null || "".equals(codeString)) 670 if (codeString == null || "".equals(codeString)) 671 return null; 672 if ("routine".equals(codeString)) 673 return RequestPriority.ROUTINE; 674 if ("urgent".equals(codeString)) 675 return RequestPriority.URGENT; 676 if ("asap".equals(codeString)) 677 return RequestPriority.ASAP; 678 if ("stat".equals(codeString)) 679 return RequestPriority.STAT; 680 throw new IllegalArgumentException("Unknown RequestPriority code '" + codeString + "'"); 681 } 682 683 public Enumeration<RequestPriority> fromType(PrimitiveType<?> code) throws FHIRException { 684 if (code == null) 685 return null; 686 if (code.isEmpty()) 687 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 688 String codeString = code.asStringValue(); 689 if (codeString == null || "".equals(codeString)) 690 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 691 if ("routine".equals(codeString)) 692 return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE, code); 693 if ("urgent".equals(codeString)) 694 return new Enumeration<RequestPriority>(this, RequestPriority.URGENT, code); 695 if ("asap".equals(codeString)) 696 return new Enumeration<RequestPriority>(this, RequestPriority.ASAP, code); 697 if ("stat".equals(codeString)) 698 return new Enumeration<RequestPriority>(this, RequestPriority.STAT, code); 699 throw new FHIRException("Unknown RequestPriority code '" + codeString + "'"); 700 } 701 702 public String toCode(RequestPriority code) { 703 if (code == RequestPriority.ROUTINE) 704 return "routine"; 705 if (code == RequestPriority.URGENT) 706 return "urgent"; 707 if (code == RequestPriority.ASAP) 708 return "asap"; 709 if (code == RequestPriority.STAT) 710 return "stat"; 711 return "?"; 712 } 713 714 public String toSystem(RequestPriority code) { 715 return code.getSystem(); 716 } 717 } 718 719 public enum ActionConditionKind { 720 /** 721 * The condition describes whether or not a given action is applicable. 722 */ 723 APPLICABILITY, 724 /** 725 * The condition is a starting condition for the action. 726 */ 727 START, 728 /** 729 * The condition is a stop, or exit condition for the action. 730 */ 731 STOP, 732 /** 733 * added to help the parsers with the generic types 734 */ 735 NULL; 736 737 public static ActionConditionKind fromCode(String codeString) throws FHIRException { 738 if (codeString == null || "".equals(codeString)) 739 return null; 740 if ("applicability".equals(codeString)) 741 return APPLICABILITY; 742 if ("start".equals(codeString)) 743 return START; 744 if ("stop".equals(codeString)) 745 return STOP; 746 if (Configuration.isAcceptInvalidEnums()) 747 return null; 748 else 749 throw new FHIRException("Unknown ActionConditionKind code '" + codeString + "'"); 750 } 751 752 public String toCode() { 753 switch (this) { 754 case APPLICABILITY: 755 return "applicability"; 756 case START: 757 return "start"; 758 case STOP: 759 return "stop"; 760 case NULL: 761 return null; 762 default: 763 return "?"; 764 } 765 } 766 767 public String getSystem() { 768 switch (this) { 769 case APPLICABILITY: 770 return "http://hl7.org/fhir/action-condition-kind"; 771 case START: 772 return "http://hl7.org/fhir/action-condition-kind"; 773 case STOP: 774 return "http://hl7.org/fhir/action-condition-kind"; 775 case NULL: 776 return null; 777 default: 778 return "?"; 779 } 780 } 781 782 public String getDefinition() { 783 switch (this) { 784 case APPLICABILITY: 785 return "The condition describes whether or not a given action is applicable."; 786 case START: 787 return "The condition is a starting condition for the action."; 788 case STOP: 789 return "The condition is a stop, or exit condition for the action."; 790 case NULL: 791 return null; 792 default: 793 return "?"; 794 } 795 } 796 797 public String getDisplay() { 798 switch (this) { 799 case APPLICABILITY: 800 return "Applicability"; 801 case START: 802 return "Start"; 803 case STOP: 804 return "Stop"; 805 case NULL: 806 return null; 807 default: 808 return "?"; 809 } 810 } 811 } 812 813 public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> { 814 public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException { 815 if (codeString == null || "".equals(codeString)) 816 if (codeString == null || "".equals(codeString)) 817 return null; 818 if ("applicability".equals(codeString)) 819 return ActionConditionKind.APPLICABILITY; 820 if ("start".equals(codeString)) 821 return ActionConditionKind.START; 822 if ("stop".equals(codeString)) 823 return ActionConditionKind.STOP; 824 throw new IllegalArgumentException("Unknown ActionConditionKind code '" + codeString + "'"); 825 } 826 827 public Enumeration<ActionConditionKind> fromType(PrimitiveType<?> code) throws FHIRException { 828 if (code == null) 829 return null; 830 if (code.isEmpty()) 831 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 832 String codeString = code.asStringValue(); 833 if (codeString == null || "".equals(codeString)) 834 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 835 if ("applicability".equals(codeString)) 836 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY, code); 837 if ("start".equals(codeString)) 838 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START, code); 839 if ("stop".equals(codeString)) 840 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP, code); 841 throw new FHIRException("Unknown ActionConditionKind code '" + codeString + "'"); 842 } 843 844 public String toCode(ActionConditionKind code) { 845 if (code == ActionConditionKind.APPLICABILITY) 846 return "applicability"; 847 if (code == ActionConditionKind.START) 848 return "start"; 849 if (code == ActionConditionKind.STOP) 850 return "stop"; 851 return "?"; 852 } 853 854 public String toSystem(ActionConditionKind code) { 855 return code.getSystem(); 856 } 857 } 858 859 public enum ActionRelationshipType { 860 /** 861 * The action must be performed before the start of the related action. 862 */ 863 BEFORESTART, 864 /** 865 * The action must be performed before the related action. 866 */ 867 BEFORE, 868 /** 869 * The action must be performed before the end of the related action. 870 */ 871 BEFOREEND, 872 /** 873 * The action must be performed concurrent with the start of the related action. 874 */ 875 CONCURRENTWITHSTART, 876 /** 877 * The action must be performed concurrent with the related action. 878 */ 879 CONCURRENT, 880 /** 881 * The action must be performed concurrent with the end of the related action. 882 */ 883 CONCURRENTWITHEND, 884 /** 885 * The action must be performed after the start of the related action. 886 */ 887 AFTERSTART, 888 /** 889 * The action must be performed after the related action. 890 */ 891 AFTER, 892 /** 893 * The action must be performed after the end of the related action. 894 */ 895 AFTEREND, 896 /** 897 * added to help the parsers with the generic types 898 */ 899 NULL; 900 901 public static ActionRelationshipType fromCode(String codeString) throws FHIRException { 902 if (codeString == null || "".equals(codeString)) 903 return null; 904 if ("before-start".equals(codeString)) 905 return BEFORESTART; 906 if ("before".equals(codeString)) 907 return BEFORE; 908 if ("before-end".equals(codeString)) 909 return BEFOREEND; 910 if ("concurrent-with-start".equals(codeString)) 911 return CONCURRENTWITHSTART; 912 if ("concurrent".equals(codeString)) 913 return CONCURRENT; 914 if ("concurrent-with-end".equals(codeString)) 915 return CONCURRENTWITHEND; 916 if ("after-start".equals(codeString)) 917 return AFTERSTART; 918 if ("after".equals(codeString)) 919 return AFTER; 920 if ("after-end".equals(codeString)) 921 return AFTEREND; 922 if (Configuration.isAcceptInvalidEnums()) 923 return null; 924 else 925 throw new FHIRException("Unknown ActionRelationshipType code '" + codeString + "'"); 926 } 927 928 public String toCode() { 929 switch (this) { 930 case BEFORESTART: 931 return "before-start"; 932 case BEFORE: 933 return "before"; 934 case BEFOREEND: 935 return "before-end"; 936 case CONCURRENTWITHSTART: 937 return "concurrent-with-start"; 938 case CONCURRENT: 939 return "concurrent"; 940 case CONCURRENTWITHEND: 941 return "concurrent-with-end"; 942 case AFTERSTART: 943 return "after-start"; 944 case AFTER: 945 return "after"; 946 case AFTEREND: 947 return "after-end"; 948 case NULL: 949 return null; 950 default: 951 return "?"; 952 } 953 } 954 955 public String getSystem() { 956 switch (this) { 957 case BEFORESTART: 958 return "http://hl7.org/fhir/action-relationship-type"; 959 case BEFORE: 960 return "http://hl7.org/fhir/action-relationship-type"; 961 case BEFOREEND: 962 return "http://hl7.org/fhir/action-relationship-type"; 963 case CONCURRENTWITHSTART: 964 return "http://hl7.org/fhir/action-relationship-type"; 965 case CONCURRENT: 966 return "http://hl7.org/fhir/action-relationship-type"; 967 case CONCURRENTWITHEND: 968 return "http://hl7.org/fhir/action-relationship-type"; 969 case AFTERSTART: 970 return "http://hl7.org/fhir/action-relationship-type"; 971 case AFTER: 972 return "http://hl7.org/fhir/action-relationship-type"; 973 case AFTEREND: 974 return "http://hl7.org/fhir/action-relationship-type"; 975 case NULL: 976 return null; 977 default: 978 return "?"; 979 } 980 } 981 982 public String getDefinition() { 983 switch (this) { 984 case BEFORESTART: 985 return "The action must be performed before the start of the related action."; 986 case BEFORE: 987 return "The action must be performed before the related action."; 988 case BEFOREEND: 989 return "The action must be performed before the end of the related action."; 990 case CONCURRENTWITHSTART: 991 return "The action must be performed concurrent with the start of the related action."; 992 case CONCURRENT: 993 return "The action must be performed concurrent with the related action."; 994 case CONCURRENTWITHEND: 995 return "The action must be performed concurrent with the end of the related action."; 996 case AFTERSTART: 997 return "The action must be performed after the start of the related action."; 998 case AFTER: 999 return "The action must be performed after the related action."; 1000 case AFTEREND: 1001 return "The action must be performed after the end of the related action."; 1002 case NULL: 1003 return null; 1004 default: 1005 return "?"; 1006 } 1007 } 1008 1009 public String getDisplay() { 1010 switch (this) { 1011 case BEFORESTART: 1012 return "Before Start"; 1013 case BEFORE: 1014 return "Before"; 1015 case BEFOREEND: 1016 return "Before End"; 1017 case CONCURRENTWITHSTART: 1018 return "Concurrent With Start"; 1019 case CONCURRENT: 1020 return "Concurrent"; 1021 case CONCURRENTWITHEND: 1022 return "Concurrent With End"; 1023 case AFTERSTART: 1024 return "After Start"; 1025 case AFTER: 1026 return "After"; 1027 case AFTEREND: 1028 return "After End"; 1029 case NULL: 1030 return null; 1031 default: 1032 return "?"; 1033 } 1034 } 1035 } 1036 1037 public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> { 1038 public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException { 1039 if (codeString == null || "".equals(codeString)) 1040 if (codeString == null || "".equals(codeString)) 1041 return null; 1042 if ("before-start".equals(codeString)) 1043 return ActionRelationshipType.BEFORESTART; 1044 if ("before".equals(codeString)) 1045 return ActionRelationshipType.BEFORE; 1046 if ("before-end".equals(codeString)) 1047 return ActionRelationshipType.BEFOREEND; 1048 if ("concurrent-with-start".equals(codeString)) 1049 return ActionRelationshipType.CONCURRENTWITHSTART; 1050 if ("concurrent".equals(codeString)) 1051 return ActionRelationshipType.CONCURRENT; 1052 if ("concurrent-with-end".equals(codeString)) 1053 return ActionRelationshipType.CONCURRENTWITHEND; 1054 if ("after-start".equals(codeString)) 1055 return ActionRelationshipType.AFTERSTART; 1056 if ("after".equals(codeString)) 1057 return ActionRelationshipType.AFTER; 1058 if ("after-end".equals(codeString)) 1059 return ActionRelationshipType.AFTEREND; 1060 throw new IllegalArgumentException("Unknown ActionRelationshipType code '" + codeString + "'"); 1061 } 1062 1063 public Enumeration<ActionRelationshipType> fromType(PrimitiveType<?> code) throws FHIRException { 1064 if (code == null) 1065 return null; 1066 if (code.isEmpty()) 1067 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 1068 String codeString = code.asStringValue(); 1069 if (codeString == null || "".equals(codeString)) 1070 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 1071 if ("before-start".equals(codeString)) 1072 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART, code); 1073 if ("before".equals(codeString)) 1074 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE, code); 1075 if ("before-end".equals(codeString)) 1076 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND, code); 1077 if ("concurrent-with-start".equals(codeString)) 1078 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART, code); 1079 if ("concurrent".equals(codeString)) 1080 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT, code); 1081 if ("concurrent-with-end".equals(codeString)) 1082 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND, code); 1083 if ("after-start".equals(codeString)) 1084 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART, code); 1085 if ("after".equals(codeString)) 1086 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER, code); 1087 if ("after-end".equals(codeString)) 1088 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND, code); 1089 throw new FHIRException("Unknown ActionRelationshipType code '" + codeString + "'"); 1090 } 1091 1092 public String toCode(ActionRelationshipType code) { 1093 if (code == ActionRelationshipType.BEFORESTART) 1094 return "before-start"; 1095 if (code == ActionRelationshipType.BEFORE) 1096 return "before"; 1097 if (code == ActionRelationshipType.BEFOREEND) 1098 return "before-end"; 1099 if (code == ActionRelationshipType.CONCURRENTWITHSTART) 1100 return "concurrent-with-start"; 1101 if (code == ActionRelationshipType.CONCURRENT) 1102 return "concurrent"; 1103 if (code == ActionRelationshipType.CONCURRENTWITHEND) 1104 return "concurrent-with-end"; 1105 if (code == ActionRelationshipType.AFTERSTART) 1106 return "after-start"; 1107 if (code == ActionRelationshipType.AFTER) 1108 return "after"; 1109 if (code == ActionRelationshipType.AFTEREND) 1110 return "after-end"; 1111 return "?"; 1112 } 1113 1114 public String toSystem(ActionRelationshipType code) { 1115 return code.getSystem(); 1116 } 1117 } 1118 1119 public enum ActionGroupingBehavior { 1120 /** 1121 * Any group marked with this behavior should be displayed as a visual group to 1122 * the end user. 1123 */ 1124 VISUALGROUP, 1125 /** 1126 * A group with this behavior logically groups its sub-elements, and may be 1127 * shown as a visual group to the end user, but it is not required to do so. 1128 */ 1129 LOGICALGROUP, 1130 /** 1131 * A group of related alternative actions is a sentence group if the target 1132 * referenced by the action is the same in all the actions and each action 1133 * simply constitutes a different variation on how to specify the details for 1134 * the target. For example, two actions that could be in a SentenceGroup are 1135 * "aspirin, 500 mg, 2 times per day" and "aspirin, 300 mg, 3 times per day". In 1136 * both cases, aspirin is the target referenced by the action, and the two 1137 * actions represent different options for how aspirin might be ordered for the 1138 * patient. Note that a SentenceGroup would almost always have an associated 1139 * selection behavior of "AtMostOne", unless it's a required action, in which 1140 * case, it would be "ExactlyOne". 1141 */ 1142 SENTENCEGROUP, 1143 /** 1144 * added to help the parsers with the generic types 1145 */ 1146 NULL; 1147 1148 public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException { 1149 if (codeString == null || "".equals(codeString)) 1150 return null; 1151 if ("visual-group".equals(codeString)) 1152 return VISUALGROUP; 1153 if ("logical-group".equals(codeString)) 1154 return LOGICALGROUP; 1155 if ("sentence-group".equals(codeString)) 1156 return SENTENCEGROUP; 1157 if (Configuration.isAcceptInvalidEnums()) 1158 return null; 1159 else 1160 throw new FHIRException("Unknown ActionGroupingBehavior code '" + codeString + "'"); 1161 } 1162 1163 public String toCode() { 1164 switch (this) { 1165 case VISUALGROUP: 1166 return "visual-group"; 1167 case LOGICALGROUP: 1168 return "logical-group"; 1169 case SENTENCEGROUP: 1170 return "sentence-group"; 1171 case NULL: 1172 return null; 1173 default: 1174 return "?"; 1175 } 1176 } 1177 1178 public String getSystem() { 1179 switch (this) { 1180 case VISUALGROUP: 1181 return "http://hl7.org/fhir/action-grouping-behavior"; 1182 case LOGICALGROUP: 1183 return "http://hl7.org/fhir/action-grouping-behavior"; 1184 case SENTENCEGROUP: 1185 return "http://hl7.org/fhir/action-grouping-behavior"; 1186 case NULL: 1187 return null; 1188 default: 1189 return "?"; 1190 } 1191 } 1192 1193 public String getDefinition() { 1194 switch (this) { 1195 case VISUALGROUP: 1196 return "Any group marked with this behavior should be displayed as a visual group to the end user."; 1197 case LOGICALGROUP: 1198 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."; 1199 case SENTENCEGROUP: 1200 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\"."; 1201 case NULL: 1202 return null; 1203 default: 1204 return "?"; 1205 } 1206 } 1207 1208 public String getDisplay() { 1209 switch (this) { 1210 case VISUALGROUP: 1211 return "Visual Group"; 1212 case LOGICALGROUP: 1213 return "Logical Group"; 1214 case SENTENCEGROUP: 1215 return "Sentence Group"; 1216 case NULL: 1217 return null; 1218 default: 1219 return "?"; 1220 } 1221 } 1222 } 1223 1224 public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> { 1225 public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException { 1226 if (codeString == null || "".equals(codeString)) 1227 if (codeString == null || "".equals(codeString)) 1228 return null; 1229 if ("visual-group".equals(codeString)) 1230 return ActionGroupingBehavior.VISUALGROUP; 1231 if ("logical-group".equals(codeString)) 1232 return ActionGroupingBehavior.LOGICALGROUP; 1233 if ("sentence-group".equals(codeString)) 1234 return ActionGroupingBehavior.SENTENCEGROUP; 1235 throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '" + codeString + "'"); 1236 } 1237 1238 public Enumeration<ActionGroupingBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1239 if (code == null) 1240 return null; 1241 if (code.isEmpty()) 1242 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 1243 String codeString = code.asStringValue(); 1244 if (codeString == null || "".equals(codeString)) 1245 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 1246 if ("visual-group".equals(codeString)) 1247 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP, code); 1248 if ("logical-group".equals(codeString)) 1249 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP, code); 1250 if ("sentence-group".equals(codeString)) 1251 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP, code); 1252 throw new FHIRException("Unknown ActionGroupingBehavior code '" + codeString + "'"); 1253 } 1254 1255 public String toCode(ActionGroupingBehavior code) { 1256 if (code == ActionGroupingBehavior.VISUALGROUP) 1257 return "visual-group"; 1258 if (code == ActionGroupingBehavior.LOGICALGROUP) 1259 return "logical-group"; 1260 if (code == ActionGroupingBehavior.SENTENCEGROUP) 1261 return "sentence-group"; 1262 return "?"; 1263 } 1264 1265 public String toSystem(ActionGroupingBehavior code) { 1266 return code.getSystem(); 1267 } 1268 } 1269 1270 public enum ActionSelectionBehavior { 1271 /** 1272 * Any number of the actions in the group may be chosen, from zero to all. 1273 */ 1274 ANY, 1275 /** 1276 * All the actions in the group must be selected as a single unit. 1277 */ 1278 ALL, 1279 /** 1280 * All the actions in the group are meant to be chosen as a single unit: either 1281 * all must be selected by the end user, or none may be selected. 1282 */ 1283 ALLORNONE, 1284 /** 1285 * The end user must choose one and only one of the selectable actions in the 1286 * group. The user SHALL NOT choose none of the actions in the group. 1287 */ 1288 EXACTLYONE, 1289 /** 1290 * The end user may choose zero or at most one of the actions in the group. 1291 */ 1292 ATMOSTONE, 1293 /** 1294 * The end user must choose a minimum of one, and as many additional as desired. 1295 */ 1296 ONEORMORE, 1297 /** 1298 * added to help the parsers with the generic types 1299 */ 1300 NULL; 1301 1302 public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException { 1303 if (codeString == null || "".equals(codeString)) 1304 return null; 1305 if ("any".equals(codeString)) 1306 return ANY; 1307 if ("all".equals(codeString)) 1308 return ALL; 1309 if ("all-or-none".equals(codeString)) 1310 return ALLORNONE; 1311 if ("exactly-one".equals(codeString)) 1312 return EXACTLYONE; 1313 if ("at-most-one".equals(codeString)) 1314 return ATMOSTONE; 1315 if ("one-or-more".equals(codeString)) 1316 return ONEORMORE; 1317 if (Configuration.isAcceptInvalidEnums()) 1318 return null; 1319 else 1320 throw new FHIRException("Unknown ActionSelectionBehavior code '" + codeString + "'"); 1321 } 1322 1323 public String toCode() { 1324 switch (this) { 1325 case ANY: 1326 return "any"; 1327 case ALL: 1328 return "all"; 1329 case ALLORNONE: 1330 return "all-or-none"; 1331 case EXACTLYONE: 1332 return "exactly-one"; 1333 case ATMOSTONE: 1334 return "at-most-one"; 1335 case ONEORMORE: 1336 return "one-or-more"; 1337 case NULL: 1338 return null; 1339 default: 1340 return "?"; 1341 } 1342 } 1343 1344 public String getSystem() { 1345 switch (this) { 1346 case ANY: 1347 return "http://hl7.org/fhir/action-selection-behavior"; 1348 case ALL: 1349 return "http://hl7.org/fhir/action-selection-behavior"; 1350 case ALLORNONE: 1351 return "http://hl7.org/fhir/action-selection-behavior"; 1352 case EXACTLYONE: 1353 return "http://hl7.org/fhir/action-selection-behavior"; 1354 case ATMOSTONE: 1355 return "http://hl7.org/fhir/action-selection-behavior"; 1356 case ONEORMORE: 1357 return "http://hl7.org/fhir/action-selection-behavior"; 1358 case NULL: 1359 return null; 1360 default: 1361 return "?"; 1362 } 1363 } 1364 1365 public String getDefinition() { 1366 switch (this) { 1367 case ANY: 1368 return "Any number of the actions in the group may be chosen, from zero to all."; 1369 case ALL: 1370 return "All the actions in the group must be selected as a single unit."; 1371 case ALLORNONE: 1372 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."; 1373 case EXACTLYONE: 1374 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."; 1375 case ATMOSTONE: 1376 return "The end user may choose zero or at most one of the actions in the group."; 1377 case ONEORMORE: 1378 return "The end user must choose a minimum of one, and as many additional as desired."; 1379 case NULL: 1380 return null; 1381 default: 1382 return "?"; 1383 } 1384 } 1385 1386 public String getDisplay() { 1387 switch (this) { 1388 case ANY: 1389 return "Any"; 1390 case ALL: 1391 return "All"; 1392 case ALLORNONE: 1393 return "All Or None"; 1394 case EXACTLYONE: 1395 return "Exactly One"; 1396 case ATMOSTONE: 1397 return "At Most One"; 1398 case ONEORMORE: 1399 return "One Or More"; 1400 case NULL: 1401 return null; 1402 default: 1403 return "?"; 1404 } 1405 } 1406 } 1407 1408 public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> { 1409 public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException { 1410 if (codeString == null || "".equals(codeString)) 1411 if (codeString == null || "".equals(codeString)) 1412 return null; 1413 if ("any".equals(codeString)) 1414 return ActionSelectionBehavior.ANY; 1415 if ("all".equals(codeString)) 1416 return ActionSelectionBehavior.ALL; 1417 if ("all-or-none".equals(codeString)) 1418 return ActionSelectionBehavior.ALLORNONE; 1419 if ("exactly-one".equals(codeString)) 1420 return ActionSelectionBehavior.EXACTLYONE; 1421 if ("at-most-one".equals(codeString)) 1422 return ActionSelectionBehavior.ATMOSTONE; 1423 if ("one-or-more".equals(codeString)) 1424 return ActionSelectionBehavior.ONEORMORE; 1425 throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '" + codeString + "'"); 1426 } 1427 1428 public Enumeration<ActionSelectionBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1429 if (code == null) 1430 return null; 1431 if (code.isEmpty()) 1432 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1433 String codeString = code.asStringValue(); 1434 if (codeString == null || "".equals(codeString)) 1435 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1436 if ("any".equals(codeString)) 1437 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY, code); 1438 if ("all".equals(codeString)) 1439 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL, code); 1440 if ("all-or-none".equals(codeString)) 1441 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE, code); 1442 if ("exactly-one".equals(codeString)) 1443 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE, code); 1444 if ("at-most-one".equals(codeString)) 1445 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE, code); 1446 if ("one-or-more".equals(codeString)) 1447 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE, code); 1448 throw new FHIRException("Unknown ActionSelectionBehavior code '" + codeString + "'"); 1449 } 1450 1451 public String toCode(ActionSelectionBehavior code) { 1452 if (code == ActionSelectionBehavior.ANY) 1453 return "any"; 1454 if (code == ActionSelectionBehavior.ALL) 1455 return "all"; 1456 if (code == ActionSelectionBehavior.ALLORNONE) 1457 return "all-or-none"; 1458 if (code == ActionSelectionBehavior.EXACTLYONE) 1459 return "exactly-one"; 1460 if (code == ActionSelectionBehavior.ATMOSTONE) 1461 return "at-most-one"; 1462 if (code == ActionSelectionBehavior.ONEORMORE) 1463 return "one-or-more"; 1464 return "?"; 1465 } 1466 1467 public String toSystem(ActionSelectionBehavior code) { 1468 return code.getSystem(); 1469 } 1470 } 1471 1472 public enum ActionRequiredBehavior { 1473 /** 1474 * An action with this behavior must be included in the actions processed by the 1475 * end user; the end user SHALL NOT choose not to include this action. 1476 */ 1477 MUST, 1478 /** 1479 * An action with this behavior may be included in the set of actions processed 1480 * by the end user. 1481 */ 1482 COULD, 1483 /** 1484 * An action with this behavior must be included in the set of actions processed 1485 * by the end user, unless the end user provides documentation as to why the 1486 * action was not included. 1487 */ 1488 MUSTUNLESSDOCUMENTED, 1489 /** 1490 * added to help the parsers with the generic types 1491 */ 1492 NULL; 1493 1494 public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException { 1495 if (codeString == null || "".equals(codeString)) 1496 return null; 1497 if ("must".equals(codeString)) 1498 return MUST; 1499 if ("could".equals(codeString)) 1500 return COULD; 1501 if ("must-unless-documented".equals(codeString)) 1502 return MUSTUNLESSDOCUMENTED; 1503 if (Configuration.isAcceptInvalidEnums()) 1504 return null; 1505 else 1506 throw new FHIRException("Unknown ActionRequiredBehavior code '" + codeString + "'"); 1507 } 1508 1509 public String toCode() { 1510 switch (this) { 1511 case MUST: 1512 return "must"; 1513 case COULD: 1514 return "could"; 1515 case MUSTUNLESSDOCUMENTED: 1516 return "must-unless-documented"; 1517 case NULL: 1518 return null; 1519 default: 1520 return "?"; 1521 } 1522 } 1523 1524 public String getSystem() { 1525 switch (this) { 1526 case MUST: 1527 return "http://hl7.org/fhir/action-required-behavior"; 1528 case COULD: 1529 return "http://hl7.org/fhir/action-required-behavior"; 1530 case MUSTUNLESSDOCUMENTED: 1531 return "http://hl7.org/fhir/action-required-behavior"; 1532 case NULL: 1533 return null; 1534 default: 1535 return "?"; 1536 } 1537 } 1538 1539 public String getDefinition() { 1540 switch (this) { 1541 case MUST: 1542 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."; 1543 case COULD: 1544 return "An action with this behavior may be included in the set of actions processed by the end user."; 1545 case MUSTUNLESSDOCUMENTED: 1546 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."; 1547 case NULL: 1548 return null; 1549 default: 1550 return "?"; 1551 } 1552 } 1553 1554 public String getDisplay() { 1555 switch (this) { 1556 case MUST: 1557 return "Must"; 1558 case COULD: 1559 return "Could"; 1560 case MUSTUNLESSDOCUMENTED: 1561 return "Must Unless Documented"; 1562 case NULL: 1563 return null; 1564 default: 1565 return "?"; 1566 } 1567 } 1568 } 1569 1570 public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> { 1571 public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException { 1572 if (codeString == null || "".equals(codeString)) 1573 if (codeString == null || "".equals(codeString)) 1574 return null; 1575 if ("must".equals(codeString)) 1576 return ActionRequiredBehavior.MUST; 1577 if ("could".equals(codeString)) 1578 return ActionRequiredBehavior.COULD; 1579 if ("must-unless-documented".equals(codeString)) 1580 return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED; 1581 throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '" + codeString + "'"); 1582 } 1583 1584 public Enumeration<ActionRequiredBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1585 if (code == null) 1586 return null; 1587 if (code.isEmpty()) 1588 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1589 String codeString = code.asStringValue(); 1590 if (codeString == null || "".equals(codeString)) 1591 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1592 if ("must".equals(codeString)) 1593 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST, code); 1594 if ("could".equals(codeString)) 1595 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD, code); 1596 if ("must-unless-documented".equals(codeString)) 1597 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED, code); 1598 throw new FHIRException("Unknown ActionRequiredBehavior code '" + codeString + "'"); 1599 } 1600 1601 public String toCode(ActionRequiredBehavior code) { 1602 if (code == ActionRequiredBehavior.MUST) 1603 return "must"; 1604 if (code == ActionRequiredBehavior.COULD) 1605 return "could"; 1606 if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED) 1607 return "must-unless-documented"; 1608 return "?"; 1609 } 1610 1611 public String toSystem(ActionRequiredBehavior code) { 1612 return code.getSystem(); 1613 } 1614 } 1615 1616 public enum ActionPrecheckBehavior { 1617 /** 1618 * An action with this behavior is one of the most frequent action that is, or 1619 * should be, included by an end user, for the particular context in which the 1620 * action occurs. The system displaying the action to the end user should 1621 * consider "pre-checking" such an action as a convenience for the user. 1622 */ 1623 YES, 1624 /** 1625 * An action with this behavior is one of the less frequent actions included by 1626 * the end user, for the particular context in which the action occurs. The 1627 * system displaying the actions to the end user would typically not "pre-check" 1628 * such an action. 1629 */ 1630 NO, 1631 /** 1632 * added to help the parsers with the generic types 1633 */ 1634 NULL; 1635 1636 public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException { 1637 if (codeString == null || "".equals(codeString)) 1638 return null; 1639 if ("yes".equals(codeString)) 1640 return YES; 1641 if ("no".equals(codeString)) 1642 return NO; 1643 if (Configuration.isAcceptInvalidEnums()) 1644 return null; 1645 else 1646 throw new FHIRException("Unknown ActionPrecheckBehavior code '" + codeString + "'"); 1647 } 1648 1649 public String toCode() { 1650 switch (this) { 1651 case YES: 1652 return "yes"; 1653 case NO: 1654 return "no"; 1655 case NULL: 1656 return null; 1657 default: 1658 return "?"; 1659 } 1660 } 1661 1662 public String getSystem() { 1663 switch (this) { 1664 case YES: 1665 return "http://hl7.org/fhir/action-precheck-behavior"; 1666 case NO: 1667 return "http://hl7.org/fhir/action-precheck-behavior"; 1668 case NULL: 1669 return null; 1670 default: 1671 return "?"; 1672 } 1673 } 1674 1675 public String getDefinition() { 1676 switch (this) { 1677 case YES: 1678 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."; 1679 case NO: 1680 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."; 1681 case NULL: 1682 return null; 1683 default: 1684 return "?"; 1685 } 1686 } 1687 1688 public String getDisplay() { 1689 switch (this) { 1690 case YES: 1691 return "Yes"; 1692 case NO: 1693 return "No"; 1694 case NULL: 1695 return null; 1696 default: 1697 return "?"; 1698 } 1699 } 1700 } 1701 1702 public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> { 1703 public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException { 1704 if (codeString == null || "".equals(codeString)) 1705 if (codeString == null || "".equals(codeString)) 1706 return null; 1707 if ("yes".equals(codeString)) 1708 return ActionPrecheckBehavior.YES; 1709 if ("no".equals(codeString)) 1710 return ActionPrecheckBehavior.NO; 1711 throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '" + codeString + "'"); 1712 } 1713 1714 public Enumeration<ActionPrecheckBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1715 if (code == null) 1716 return null; 1717 if (code.isEmpty()) 1718 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 1719 String codeString = code.asStringValue(); 1720 if (codeString == null || "".equals(codeString)) 1721 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 1722 if ("yes".equals(codeString)) 1723 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES, code); 1724 if ("no".equals(codeString)) 1725 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO, code); 1726 throw new FHIRException("Unknown ActionPrecheckBehavior code '" + codeString + "'"); 1727 } 1728 1729 public String toCode(ActionPrecheckBehavior code) { 1730 if (code == ActionPrecheckBehavior.YES) 1731 return "yes"; 1732 if (code == ActionPrecheckBehavior.NO) 1733 return "no"; 1734 return "?"; 1735 } 1736 1737 public String toSystem(ActionPrecheckBehavior code) { 1738 return code.getSystem(); 1739 } 1740 } 1741 1742 public enum ActionCardinalityBehavior { 1743 /** 1744 * The action may only be selected one time. 1745 */ 1746 SINGLE, 1747 /** 1748 * The action may be selected multiple times. 1749 */ 1750 MULTIPLE, 1751 /** 1752 * added to help the parsers with the generic types 1753 */ 1754 NULL; 1755 1756 public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException { 1757 if (codeString == null || "".equals(codeString)) 1758 return null; 1759 if ("single".equals(codeString)) 1760 return SINGLE; 1761 if ("multiple".equals(codeString)) 1762 return MULTIPLE; 1763 if (Configuration.isAcceptInvalidEnums()) 1764 return null; 1765 else 1766 throw new FHIRException("Unknown ActionCardinalityBehavior code '" + codeString + "'"); 1767 } 1768 1769 public String toCode() { 1770 switch (this) { 1771 case SINGLE: 1772 return "single"; 1773 case MULTIPLE: 1774 return "multiple"; 1775 case NULL: 1776 return null; 1777 default: 1778 return "?"; 1779 } 1780 } 1781 1782 public String getSystem() { 1783 switch (this) { 1784 case SINGLE: 1785 return "http://hl7.org/fhir/action-cardinality-behavior"; 1786 case MULTIPLE: 1787 return "http://hl7.org/fhir/action-cardinality-behavior"; 1788 case NULL: 1789 return null; 1790 default: 1791 return "?"; 1792 } 1793 } 1794 1795 public String getDefinition() { 1796 switch (this) { 1797 case SINGLE: 1798 return "The action may only be selected one time."; 1799 case MULTIPLE: 1800 return "The action may be selected multiple times."; 1801 case NULL: 1802 return null; 1803 default: 1804 return "?"; 1805 } 1806 } 1807 1808 public String getDisplay() { 1809 switch (this) { 1810 case SINGLE: 1811 return "Single"; 1812 case MULTIPLE: 1813 return "Multiple"; 1814 case NULL: 1815 return null; 1816 default: 1817 return "?"; 1818 } 1819 } 1820 } 1821 1822 public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> { 1823 public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException { 1824 if (codeString == null || "".equals(codeString)) 1825 if (codeString == null || "".equals(codeString)) 1826 return null; 1827 if ("single".equals(codeString)) 1828 return ActionCardinalityBehavior.SINGLE; 1829 if ("multiple".equals(codeString)) 1830 return ActionCardinalityBehavior.MULTIPLE; 1831 throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '" + codeString + "'"); 1832 } 1833 1834 public Enumeration<ActionCardinalityBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1835 if (code == null) 1836 return null; 1837 if (code.isEmpty()) 1838 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 1839 String codeString = code.asStringValue(); 1840 if (codeString == null || "".equals(codeString)) 1841 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 1842 if ("single".equals(codeString)) 1843 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE, code); 1844 if ("multiple".equals(codeString)) 1845 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE, code); 1846 throw new FHIRException("Unknown ActionCardinalityBehavior code '" + codeString + "'"); 1847 } 1848 1849 public String toCode(ActionCardinalityBehavior code) { 1850 if (code == ActionCardinalityBehavior.SINGLE) 1851 return "single"; 1852 if (code == ActionCardinalityBehavior.MULTIPLE) 1853 return "multiple"; 1854 return "?"; 1855 } 1856 1857 public String toSystem(ActionCardinalityBehavior code) { 1858 return code.getSystem(); 1859 } 1860 } 1861 1862 @Block() 1863 public static class RequestGroupActionComponent extends BackboneElement implements IBaseBackboneElement { 1864 /** 1865 * A user-visible prefix for the action. 1866 */ 1867 @Child(name = "prefix", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false) 1868 @Description(shortDefinition = "User-visible prefix for the action (e.g. 1. or A.)", formalDefinition = "A user-visible prefix for the action.") 1869 protected StringType prefix; 1870 1871 /** 1872 * The title of the action displayed to a user. 1873 */ 1874 @Child(name = "title", type = { StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 1875 @Description(shortDefinition = "User-visible title", formalDefinition = "The title of the action displayed to a user.") 1876 protected StringType title; 1877 1878 /** 1879 * A short description of the action used to provide a summary to display to the 1880 * user. 1881 */ 1882 @Child(name = "description", type = { 1883 StringType.class }, order = 3, min = 0, max = 1, modifier = false, summary = true) 1884 @Description(shortDefinition = "Short description of the action", formalDefinition = "A short description of the action used to provide a summary to display to the user.") 1885 protected StringType description; 1886 1887 /** 1888 * A text equivalent of the action to be performed. This provides a 1889 * human-interpretable description of the action when the definition is consumed 1890 * by a system that might not be capable of interpreting it dynamically. 1891 */ 1892 @Child(name = "textEquivalent", type = { 1893 StringType.class }, order = 4, min = 0, max = 1, modifier = false, summary = true) 1894 @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.") 1895 protected StringType textEquivalent; 1896 1897 /** 1898 * Indicates how quickly the action should be addressed with respect to other 1899 * actions. 1900 */ 1901 @Child(name = "priority", type = { CodeType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false) 1902 @Description(shortDefinition = "routine | urgent | asap | stat", formalDefinition = "Indicates how quickly the action should be addressed with respect to other actions.") 1903 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/request-priority") 1904 protected Enumeration<RequestPriority> priority; 1905 1906 /** 1907 * A code that provides meaning for the action or action group. For example, a 1908 * section may have a LOINC code for a section of a documentation template. 1909 */ 1910 @Child(name = "code", type = { 1911 CodeableConcept.class }, order = 6, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1912 @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 a section of a documentation template.") 1913 protected List<CodeableConcept> code; 1914 1915 /** 1916 * Didactic or other informational resources associated with the action that can 1917 * be provided to the CDS recipient. Information resources can include inline 1918 * text commentary and links to web resources. 1919 */ 1920 @Child(name = "documentation", type = { 1921 RelatedArtifact.class }, order = 7, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1922 @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.") 1923 protected List<RelatedArtifact> documentation; 1924 1925 /** 1926 * An expression that describes applicability criteria, or start/stop conditions 1927 * for the action. 1928 */ 1929 @Child(name = "condition", type = {}, order = 8, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1930 @Description(shortDefinition = "Whether or not the action is applicable", formalDefinition = "An expression that describes applicability criteria, or start/stop conditions for the action.") 1931 protected List<RequestGroupActionConditionComponent> condition; 1932 1933 /** 1934 * A relationship to another action such as "before" or "30-60 minutes after 1935 * start of". 1936 */ 1937 @Child(name = "relatedAction", type = {}, order = 9, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1938 @Description(shortDefinition = "Relationship to another action", formalDefinition = "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".") 1939 protected List<RequestGroupActionRelatedActionComponent> relatedAction; 1940 1941 /** 1942 * An optional value describing when the action should be performed. 1943 */ 1944 @Child(name = "timing", type = { DateTimeType.class, Age.class, Period.class, Duration.class, Range.class, 1945 Timing.class }, order = 10, min = 0, max = 1, modifier = false, summary = false) 1946 @Description(shortDefinition = "When the action should take place", formalDefinition = "An optional value describing when the action should be performed.") 1947 protected Type timing; 1948 1949 /** 1950 * The participant that should perform or be responsible for this action. 1951 */ 1952 @Child(name = "participant", type = { Patient.class, Practitioner.class, PractitionerRole.class, 1953 RelatedPerson.class, 1954 Device.class }, order = 11, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1955 @Description(shortDefinition = "Who should perform the action", formalDefinition = "The participant that should perform or be responsible for this action.") 1956 protected List<Reference> participant; 1957 /** 1958 * The actual objects that are the target of the reference (The participant that 1959 * should perform or be responsible for this action.) 1960 */ 1961 protected List<Resource> participantTarget; 1962 1963 /** 1964 * The type of action to perform (create, update, remove). 1965 */ 1966 @Child(name = "type", type = { 1967 CodeableConcept.class }, order = 12, min = 0, max = 1, modifier = false, summary = false) 1968 @Description(shortDefinition = "create | update | remove | fire-event", formalDefinition = "The type of action to perform (create, update, remove).") 1969 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-type") 1970 protected CodeableConcept type; 1971 1972 /** 1973 * Defines the grouping behavior for the action and its children. 1974 */ 1975 @Child(name = "groupingBehavior", type = { 1976 CodeType.class }, order = 13, min = 0, max = 1, modifier = false, summary = false) 1977 @Description(shortDefinition = "visual-group | logical-group | sentence-group", formalDefinition = "Defines the grouping behavior for the action and its children.") 1978 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-grouping-behavior") 1979 protected Enumeration<ActionGroupingBehavior> groupingBehavior; 1980 1981 /** 1982 * Defines the selection behavior for the action and its children. 1983 */ 1984 @Child(name = "selectionBehavior", type = { 1985 CodeType.class }, order = 14, min = 0, max = 1, modifier = false, summary = false) 1986 @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.") 1987 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-selection-behavior") 1988 protected Enumeration<ActionSelectionBehavior> selectionBehavior; 1989 1990 /** 1991 * Defines expectations around whether an action is required. 1992 */ 1993 @Child(name = "requiredBehavior", type = { 1994 CodeType.class }, order = 15, min = 0, max = 1, modifier = false, summary = false) 1995 @Description(shortDefinition = "must | could | must-unless-documented", formalDefinition = "Defines expectations around whether an action is required.") 1996 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-required-behavior") 1997 protected Enumeration<ActionRequiredBehavior> requiredBehavior; 1998 1999 /** 2000 * Defines whether the action should usually be preselected. 2001 */ 2002 @Child(name = "precheckBehavior", type = { 2003 CodeType.class }, order = 16, min = 0, max = 1, modifier = false, summary = false) 2004 @Description(shortDefinition = "yes | no", formalDefinition = "Defines whether the action should usually be preselected.") 2005 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-precheck-behavior") 2006 protected Enumeration<ActionPrecheckBehavior> precheckBehavior; 2007 2008 /** 2009 * Defines whether the action can be selected multiple times. 2010 */ 2011 @Child(name = "cardinalityBehavior", type = { 2012 CodeType.class }, order = 17, min = 0, max = 1, modifier = false, summary = false) 2013 @Description(shortDefinition = "single | multiple", formalDefinition = "Defines whether the action can be selected multiple times.") 2014 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-cardinality-behavior") 2015 protected Enumeration<ActionCardinalityBehavior> cardinalityBehavior; 2016 2017 /** 2018 * The resource that is the target of the action (e.g. CommunicationRequest). 2019 */ 2020 @Child(name = "resource", type = { 2021 Reference.class }, order = 18, min = 0, max = 1, modifier = false, summary = false) 2022 @Description(shortDefinition = "The target of the action", formalDefinition = "The resource that is the target of the action (e.g. CommunicationRequest).") 2023 protected Reference resource; 2024 2025 /** 2026 * The actual object that is the target of the reference (The resource that is 2027 * the target of the action (e.g. CommunicationRequest).) 2028 */ 2029 protected Resource resourceTarget; 2030 2031 /** 2032 * Sub actions. 2033 */ 2034 @Child(name = "action", type = { 2035 RequestGroupActionComponent.class }, order = 19, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2036 @Description(shortDefinition = "Sub action", formalDefinition = "Sub actions.") 2037 protected List<RequestGroupActionComponent> action; 2038 2039 private static final long serialVersionUID = 296752321L; 2040 2041 /** 2042 * Constructor 2043 */ 2044 public RequestGroupActionComponent() { 2045 super(); 2046 } 2047 2048 /** 2049 * @return {@link #prefix} (A user-visible prefix for the action.). This is the 2050 * underlying object with id, value and extensions. The accessor 2051 * "getPrefix" gives direct access to the value 2052 */ 2053 public StringType getPrefixElement() { 2054 if (this.prefix == null) 2055 if (Configuration.errorOnAutoCreate()) 2056 throw new Error("Attempt to auto-create RequestGroupActionComponent.prefix"); 2057 else if (Configuration.doAutoCreate()) 2058 this.prefix = new StringType(); // bb 2059 return this.prefix; 2060 } 2061 2062 public boolean hasPrefixElement() { 2063 return this.prefix != null && !this.prefix.isEmpty(); 2064 } 2065 2066 public boolean hasPrefix() { 2067 return this.prefix != null && !this.prefix.isEmpty(); 2068 } 2069 2070 /** 2071 * @param value {@link #prefix} (A user-visible prefix for the action.). This is 2072 * the underlying object with id, value and extensions. The 2073 * accessor "getPrefix" gives direct access to the value 2074 */ 2075 public RequestGroupActionComponent setPrefixElement(StringType value) { 2076 this.prefix = value; 2077 return this; 2078 } 2079 2080 /** 2081 * @return A user-visible prefix for the action. 2082 */ 2083 public String getPrefix() { 2084 return this.prefix == null ? null : this.prefix.getValue(); 2085 } 2086 2087 /** 2088 * @param value A user-visible prefix for the action. 2089 */ 2090 public RequestGroupActionComponent setPrefix(String value) { 2091 if (Utilities.noString(value)) 2092 this.prefix = null; 2093 else { 2094 if (this.prefix == null) 2095 this.prefix = new StringType(); 2096 this.prefix.setValue(value); 2097 } 2098 return this; 2099 } 2100 2101 /** 2102 * @return {@link #title} (The title of the action displayed to a user.). This 2103 * is the underlying object with id, value and extensions. The accessor 2104 * "getTitle" gives direct access to the value 2105 */ 2106 public StringType getTitleElement() { 2107 if (this.title == null) 2108 if (Configuration.errorOnAutoCreate()) 2109 throw new Error("Attempt to auto-create RequestGroupActionComponent.title"); 2110 else if (Configuration.doAutoCreate()) 2111 this.title = new StringType(); // bb 2112 return this.title; 2113 } 2114 2115 public boolean hasTitleElement() { 2116 return this.title != null && !this.title.isEmpty(); 2117 } 2118 2119 public boolean hasTitle() { 2120 return this.title != null && !this.title.isEmpty(); 2121 } 2122 2123 /** 2124 * @param value {@link #title} (The title of the action displayed to a user.). 2125 * This is the underlying object with id, value and extensions. The 2126 * accessor "getTitle" gives direct access to the value 2127 */ 2128 public RequestGroupActionComponent setTitleElement(StringType value) { 2129 this.title = value; 2130 return this; 2131 } 2132 2133 /** 2134 * @return The title of the action displayed to a user. 2135 */ 2136 public String getTitle() { 2137 return this.title == null ? null : this.title.getValue(); 2138 } 2139 2140 /** 2141 * @param value The title of the action displayed to a user. 2142 */ 2143 public RequestGroupActionComponent setTitle(String value) { 2144 if (Utilities.noString(value)) 2145 this.title = null; 2146 else { 2147 if (this.title == null) 2148 this.title = new StringType(); 2149 this.title.setValue(value); 2150 } 2151 return this; 2152 } 2153 2154 /** 2155 * @return {@link #description} (A short description of the action used to 2156 * provide a summary to display to the user.). This is the underlying 2157 * object with id, value and extensions. The accessor "getDescription" 2158 * gives direct access to the value 2159 */ 2160 public StringType getDescriptionElement() { 2161 if (this.description == null) 2162 if (Configuration.errorOnAutoCreate()) 2163 throw new Error("Attempt to auto-create RequestGroupActionComponent.description"); 2164 else if (Configuration.doAutoCreate()) 2165 this.description = new StringType(); // bb 2166 return this.description; 2167 } 2168 2169 public boolean hasDescriptionElement() { 2170 return this.description != null && !this.description.isEmpty(); 2171 } 2172 2173 public boolean hasDescription() { 2174 return this.description != null && !this.description.isEmpty(); 2175 } 2176 2177 /** 2178 * @param value {@link #description} (A short description of the action used to 2179 * provide a summary to display to the user.). This is the 2180 * underlying object with id, value and extensions. The accessor 2181 * "getDescription" gives direct access to the value 2182 */ 2183 public RequestGroupActionComponent setDescriptionElement(StringType value) { 2184 this.description = value; 2185 return this; 2186 } 2187 2188 /** 2189 * @return A short description of the action used to provide a summary to 2190 * display to the user. 2191 */ 2192 public String getDescription() { 2193 return this.description == null ? null : this.description.getValue(); 2194 } 2195 2196 /** 2197 * @param value A short description of the action used to provide a summary to 2198 * display to the user. 2199 */ 2200 public RequestGroupActionComponent setDescription(String value) { 2201 if (Utilities.noString(value)) 2202 this.description = null; 2203 else { 2204 if (this.description == null) 2205 this.description = new StringType(); 2206 this.description.setValue(value); 2207 } 2208 return this; 2209 } 2210 2211 /** 2212 * @return {@link #textEquivalent} (A text equivalent of the action to be 2213 * performed. This provides a human-interpretable description of the 2214 * action when the definition is consumed by a system that might not be 2215 * capable of interpreting it dynamically.). This is the underlying 2216 * object with id, value and extensions. The accessor 2217 * "getTextEquivalent" gives direct access to the value 2218 */ 2219 public StringType getTextEquivalentElement() { 2220 if (this.textEquivalent == null) 2221 if (Configuration.errorOnAutoCreate()) 2222 throw new Error("Attempt to auto-create RequestGroupActionComponent.textEquivalent"); 2223 else if (Configuration.doAutoCreate()) 2224 this.textEquivalent = new StringType(); // bb 2225 return this.textEquivalent; 2226 } 2227 2228 public boolean hasTextEquivalentElement() { 2229 return this.textEquivalent != null && !this.textEquivalent.isEmpty(); 2230 } 2231 2232 public boolean hasTextEquivalent() { 2233 return this.textEquivalent != null && !this.textEquivalent.isEmpty(); 2234 } 2235 2236 /** 2237 * @param value {@link #textEquivalent} (A text equivalent of the action to be 2238 * performed. This provides a human-interpretable description of 2239 * the action when the definition is consumed by a system that 2240 * might not be capable of interpreting it dynamically.). This is 2241 * the underlying object with id, value and extensions. The 2242 * accessor "getTextEquivalent" gives direct access to the value 2243 */ 2244 public RequestGroupActionComponent setTextEquivalentElement(StringType value) { 2245 this.textEquivalent = value; 2246 return this; 2247 } 2248 2249 /** 2250 * @return A text equivalent of the action to be performed. This provides a 2251 * human-interpretable description of the action when the definition is 2252 * consumed by a system that might not be capable of interpreting it 2253 * dynamically. 2254 */ 2255 public String getTextEquivalent() { 2256 return this.textEquivalent == null ? null : this.textEquivalent.getValue(); 2257 } 2258 2259 /** 2260 * @param value A text equivalent of the action to be performed. This provides a 2261 * human-interpretable description of the action when the 2262 * definition is consumed by a system that might not be capable of 2263 * interpreting it dynamically. 2264 */ 2265 public RequestGroupActionComponent setTextEquivalent(String value) { 2266 if (Utilities.noString(value)) 2267 this.textEquivalent = null; 2268 else { 2269 if (this.textEquivalent == null) 2270 this.textEquivalent = new StringType(); 2271 this.textEquivalent.setValue(value); 2272 } 2273 return this; 2274 } 2275 2276 /** 2277 * @return {@link #priority} (Indicates how quickly the action should be 2278 * addressed with respect to other actions.). This is the underlying 2279 * object with id, value and extensions. The accessor "getPriority" 2280 * gives direct access to the value 2281 */ 2282 public Enumeration<RequestPriority> getPriorityElement() { 2283 if (this.priority == null) 2284 if (Configuration.errorOnAutoCreate()) 2285 throw new Error("Attempt to auto-create RequestGroupActionComponent.priority"); 2286 else if (Configuration.doAutoCreate()) 2287 this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); // bb 2288 return this.priority; 2289 } 2290 2291 public boolean hasPriorityElement() { 2292 return this.priority != null && !this.priority.isEmpty(); 2293 } 2294 2295 public boolean hasPriority() { 2296 return this.priority != null && !this.priority.isEmpty(); 2297 } 2298 2299 /** 2300 * @param value {@link #priority} (Indicates how quickly the action should be 2301 * addressed with respect to other actions.). This is the 2302 * underlying object with id, value and extensions. The accessor 2303 * "getPriority" gives direct access to the value 2304 */ 2305 public RequestGroupActionComponent setPriorityElement(Enumeration<RequestPriority> value) { 2306 this.priority = value; 2307 return this; 2308 } 2309 2310 /** 2311 * @return Indicates how quickly the action should be addressed with respect to 2312 * other actions. 2313 */ 2314 public RequestPriority getPriority() { 2315 return this.priority == null ? null : this.priority.getValue(); 2316 } 2317 2318 /** 2319 * @param value Indicates how quickly the action should be addressed with 2320 * respect to other actions. 2321 */ 2322 public RequestGroupActionComponent setPriority(RequestPriority value) { 2323 if (value == null) 2324 this.priority = null; 2325 else { 2326 if (this.priority == null) 2327 this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); 2328 this.priority.setValue(value); 2329 } 2330 return this; 2331 } 2332 2333 /** 2334 * @return {@link #code} (A code that provides meaning for the action or action 2335 * group. For example, a section may have a LOINC code for a section of 2336 * a documentation template.) 2337 */ 2338 public List<CodeableConcept> getCode() { 2339 if (this.code == null) 2340 this.code = new ArrayList<CodeableConcept>(); 2341 return this.code; 2342 } 2343 2344 /** 2345 * @return Returns a reference to <code>this</code> for easy method chaining 2346 */ 2347 public RequestGroupActionComponent setCode(List<CodeableConcept> theCode) { 2348 this.code = theCode; 2349 return this; 2350 } 2351 2352 public boolean hasCode() { 2353 if (this.code == null) 2354 return false; 2355 for (CodeableConcept item : this.code) 2356 if (!item.isEmpty()) 2357 return true; 2358 return false; 2359 } 2360 2361 public CodeableConcept addCode() { // 3 2362 CodeableConcept t = new CodeableConcept(); 2363 if (this.code == null) 2364 this.code = new ArrayList<CodeableConcept>(); 2365 this.code.add(t); 2366 return t; 2367 } 2368 2369 public RequestGroupActionComponent addCode(CodeableConcept t) { // 3 2370 if (t == null) 2371 return this; 2372 if (this.code == null) 2373 this.code = new ArrayList<CodeableConcept>(); 2374 this.code.add(t); 2375 return this; 2376 } 2377 2378 /** 2379 * @return The first repetition of repeating field {@link #code}, creating it if 2380 * it does not already exist 2381 */ 2382 public CodeableConcept getCodeFirstRep() { 2383 if (getCode().isEmpty()) { 2384 addCode(); 2385 } 2386 return getCode().get(0); 2387 } 2388 2389 /** 2390 * @return {@link #documentation} (Didactic or other informational resources 2391 * associated with the action that can be provided to the CDS recipient. 2392 * Information resources can include inline text commentary and links to 2393 * web resources.) 2394 */ 2395 public List<RelatedArtifact> getDocumentation() { 2396 if (this.documentation == null) 2397 this.documentation = new ArrayList<RelatedArtifact>(); 2398 return this.documentation; 2399 } 2400 2401 /** 2402 * @return Returns a reference to <code>this</code> for easy method chaining 2403 */ 2404 public RequestGroupActionComponent setDocumentation(List<RelatedArtifact> theDocumentation) { 2405 this.documentation = theDocumentation; 2406 return this; 2407 } 2408 2409 public boolean hasDocumentation() { 2410 if (this.documentation == null) 2411 return false; 2412 for (RelatedArtifact item : this.documentation) 2413 if (!item.isEmpty()) 2414 return true; 2415 return false; 2416 } 2417 2418 public RelatedArtifact addDocumentation() { // 3 2419 RelatedArtifact t = new RelatedArtifact(); 2420 if (this.documentation == null) 2421 this.documentation = new ArrayList<RelatedArtifact>(); 2422 this.documentation.add(t); 2423 return t; 2424 } 2425 2426 public RequestGroupActionComponent addDocumentation(RelatedArtifact t) { // 3 2427 if (t == null) 2428 return this; 2429 if (this.documentation == null) 2430 this.documentation = new ArrayList<RelatedArtifact>(); 2431 this.documentation.add(t); 2432 return this; 2433 } 2434 2435 /** 2436 * @return The first repetition of repeating field {@link #documentation}, 2437 * creating it if it does not already exist 2438 */ 2439 public RelatedArtifact getDocumentationFirstRep() { 2440 if (getDocumentation().isEmpty()) { 2441 addDocumentation(); 2442 } 2443 return getDocumentation().get(0); 2444 } 2445 2446 /** 2447 * @return {@link #condition} (An expression that describes applicability 2448 * criteria, or start/stop conditions for the action.) 2449 */ 2450 public List<RequestGroupActionConditionComponent> getCondition() { 2451 if (this.condition == null) 2452 this.condition = new ArrayList<RequestGroupActionConditionComponent>(); 2453 return this.condition; 2454 } 2455 2456 /** 2457 * @return Returns a reference to <code>this</code> for easy method chaining 2458 */ 2459 public RequestGroupActionComponent setCondition(List<RequestGroupActionConditionComponent> theCondition) { 2460 this.condition = theCondition; 2461 return this; 2462 } 2463 2464 public boolean hasCondition() { 2465 if (this.condition == null) 2466 return false; 2467 for (RequestGroupActionConditionComponent item : this.condition) 2468 if (!item.isEmpty()) 2469 return true; 2470 return false; 2471 } 2472 2473 public RequestGroupActionConditionComponent addCondition() { // 3 2474 RequestGroupActionConditionComponent t = new RequestGroupActionConditionComponent(); 2475 if (this.condition == null) 2476 this.condition = new ArrayList<RequestGroupActionConditionComponent>(); 2477 this.condition.add(t); 2478 return t; 2479 } 2480 2481 public RequestGroupActionComponent addCondition(RequestGroupActionConditionComponent t) { // 3 2482 if (t == null) 2483 return this; 2484 if (this.condition == null) 2485 this.condition = new ArrayList<RequestGroupActionConditionComponent>(); 2486 this.condition.add(t); 2487 return this; 2488 } 2489 2490 /** 2491 * @return The first repetition of repeating field {@link #condition}, creating 2492 * it if it does not already exist 2493 */ 2494 public RequestGroupActionConditionComponent getConditionFirstRep() { 2495 if (getCondition().isEmpty()) { 2496 addCondition(); 2497 } 2498 return getCondition().get(0); 2499 } 2500 2501 /** 2502 * @return {@link #relatedAction} (A relationship to another action such as 2503 * "before" or "30-60 minutes after start of".) 2504 */ 2505 public List<RequestGroupActionRelatedActionComponent> getRelatedAction() { 2506 if (this.relatedAction == null) 2507 this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>(); 2508 return this.relatedAction; 2509 } 2510 2511 /** 2512 * @return Returns a reference to <code>this</code> for easy method chaining 2513 */ 2514 public RequestGroupActionComponent setRelatedAction( 2515 List<RequestGroupActionRelatedActionComponent> theRelatedAction) { 2516 this.relatedAction = theRelatedAction; 2517 return this; 2518 } 2519 2520 public boolean hasRelatedAction() { 2521 if (this.relatedAction == null) 2522 return false; 2523 for (RequestGroupActionRelatedActionComponent item : this.relatedAction) 2524 if (!item.isEmpty()) 2525 return true; 2526 return false; 2527 } 2528 2529 public RequestGroupActionRelatedActionComponent addRelatedAction() { // 3 2530 RequestGroupActionRelatedActionComponent t = new RequestGroupActionRelatedActionComponent(); 2531 if (this.relatedAction == null) 2532 this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>(); 2533 this.relatedAction.add(t); 2534 return t; 2535 } 2536 2537 public RequestGroupActionComponent addRelatedAction(RequestGroupActionRelatedActionComponent t) { // 3 2538 if (t == null) 2539 return this; 2540 if (this.relatedAction == null) 2541 this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>(); 2542 this.relatedAction.add(t); 2543 return this; 2544 } 2545 2546 /** 2547 * @return The first repetition of repeating field {@link #relatedAction}, 2548 * creating it if it does not already exist 2549 */ 2550 public RequestGroupActionRelatedActionComponent getRelatedActionFirstRep() { 2551 if (getRelatedAction().isEmpty()) { 2552 addRelatedAction(); 2553 } 2554 return getRelatedAction().get(0); 2555 } 2556 2557 /** 2558 * @return {@link #timing} (An optional value describing when the action should 2559 * be performed.) 2560 */ 2561 public Type getTiming() { 2562 return this.timing; 2563 } 2564 2565 /** 2566 * @return {@link #timing} (An optional value describing when the action should 2567 * be performed.) 2568 */ 2569 public DateTimeType getTimingDateTimeType() throws FHIRException { 2570 if (this.timing == null) 2571 this.timing = new DateTimeType(); 2572 if (!(this.timing instanceof DateTimeType)) 2573 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but " 2574 + this.timing.getClass().getName() + " was encountered"); 2575 return (DateTimeType) this.timing; 2576 } 2577 2578 public boolean hasTimingDateTimeType() { 2579 return this != null && this.timing instanceof DateTimeType; 2580 } 2581 2582 /** 2583 * @return {@link #timing} (An optional value describing when the action should 2584 * be performed.) 2585 */ 2586 public Age getTimingAge() throws FHIRException { 2587 if (this.timing == null) 2588 this.timing = new Age(); 2589 if (!(this.timing instanceof Age)) 2590 throw new FHIRException( 2591 "Type mismatch: the type Age was expected, but " + this.timing.getClass().getName() + " was encountered"); 2592 return (Age) this.timing; 2593 } 2594 2595 public boolean hasTimingAge() { 2596 return this != null && this.timing instanceof Age; 2597 } 2598 2599 /** 2600 * @return {@link #timing} (An optional value describing when the action should 2601 * be performed.) 2602 */ 2603 public Period getTimingPeriod() throws FHIRException { 2604 if (this.timing == null) 2605 this.timing = new Period(); 2606 if (!(this.timing instanceof Period)) 2607 throw new FHIRException("Type mismatch: the type Period was expected, but " + this.timing.getClass().getName() 2608 + " was encountered"); 2609 return (Period) this.timing; 2610 } 2611 2612 public boolean hasTimingPeriod() { 2613 return this != null && this.timing instanceof Period; 2614 } 2615 2616 /** 2617 * @return {@link #timing} (An optional value describing when the action should 2618 * be performed.) 2619 */ 2620 public Duration getTimingDuration() throws FHIRException { 2621 if (this.timing == null) 2622 this.timing = new Duration(); 2623 if (!(this.timing instanceof Duration)) 2624 throw new FHIRException("Type mismatch: the type Duration was expected, but " + this.timing.getClass().getName() 2625 + " was encountered"); 2626 return (Duration) this.timing; 2627 } 2628 2629 public boolean hasTimingDuration() { 2630 return this != null && this.timing instanceof Duration; 2631 } 2632 2633 /** 2634 * @return {@link #timing} (An optional value describing when the action should 2635 * be performed.) 2636 */ 2637 public Range getTimingRange() throws FHIRException { 2638 if (this.timing == null) 2639 this.timing = new Range(); 2640 if (!(this.timing instanceof Range)) 2641 throw new FHIRException( 2642 "Type mismatch: the type Range was expected, but " + this.timing.getClass().getName() + " was encountered"); 2643 return (Range) this.timing; 2644 } 2645 2646 public boolean hasTimingRange() { 2647 return this != null && this.timing instanceof Range; 2648 } 2649 2650 /** 2651 * @return {@link #timing} (An optional value describing when the action should 2652 * be performed.) 2653 */ 2654 public Timing getTimingTiming() throws FHIRException { 2655 if (this.timing == null) 2656 this.timing = new Timing(); 2657 if (!(this.timing instanceof Timing)) 2658 throw new FHIRException("Type mismatch: the type Timing was expected, but " + this.timing.getClass().getName() 2659 + " was encountered"); 2660 return (Timing) this.timing; 2661 } 2662 2663 public boolean hasTimingTiming() { 2664 return this != null && this.timing instanceof Timing; 2665 } 2666 2667 public boolean hasTiming() { 2668 return this.timing != null && !this.timing.isEmpty(); 2669 } 2670 2671 /** 2672 * @param value {@link #timing} (An optional value describing when the action 2673 * should be performed.) 2674 */ 2675 public RequestGroupActionComponent setTiming(Type value) { 2676 if (value != null && !(value instanceof DateTimeType || value instanceof Age || value instanceof Period 2677 || value instanceof Duration || value instanceof Range || value instanceof Timing)) 2678 throw new Error("Not the right type for RequestGroup.action.timing[x]: " + value.fhirType()); 2679 this.timing = value; 2680 return this; 2681 } 2682 2683 /** 2684 * @return {@link #participant} (The participant that should perform or be 2685 * responsible for this action.) 2686 */ 2687 public List<Reference> getParticipant() { 2688 if (this.participant == null) 2689 this.participant = new ArrayList<Reference>(); 2690 return this.participant; 2691 } 2692 2693 /** 2694 * @return Returns a reference to <code>this</code> for easy method chaining 2695 */ 2696 public RequestGroupActionComponent setParticipant(List<Reference> theParticipant) { 2697 this.participant = theParticipant; 2698 return this; 2699 } 2700 2701 public boolean hasParticipant() { 2702 if (this.participant == null) 2703 return false; 2704 for (Reference item : this.participant) 2705 if (!item.isEmpty()) 2706 return true; 2707 return false; 2708 } 2709 2710 public Reference addParticipant() { // 3 2711 Reference t = new Reference(); 2712 if (this.participant == null) 2713 this.participant = new ArrayList<Reference>(); 2714 this.participant.add(t); 2715 return t; 2716 } 2717 2718 public RequestGroupActionComponent addParticipant(Reference t) { // 3 2719 if (t == null) 2720 return this; 2721 if (this.participant == null) 2722 this.participant = new ArrayList<Reference>(); 2723 this.participant.add(t); 2724 return this; 2725 } 2726 2727 /** 2728 * @return The first repetition of repeating field {@link #participant}, 2729 * creating it if it does not already exist 2730 */ 2731 public Reference getParticipantFirstRep() { 2732 if (getParticipant().isEmpty()) { 2733 addParticipant(); 2734 } 2735 return getParticipant().get(0); 2736 } 2737 2738 /** 2739 * @deprecated Use Reference#setResource(IBaseResource) instead 2740 */ 2741 @Deprecated 2742 public List<Resource> getParticipantTarget() { 2743 if (this.participantTarget == null) 2744 this.participantTarget = new ArrayList<Resource>(); 2745 return this.participantTarget; 2746 } 2747 2748 /** 2749 * @return {@link #type} (The type of action to perform (create, update, 2750 * remove).) 2751 */ 2752 public CodeableConcept getType() { 2753 if (this.type == null) 2754 if (Configuration.errorOnAutoCreate()) 2755 throw new Error("Attempt to auto-create RequestGroupActionComponent.type"); 2756 else if (Configuration.doAutoCreate()) 2757 this.type = new CodeableConcept(); // cc 2758 return this.type; 2759 } 2760 2761 public boolean hasType() { 2762 return this.type != null && !this.type.isEmpty(); 2763 } 2764 2765 /** 2766 * @param value {@link #type} (The type of action to perform (create, update, 2767 * remove).) 2768 */ 2769 public RequestGroupActionComponent setType(CodeableConcept value) { 2770 this.type = value; 2771 return this; 2772 } 2773 2774 /** 2775 * @return {@link #groupingBehavior} (Defines the grouping behavior for the 2776 * action and its children.). This is the underlying object with id, 2777 * value and extensions. The accessor "getGroupingBehavior" gives direct 2778 * access to the value 2779 */ 2780 public Enumeration<ActionGroupingBehavior> getGroupingBehaviorElement() { 2781 if (this.groupingBehavior == null) 2782 if (Configuration.errorOnAutoCreate()) 2783 throw new Error("Attempt to auto-create RequestGroupActionComponent.groupingBehavior"); 2784 else if (Configuration.doAutoCreate()) 2785 this.groupingBehavior = new Enumeration<ActionGroupingBehavior>(new ActionGroupingBehaviorEnumFactory()); // bb 2786 return this.groupingBehavior; 2787 } 2788 2789 public boolean hasGroupingBehaviorElement() { 2790 return this.groupingBehavior != null && !this.groupingBehavior.isEmpty(); 2791 } 2792 2793 public boolean hasGroupingBehavior() { 2794 return this.groupingBehavior != null && !this.groupingBehavior.isEmpty(); 2795 } 2796 2797 /** 2798 * @param value {@link #groupingBehavior} (Defines the grouping behavior for the 2799 * action and its children.). This is the underlying object with 2800 * id, value and extensions. The accessor "getGroupingBehavior" 2801 * gives direct access to the value 2802 */ 2803 public RequestGroupActionComponent setGroupingBehaviorElement(Enumeration<ActionGroupingBehavior> value) { 2804 this.groupingBehavior = value; 2805 return this; 2806 } 2807 2808 /** 2809 * @return Defines the grouping behavior for the action and its children. 2810 */ 2811 public ActionGroupingBehavior getGroupingBehavior() { 2812 return this.groupingBehavior == null ? null : this.groupingBehavior.getValue(); 2813 } 2814 2815 /** 2816 * @param value Defines the grouping behavior for the action and its children. 2817 */ 2818 public RequestGroupActionComponent setGroupingBehavior(ActionGroupingBehavior value) { 2819 if (value == null) 2820 this.groupingBehavior = null; 2821 else { 2822 if (this.groupingBehavior == null) 2823 this.groupingBehavior = new Enumeration<ActionGroupingBehavior>(new ActionGroupingBehaviorEnumFactory()); 2824 this.groupingBehavior.setValue(value); 2825 } 2826 return this; 2827 } 2828 2829 /** 2830 * @return {@link #selectionBehavior} (Defines the selection behavior for the 2831 * action and its children.). This is the underlying object with id, 2832 * value and extensions. The accessor "getSelectionBehavior" gives 2833 * direct access to the value 2834 */ 2835 public Enumeration<ActionSelectionBehavior> getSelectionBehaviorElement() { 2836 if (this.selectionBehavior == null) 2837 if (Configuration.errorOnAutoCreate()) 2838 throw new Error("Attempt to auto-create RequestGroupActionComponent.selectionBehavior"); 2839 else if (Configuration.doAutoCreate()) 2840 this.selectionBehavior = new Enumeration<ActionSelectionBehavior>(new ActionSelectionBehaviorEnumFactory()); // bb 2841 return this.selectionBehavior; 2842 } 2843 2844 public boolean hasSelectionBehaviorElement() { 2845 return this.selectionBehavior != null && !this.selectionBehavior.isEmpty(); 2846 } 2847 2848 public boolean hasSelectionBehavior() { 2849 return this.selectionBehavior != null && !this.selectionBehavior.isEmpty(); 2850 } 2851 2852 /** 2853 * @param value {@link #selectionBehavior} (Defines the selection behavior for 2854 * the action and its children.). This is the underlying object 2855 * with id, value and extensions. The accessor 2856 * "getSelectionBehavior" gives direct access to the value 2857 */ 2858 public RequestGroupActionComponent setSelectionBehaviorElement(Enumeration<ActionSelectionBehavior> value) { 2859 this.selectionBehavior = value; 2860 return this; 2861 } 2862 2863 /** 2864 * @return Defines the selection behavior for the action and its children. 2865 */ 2866 public ActionSelectionBehavior getSelectionBehavior() { 2867 return this.selectionBehavior == null ? null : this.selectionBehavior.getValue(); 2868 } 2869 2870 /** 2871 * @param value Defines the selection behavior for the action and its children. 2872 */ 2873 public RequestGroupActionComponent setSelectionBehavior(ActionSelectionBehavior value) { 2874 if (value == null) 2875 this.selectionBehavior = null; 2876 else { 2877 if (this.selectionBehavior == null) 2878 this.selectionBehavior = new Enumeration<ActionSelectionBehavior>(new ActionSelectionBehaviorEnumFactory()); 2879 this.selectionBehavior.setValue(value); 2880 } 2881 return this; 2882 } 2883 2884 /** 2885 * @return {@link #requiredBehavior} (Defines expectations around whether an 2886 * action is required.). This is the underlying object with id, value 2887 * and extensions. The accessor "getRequiredBehavior" gives direct 2888 * access to the value 2889 */ 2890 public Enumeration<ActionRequiredBehavior> getRequiredBehaviorElement() { 2891 if (this.requiredBehavior == null) 2892 if (Configuration.errorOnAutoCreate()) 2893 throw new Error("Attempt to auto-create RequestGroupActionComponent.requiredBehavior"); 2894 else if (Configuration.doAutoCreate()) 2895 this.requiredBehavior = new Enumeration<ActionRequiredBehavior>(new ActionRequiredBehaviorEnumFactory()); // bb 2896 return this.requiredBehavior; 2897 } 2898 2899 public boolean hasRequiredBehaviorElement() { 2900 return this.requiredBehavior != null && !this.requiredBehavior.isEmpty(); 2901 } 2902 2903 public boolean hasRequiredBehavior() { 2904 return this.requiredBehavior != null && !this.requiredBehavior.isEmpty(); 2905 } 2906 2907 /** 2908 * @param value {@link #requiredBehavior} (Defines expectations around whether 2909 * an action is required.). This is the underlying object with id, 2910 * value and extensions. The accessor "getRequiredBehavior" gives 2911 * direct access to the value 2912 */ 2913 public RequestGroupActionComponent setRequiredBehaviorElement(Enumeration<ActionRequiredBehavior> value) { 2914 this.requiredBehavior = value; 2915 return this; 2916 } 2917 2918 /** 2919 * @return Defines expectations around whether an action is required. 2920 */ 2921 public ActionRequiredBehavior getRequiredBehavior() { 2922 return this.requiredBehavior == null ? null : this.requiredBehavior.getValue(); 2923 } 2924 2925 /** 2926 * @param value Defines expectations around whether an action is required. 2927 */ 2928 public RequestGroupActionComponent setRequiredBehavior(ActionRequiredBehavior value) { 2929 if (value == null) 2930 this.requiredBehavior = null; 2931 else { 2932 if (this.requiredBehavior == null) 2933 this.requiredBehavior = new Enumeration<ActionRequiredBehavior>(new ActionRequiredBehaviorEnumFactory()); 2934 this.requiredBehavior.setValue(value); 2935 } 2936 return this; 2937 } 2938 2939 /** 2940 * @return {@link #precheckBehavior} (Defines whether the action should usually 2941 * be preselected.). This is the underlying object with id, value and 2942 * extensions. The accessor "getPrecheckBehavior" gives direct access to 2943 * the value 2944 */ 2945 public Enumeration<ActionPrecheckBehavior> getPrecheckBehaviorElement() { 2946 if (this.precheckBehavior == null) 2947 if (Configuration.errorOnAutoCreate()) 2948 throw new Error("Attempt to auto-create RequestGroupActionComponent.precheckBehavior"); 2949 else if (Configuration.doAutoCreate()) 2950 this.precheckBehavior = new Enumeration<ActionPrecheckBehavior>(new ActionPrecheckBehaviorEnumFactory()); // bb 2951 return this.precheckBehavior; 2952 } 2953 2954 public boolean hasPrecheckBehaviorElement() { 2955 return this.precheckBehavior != null && !this.precheckBehavior.isEmpty(); 2956 } 2957 2958 public boolean hasPrecheckBehavior() { 2959 return this.precheckBehavior != null && !this.precheckBehavior.isEmpty(); 2960 } 2961 2962 /** 2963 * @param value {@link #precheckBehavior} (Defines whether the action should 2964 * usually be preselected.). This is the underlying object with id, 2965 * value and extensions. The accessor "getPrecheckBehavior" gives 2966 * direct access to the value 2967 */ 2968 public RequestGroupActionComponent setPrecheckBehaviorElement(Enumeration<ActionPrecheckBehavior> value) { 2969 this.precheckBehavior = value; 2970 return this; 2971 } 2972 2973 /** 2974 * @return Defines whether the action should usually be preselected. 2975 */ 2976 public ActionPrecheckBehavior getPrecheckBehavior() { 2977 return this.precheckBehavior == null ? null : this.precheckBehavior.getValue(); 2978 } 2979 2980 /** 2981 * @param value Defines whether the action should usually be preselected. 2982 */ 2983 public RequestGroupActionComponent setPrecheckBehavior(ActionPrecheckBehavior value) { 2984 if (value == null) 2985 this.precheckBehavior = null; 2986 else { 2987 if (this.precheckBehavior == null) 2988 this.precheckBehavior = new Enumeration<ActionPrecheckBehavior>(new ActionPrecheckBehaviorEnumFactory()); 2989 this.precheckBehavior.setValue(value); 2990 } 2991 return this; 2992 } 2993 2994 /** 2995 * @return {@link #cardinalityBehavior} (Defines whether the action can be 2996 * selected multiple times.). This is the underlying object with id, 2997 * value and extensions. The accessor "getCardinalityBehavior" gives 2998 * direct access to the value 2999 */ 3000 public Enumeration<ActionCardinalityBehavior> getCardinalityBehaviorElement() { 3001 if (this.cardinalityBehavior == null) 3002 if (Configuration.errorOnAutoCreate()) 3003 throw new Error("Attempt to auto-create RequestGroupActionComponent.cardinalityBehavior"); 3004 else if (Configuration.doAutoCreate()) 3005 this.cardinalityBehavior = new Enumeration<ActionCardinalityBehavior>( 3006 new ActionCardinalityBehaviorEnumFactory()); // bb 3007 return this.cardinalityBehavior; 3008 } 3009 3010 public boolean hasCardinalityBehaviorElement() { 3011 return this.cardinalityBehavior != null && !this.cardinalityBehavior.isEmpty(); 3012 } 3013 3014 public boolean hasCardinalityBehavior() { 3015 return this.cardinalityBehavior != null && !this.cardinalityBehavior.isEmpty(); 3016 } 3017 3018 /** 3019 * @param value {@link #cardinalityBehavior} (Defines whether the action can be 3020 * selected multiple times.). This is the underlying object with 3021 * id, value and extensions. The accessor "getCardinalityBehavior" 3022 * gives direct access to the value 3023 */ 3024 public RequestGroupActionComponent setCardinalityBehaviorElement(Enumeration<ActionCardinalityBehavior> value) { 3025 this.cardinalityBehavior = value; 3026 return this; 3027 } 3028 3029 /** 3030 * @return Defines whether the action can be selected multiple times. 3031 */ 3032 public ActionCardinalityBehavior getCardinalityBehavior() { 3033 return this.cardinalityBehavior == null ? null : this.cardinalityBehavior.getValue(); 3034 } 3035 3036 /** 3037 * @param value Defines whether the action can be selected multiple times. 3038 */ 3039 public RequestGroupActionComponent setCardinalityBehavior(ActionCardinalityBehavior value) { 3040 if (value == null) 3041 this.cardinalityBehavior = null; 3042 else { 3043 if (this.cardinalityBehavior == null) 3044 this.cardinalityBehavior = new Enumeration<ActionCardinalityBehavior>( 3045 new ActionCardinalityBehaviorEnumFactory()); 3046 this.cardinalityBehavior.setValue(value); 3047 } 3048 return this; 3049 } 3050 3051 /** 3052 * @return {@link #resource} (The resource that is the target of the action 3053 * (e.g. CommunicationRequest).) 3054 */ 3055 public Reference getResource() { 3056 if (this.resource == null) 3057 if (Configuration.errorOnAutoCreate()) 3058 throw new Error("Attempt to auto-create RequestGroupActionComponent.resource"); 3059 else if (Configuration.doAutoCreate()) 3060 this.resource = new Reference(); // cc 3061 return this.resource; 3062 } 3063 3064 public boolean hasResource() { 3065 return this.resource != null && !this.resource.isEmpty(); 3066 } 3067 3068 /** 3069 * @param value {@link #resource} (The resource that is the target of the action 3070 * (e.g. CommunicationRequest).) 3071 */ 3072 public RequestGroupActionComponent setResource(Reference value) { 3073 this.resource = value; 3074 return this; 3075 } 3076 3077 /** 3078 * @return {@link #resource} The actual object that is the target of the 3079 * reference. The reference library doesn't populate this, but you can 3080 * use it to hold the resource if you resolve it. (The resource that is 3081 * the target of the action (e.g. CommunicationRequest).) 3082 */ 3083 public Resource getResourceTarget() { 3084 return this.resourceTarget; 3085 } 3086 3087 /** 3088 * @param value {@link #resource} The actual object that is the target of the 3089 * reference. The reference library doesn't use these, but you can 3090 * use it to hold the resource if you resolve it. (The resource 3091 * that is the target of the action (e.g. CommunicationRequest).) 3092 */ 3093 public RequestGroupActionComponent setResourceTarget(Resource value) { 3094 this.resourceTarget = value; 3095 return this; 3096 } 3097 3098 /** 3099 * @return {@link #action} (Sub actions.) 3100 */ 3101 public List<RequestGroupActionComponent> getAction() { 3102 if (this.action == null) 3103 this.action = new ArrayList<RequestGroupActionComponent>(); 3104 return this.action; 3105 } 3106 3107 /** 3108 * @return Returns a reference to <code>this</code> for easy method chaining 3109 */ 3110 public RequestGroupActionComponent setAction(List<RequestGroupActionComponent> theAction) { 3111 this.action = theAction; 3112 return this; 3113 } 3114 3115 public boolean hasAction() { 3116 if (this.action == null) 3117 return false; 3118 for (RequestGroupActionComponent item : this.action) 3119 if (!item.isEmpty()) 3120 return true; 3121 return false; 3122 } 3123 3124 public RequestGroupActionComponent addAction() { // 3 3125 RequestGroupActionComponent t = new RequestGroupActionComponent(); 3126 if (this.action == null) 3127 this.action = new ArrayList<RequestGroupActionComponent>(); 3128 this.action.add(t); 3129 return t; 3130 } 3131 3132 public RequestGroupActionComponent addAction(RequestGroupActionComponent t) { // 3 3133 if (t == null) 3134 return this; 3135 if (this.action == null) 3136 this.action = new ArrayList<RequestGroupActionComponent>(); 3137 this.action.add(t); 3138 return this; 3139 } 3140 3141 /** 3142 * @return The first repetition of repeating field {@link #action}, creating it 3143 * if it does not already exist 3144 */ 3145 public RequestGroupActionComponent getActionFirstRep() { 3146 if (getAction().isEmpty()) { 3147 addAction(); 3148 } 3149 return getAction().get(0); 3150 } 3151 3152 protected void listChildren(List<Property> children) { 3153 super.listChildren(children); 3154 children.add(new Property("prefix", "string", "A user-visible prefix for the action.", 0, 1, prefix)); 3155 children.add(new Property("title", "string", "The title of the action displayed to a user.", 0, 1, title)); 3156 children.add(new Property("description", "string", 3157 "A short description of the action used to provide a summary to display to the user.", 0, 1, description)); 3158 children.add(new Property("textEquivalent", "string", 3159 "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.", 3160 0, 1, textEquivalent)); 3161 children.add(new Property("priority", "code", 3162 "Indicates how quickly the action should be addressed with respect to other actions.", 0, 1, priority)); 3163 children.add(new Property("code", "CodeableConcept", 3164 "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a section of a documentation template.", 3165 0, java.lang.Integer.MAX_VALUE, code)); 3166 children.add(new Property("documentation", "RelatedArtifact", 3167 "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.", 3168 0, java.lang.Integer.MAX_VALUE, documentation)); 3169 children.add(new Property("condition", "", 3170 "An expression that describes applicability criteria, or start/stop conditions for the action.", 0, 3171 java.lang.Integer.MAX_VALUE, condition)); 3172 children.add(new Property("relatedAction", "", 3173 "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".", 0, 3174 java.lang.Integer.MAX_VALUE, relatedAction)); 3175 children.add(new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3176 "An optional value describing when the action should be performed.", 0, 1, timing)); 3177 children.add(new Property("participant", "Reference(Patient|Practitioner|PractitionerRole|RelatedPerson|Device)", 3178 "The participant that should perform or be responsible for this action.", 0, java.lang.Integer.MAX_VALUE, 3179 participant)); 3180 children.add(new Property("type", "CodeableConcept", "The type of action to perform (create, update, remove).", 0, 3181 1, type)); 3182 children.add(new Property("groupingBehavior", "code", 3183 "Defines the grouping behavior for the action and its children.", 0, 1, groupingBehavior)); 3184 children.add(new Property("selectionBehavior", "code", 3185 "Defines the selection behavior for the action and its children.", 0, 1, selectionBehavior)); 3186 children.add(new Property("requiredBehavior", "code", 3187 "Defines expectations around whether an action is required.", 0, 1, requiredBehavior)); 3188 children.add(new Property("precheckBehavior", "code", "Defines whether the action should usually be preselected.", 3189 0, 1, precheckBehavior)); 3190 children.add(new Property("cardinalityBehavior", "code", 3191 "Defines whether the action can be selected multiple times.", 0, 1, cardinalityBehavior)); 3192 children.add(new Property("resource", "Reference(Any)", 3193 "The resource that is the target of the action (e.g. CommunicationRequest).", 0, 1, resource)); 3194 children 3195 .add(new Property("action", "@RequestGroup.action", "Sub actions.", 0, java.lang.Integer.MAX_VALUE, action)); 3196 } 3197 3198 @Override 3199 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3200 switch (_hash) { 3201 case -980110702: 3202 /* prefix */ return new Property("prefix", "string", "A user-visible prefix for the action.", 0, 1, prefix); 3203 case 110371416: 3204 /* title */ return new Property("title", "string", "The title of the action displayed to a user.", 0, 1, title); 3205 case -1724546052: 3206 /* description */ return new Property("description", "string", 3207 "A short description of the action used to provide a summary to display to the user.", 0, 1, description); 3208 case -900391049: 3209 /* textEquivalent */ return new Property("textEquivalent", "string", 3210 "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.", 3211 0, 1, textEquivalent); 3212 case -1165461084: 3213 /* priority */ return new Property("priority", "code", 3214 "Indicates how quickly the action should be addressed with respect to other actions.", 0, 1, priority); 3215 case 3059181: 3216 /* code */ return new Property("code", "CodeableConcept", 3217 "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a section of a documentation template.", 3218 0, java.lang.Integer.MAX_VALUE, code); 3219 case 1587405498: 3220 /* documentation */ return new Property("documentation", "RelatedArtifact", 3221 "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.", 3222 0, java.lang.Integer.MAX_VALUE, documentation); 3223 case -861311717: 3224 /* condition */ return new Property("condition", "", 3225 "An expression that describes applicability criteria, or start/stop conditions for the action.", 0, 3226 java.lang.Integer.MAX_VALUE, condition); 3227 case -384107967: 3228 /* relatedAction */ return new Property("relatedAction", "", 3229 "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".", 0, 3230 java.lang.Integer.MAX_VALUE, relatedAction); 3231 case 164632566: 3232 /* timing[x] */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3233 "An optional value describing when the action should be performed.", 0, 1, timing); 3234 case -873664438: 3235 /* timing */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3236 "An optional value describing when the action should be performed.", 0, 1, timing); 3237 case -1837458939: 3238 /* timingDateTime */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3239 "An optional value describing when the action should be performed.", 0, 1, timing); 3240 case 164607061: 3241 /* timingAge */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3242 "An optional value describing when the action should be performed.", 0, 1, timing); 3243 case -615615829: 3244 /* timingPeriod */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3245 "An optional value describing when the action should be performed.", 0, 1, timing); 3246 case -1327253506: 3247 /* timingDuration */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3248 "An optional value describing when the action should be performed.", 0, 1, timing); 3249 case -710871277: 3250 /* timingRange */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3251 "An optional value describing when the action should be performed.", 0, 1, timing); 3252 case -497554124: 3253 /* timingTiming */ return new Property("timing[x]", "dateTime|Age|Period|Duration|Range|Timing", 3254 "An optional value describing when the action should be performed.", 0, 1, timing); 3255 case 767422259: 3256 /* participant */ return new Property("participant", 3257 "Reference(Patient|Practitioner|PractitionerRole|RelatedPerson|Device)", 3258 "The participant that should perform or be responsible for this action.", 0, java.lang.Integer.MAX_VALUE, 3259 participant); 3260 case 3575610: 3261 /* type */ return new Property("type", "CodeableConcept", 3262 "The type of action to perform (create, update, remove).", 0, 1, type); 3263 case 586678389: 3264 /* groupingBehavior */ return new Property("groupingBehavior", "code", 3265 "Defines the grouping behavior for the action and its children.", 0, 1, groupingBehavior); 3266 case 168639486: 3267 /* selectionBehavior */ return new Property("selectionBehavior", "code", 3268 "Defines the selection behavior for the action and its children.", 0, 1, selectionBehavior); 3269 case -1163906287: 3270 /* requiredBehavior */ return new Property("requiredBehavior", "code", 3271 "Defines expectations around whether an action is required.", 0, 1, requiredBehavior); 3272 case -1174249033: 3273 /* precheckBehavior */ return new Property("precheckBehavior", "code", 3274 "Defines whether the action should usually be preselected.", 0, 1, precheckBehavior); 3275 case -922577408: 3276 /* cardinalityBehavior */ return new Property("cardinalityBehavior", "code", 3277 "Defines whether the action can be selected multiple times.", 0, 1, cardinalityBehavior); 3278 case -341064690: 3279 /* resource */ return new Property("resource", "Reference(Any)", 3280 "The resource that is the target of the action (e.g. CommunicationRequest).", 0, 1, resource); 3281 case -1422950858: 3282 /* action */ return new Property("action", "@RequestGroup.action", "Sub actions.", 0, 3283 java.lang.Integer.MAX_VALUE, action); 3284 default: 3285 return super.getNamedProperty(_hash, _name, _checkValid); 3286 } 3287 3288 } 3289 3290 @Override 3291 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3292 switch (hash) { 3293 case -980110702: 3294 /* prefix */ return this.prefix == null ? new Base[0] : new Base[] { this.prefix }; // StringType 3295 case 110371416: 3296 /* title */ return this.title == null ? new Base[0] : new Base[] { this.title }; // StringType 3297 case -1724546052: 3298 /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType 3299 case -900391049: 3300 /* textEquivalent */ return this.textEquivalent == null ? new Base[0] : new Base[] { this.textEquivalent }; // StringType 3301 case -1165461084: 3302 /* priority */ return this.priority == null ? new Base[0] : new Base[] { this.priority }; // Enumeration<RequestPriority> 3303 case 3059181: 3304 /* code */ return this.code == null ? new Base[0] : this.code.toArray(new Base[this.code.size()]); // CodeableConcept 3305 case 1587405498: 3306 /* documentation */ return this.documentation == null ? new Base[0] 3307 : this.documentation.toArray(new Base[this.documentation.size()]); // RelatedArtifact 3308 case -861311717: 3309 /* condition */ return this.condition == null ? new Base[0] 3310 : this.condition.toArray(new Base[this.condition.size()]); // RequestGroupActionConditionComponent 3311 case -384107967: 3312 /* relatedAction */ return this.relatedAction == null ? new Base[0] 3313 : this.relatedAction.toArray(new Base[this.relatedAction.size()]); // RequestGroupActionRelatedActionComponent 3314 case -873664438: 3315 /* timing */ return this.timing == null ? new Base[0] : new Base[] { this.timing }; // Type 3316 case 767422259: 3317 /* participant */ return this.participant == null ? new Base[0] 3318 : this.participant.toArray(new Base[this.participant.size()]); // Reference 3319 case 3575610: 3320 /* type */ return this.type == null ? new Base[0] : new Base[] { this.type }; // CodeableConcept 3321 case 586678389: 3322 /* groupingBehavior */ return this.groupingBehavior == null ? new Base[0] 3323 : new Base[] { this.groupingBehavior }; // Enumeration<ActionGroupingBehavior> 3324 case 168639486: 3325 /* selectionBehavior */ return this.selectionBehavior == null ? new Base[0] 3326 : new Base[] { this.selectionBehavior }; // Enumeration<ActionSelectionBehavior> 3327 case -1163906287: 3328 /* requiredBehavior */ return this.requiredBehavior == null ? new Base[0] 3329 : new Base[] { this.requiredBehavior }; // Enumeration<ActionRequiredBehavior> 3330 case -1174249033: 3331 /* precheckBehavior */ return this.precheckBehavior == null ? new Base[0] 3332 : new Base[] { this.precheckBehavior }; // Enumeration<ActionPrecheckBehavior> 3333 case -922577408: 3334 /* cardinalityBehavior */ return this.cardinalityBehavior == null ? new Base[0] 3335 : new Base[] { this.cardinalityBehavior }; // Enumeration<ActionCardinalityBehavior> 3336 case -341064690: 3337 /* resource */ return this.resource == null ? new Base[0] : new Base[] { this.resource }; // Reference 3338 case -1422950858: 3339 /* action */ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // RequestGroupActionComponent 3340 default: 3341 return super.getProperty(hash, name, checkValid); 3342 } 3343 3344 } 3345 3346 @Override 3347 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3348 switch (hash) { 3349 case -980110702: // prefix 3350 this.prefix = castToString(value); // StringType 3351 return value; 3352 case 110371416: // title 3353 this.title = castToString(value); // StringType 3354 return value; 3355 case -1724546052: // description 3356 this.description = castToString(value); // StringType 3357 return value; 3358 case -900391049: // textEquivalent 3359 this.textEquivalent = castToString(value); // StringType 3360 return value; 3361 case -1165461084: // priority 3362 value = new RequestPriorityEnumFactory().fromType(castToCode(value)); 3363 this.priority = (Enumeration) value; // Enumeration<RequestPriority> 3364 return value; 3365 case 3059181: // code 3366 this.getCode().add(castToCodeableConcept(value)); // CodeableConcept 3367 return value; 3368 case 1587405498: // documentation 3369 this.getDocumentation().add(castToRelatedArtifact(value)); // RelatedArtifact 3370 return value; 3371 case -861311717: // condition 3372 this.getCondition().add((RequestGroupActionConditionComponent) value); // RequestGroupActionConditionComponent 3373 return value; 3374 case -384107967: // relatedAction 3375 this.getRelatedAction().add((RequestGroupActionRelatedActionComponent) value); // RequestGroupActionRelatedActionComponent 3376 return value; 3377 case -873664438: // timing 3378 this.timing = castToType(value); // Type 3379 return value; 3380 case 767422259: // participant 3381 this.getParticipant().add(castToReference(value)); // Reference 3382 return value; 3383 case 3575610: // type 3384 this.type = castToCodeableConcept(value); // CodeableConcept 3385 return value; 3386 case 586678389: // groupingBehavior 3387 value = new ActionGroupingBehaviorEnumFactory().fromType(castToCode(value)); 3388 this.groupingBehavior = (Enumeration) value; // Enumeration<ActionGroupingBehavior> 3389 return value; 3390 case 168639486: // selectionBehavior 3391 value = new ActionSelectionBehaviorEnumFactory().fromType(castToCode(value)); 3392 this.selectionBehavior = (Enumeration) value; // Enumeration<ActionSelectionBehavior> 3393 return value; 3394 case -1163906287: // requiredBehavior 3395 value = new ActionRequiredBehaviorEnumFactory().fromType(castToCode(value)); 3396 this.requiredBehavior = (Enumeration) value; // Enumeration<ActionRequiredBehavior> 3397 return value; 3398 case -1174249033: // precheckBehavior 3399 value = new ActionPrecheckBehaviorEnumFactory().fromType(castToCode(value)); 3400 this.precheckBehavior = (Enumeration) value; // Enumeration<ActionPrecheckBehavior> 3401 return value; 3402 case -922577408: // cardinalityBehavior 3403 value = new ActionCardinalityBehaviorEnumFactory().fromType(castToCode(value)); 3404 this.cardinalityBehavior = (Enumeration) value; // Enumeration<ActionCardinalityBehavior> 3405 return value; 3406 case -341064690: // resource 3407 this.resource = castToReference(value); // Reference 3408 return value; 3409 case -1422950858: // action 3410 this.getAction().add((RequestGroupActionComponent) value); // RequestGroupActionComponent 3411 return value; 3412 default: 3413 return super.setProperty(hash, name, value); 3414 } 3415 3416 } 3417 3418 @Override 3419 public Base setProperty(String name, Base value) throws FHIRException { 3420 if (name.equals("prefix")) { 3421 this.prefix = castToString(value); // StringType 3422 } else if (name.equals("title")) { 3423 this.title = castToString(value); // StringType 3424 } else if (name.equals("description")) { 3425 this.description = castToString(value); // StringType 3426 } else if (name.equals("textEquivalent")) { 3427 this.textEquivalent = castToString(value); // StringType 3428 } else if (name.equals("priority")) { 3429 value = new RequestPriorityEnumFactory().fromType(castToCode(value)); 3430 this.priority = (Enumeration) value; // Enumeration<RequestPriority> 3431 } else if (name.equals("code")) { 3432 this.getCode().add(castToCodeableConcept(value)); 3433 } else if (name.equals("documentation")) { 3434 this.getDocumentation().add(castToRelatedArtifact(value)); 3435 } else if (name.equals("condition")) { 3436 this.getCondition().add((RequestGroupActionConditionComponent) value); 3437 } else if (name.equals("relatedAction")) { 3438 this.getRelatedAction().add((RequestGroupActionRelatedActionComponent) value); 3439 } else if (name.equals("timing[x]")) { 3440 this.timing = castToType(value); // Type 3441 } else if (name.equals("participant")) { 3442 this.getParticipant().add(castToReference(value)); 3443 } else if (name.equals("type")) { 3444 this.type = castToCodeableConcept(value); // CodeableConcept 3445 } else if (name.equals("groupingBehavior")) { 3446 value = new ActionGroupingBehaviorEnumFactory().fromType(castToCode(value)); 3447 this.groupingBehavior = (Enumeration) value; // Enumeration<ActionGroupingBehavior> 3448 } else if (name.equals("selectionBehavior")) { 3449 value = new ActionSelectionBehaviorEnumFactory().fromType(castToCode(value)); 3450 this.selectionBehavior = (Enumeration) value; // Enumeration<ActionSelectionBehavior> 3451 } else if (name.equals("requiredBehavior")) { 3452 value = new ActionRequiredBehaviorEnumFactory().fromType(castToCode(value)); 3453 this.requiredBehavior = (Enumeration) value; // Enumeration<ActionRequiredBehavior> 3454 } else if (name.equals("precheckBehavior")) { 3455 value = new ActionPrecheckBehaviorEnumFactory().fromType(castToCode(value)); 3456 this.precheckBehavior = (Enumeration) value; // Enumeration<ActionPrecheckBehavior> 3457 } else if (name.equals("cardinalityBehavior")) { 3458 value = new ActionCardinalityBehaviorEnumFactory().fromType(castToCode(value)); 3459 this.cardinalityBehavior = (Enumeration) value; // Enumeration<ActionCardinalityBehavior> 3460 } else if (name.equals("resource")) { 3461 this.resource = castToReference(value); // Reference 3462 } else if (name.equals("action")) { 3463 this.getAction().add((RequestGroupActionComponent) value); 3464 } else 3465 return super.setProperty(name, value); 3466 return value; 3467 } 3468 3469 @Override 3470 public void removeChild(String name, Base value) throws FHIRException { 3471 if (name.equals("prefix")) { 3472 this.prefix = null; 3473 } else if (name.equals("title")) { 3474 this.title = null; 3475 } else if (name.equals("description")) { 3476 this.description = null; 3477 } else if (name.equals("textEquivalent")) { 3478 this.textEquivalent = null; 3479 } else if (name.equals("priority")) { 3480 this.priority = null; 3481 } else if (name.equals("code")) { 3482 this.getCode().remove(castToCodeableConcept(value)); 3483 } else if (name.equals("documentation")) { 3484 this.getDocumentation().remove(castToRelatedArtifact(value)); 3485 } else if (name.equals("condition")) { 3486 this.getCondition().remove((RequestGroupActionConditionComponent) value); 3487 } else if (name.equals("relatedAction")) { 3488 this.getRelatedAction().remove((RequestGroupActionRelatedActionComponent) value); 3489 } else if (name.equals("timing[x]")) { 3490 this.timing = null; 3491 } else if (name.equals("participant")) { 3492 this.getParticipant().remove(castToReference(value)); 3493 } else if (name.equals("type")) { 3494 this.type = null; 3495 } else if (name.equals("groupingBehavior")) { 3496 this.groupingBehavior = null; 3497 } else if (name.equals("selectionBehavior")) { 3498 this.selectionBehavior = null; 3499 } else if (name.equals("requiredBehavior")) { 3500 this.requiredBehavior = null; 3501 } else if (name.equals("precheckBehavior")) { 3502 this.precheckBehavior = null; 3503 } else if (name.equals("cardinalityBehavior")) { 3504 this.cardinalityBehavior = null; 3505 } else if (name.equals("resource")) { 3506 this.resource = null; 3507 } else if (name.equals("action")) { 3508 this.getAction().remove((RequestGroupActionComponent) value); 3509 } else 3510 super.removeChild(name, value); 3511 3512 } 3513 3514 @Override 3515 public Base makeProperty(int hash, String name) throws FHIRException { 3516 switch (hash) { 3517 case -980110702: 3518 return getPrefixElement(); 3519 case 110371416: 3520 return getTitleElement(); 3521 case -1724546052: 3522 return getDescriptionElement(); 3523 case -900391049: 3524 return getTextEquivalentElement(); 3525 case -1165461084: 3526 return getPriorityElement(); 3527 case 3059181: 3528 return addCode(); 3529 case 1587405498: 3530 return addDocumentation(); 3531 case -861311717: 3532 return addCondition(); 3533 case -384107967: 3534 return addRelatedAction(); 3535 case 164632566: 3536 return getTiming(); 3537 case -873664438: 3538 return getTiming(); 3539 case 767422259: 3540 return addParticipant(); 3541 case 3575610: 3542 return getType(); 3543 case 586678389: 3544 return getGroupingBehaviorElement(); 3545 case 168639486: 3546 return getSelectionBehaviorElement(); 3547 case -1163906287: 3548 return getRequiredBehaviorElement(); 3549 case -1174249033: 3550 return getPrecheckBehaviorElement(); 3551 case -922577408: 3552 return getCardinalityBehaviorElement(); 3553 case -341064690: 3554 return getResource(); 3555 case -1422950858: 3556 return addAction(); 3557 default: 3558 return super.makeProperty(hash, name); 3559 } 3560 3561 } 3562 3563 @Override 3564 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3565 switch (hash) { 3566 case -980110702: 3567 /* prefix */ return new String[] { "string" }; 3568 case 110371416: 3569 /* title */ return new String[] { "string" }; 3570 case -1724546052: 3571 /* description */ return new String[] { "string" }; 3572 case -900391049: 3573 /* textEquivalent */ return new String[] { "string" }; 3574 case -1165461084: 3575 /* priority */ return new String[] { "code" }; 3576 case 3059181: 3577 /* code */ return new String[] { "CodeableConcept" }; 3578 case 1587405498: 3579 /* documentation */ return new String[] { "RelatedArtifact" }; 3580 case -861311717: 3581 /* condition */ return new String[] {}; 3582 case -384107967: 3583 /* relatedAction */ return new String[] {}; 3584 case -873664438: 3585 /* timing */ return new String[] { "dateTime", "Age", "Period", "Duration", "Range", "Timing" }; 3586 case 767422259: 3587 /* participant */ return new String[] { "Reference" }; 3588 case 3575610: 3589 /* type */ return new String[] { "CodeableConcept" }; 3590 case 586678389: 3591 /* groupingBehavior */ return new String[] { "code" }; 3592 case 168639486: 3593 /* selectionBehavior */ return new String[] { "code" }; 3594 case -1163906287: 3595 /* requiredBehavior */ return new String[] { "code" }; 3596 case -1174249033: 3597 /* precheckBehavior */ return new String[] { "code" }; 3598 case -922577408: 3599 /* cardinalityBehavior */ return new String[] { "code" }; 3600 case -341064690: 3601 /* resource */ return new String[] { "Reference" }; 3602 case -1422950858: 3603 /* action */ return new String[] { "@RequestGroup.action" }; 3604 default: 3605 return super.getTypesForProperty(hash, name); 3606 } 3607 3608 } 3609 3610 @Override 3611 public Base addChild(String name) throws FHIRException { 3612 if (name.equals("prefix")) { 3613 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.prefix"); 3614 } else if (name.equals("title")) { 3615 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.title"); 3616 } else if (name.equals("description")) { 3617 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.description"); 3618 } else if (name.equals("textEquivalent")) { 3619 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.textEquivalent"); 3620 } else if (name.equals("priority")) { 3621 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.priority"); 3622 } else if (name.equals("code")) { 3623 return addCode(); 3624 } else if (name.equals("documentation")) { 3625 return addDocumentation(); 3626 } else if (name.equals("condition")) { 3627 return addCondition(); 3628 } else if (name.equals("relatedAction")) { 3629 return addRelatedAction(); 3630 } else if (name.equals("timingDateTime")) { 3631 this.timing = new DateTimeType(); 3632 return this.timing; 3633 } else if (name.equals("timingAge")) { 3634 this.timing = new Age(); 3635 return this.timing; 3636 } else if (name.equals("timingPeriod")) { 3637 this.timing = new Period(); 3638 return this.timing; 3639 } else if (name.equals("timingDuration")) { 3640 this.timing = new Duration(); 3641 return this.timing; 3642 } else if (name.equals("timingRange")) { 3643 this.timing = new Range(); 3644 return this.timing; 3645 } else if (name.equals("timingTiming")) { 3646 this.timing = new Timing(); 3647 return this.timing; 3648 } else if (name.equals("participant")) { 3649 return addParticipant(); 3650 } else if (name.equals("type")) { 3651 this.type = new CodeableConcept(); 3652 return this.type; 3653 } else if (name.equals("groupingBehavior")) { 3654 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.groupingBehavior"); 3655 } else if (name.equals("selectionBehavior")) { 3656 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.selectionBehavior"); 3657 } else if (name.equals("requiredBehavior")) { 3658 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.requiredBehavior"); 3659 } else if (name.equals("precheckBehavior")) { 3660 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.precheckBehavior"); 3661 } else if (name.equals("cardinalityBehavior")) { 3662 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.cardinalityBehavior"); 3663 } else if (name.equals("resource")) { 3664 this.resource = new Reference(); 3665 return this.resource; 3666 } else if (name.equals("action")) { 3667 return addAction(); 3668 } else 3669 return super.addChild(name); 3670 } 3671 3672 public RequestGroupActionComponent copy() { 3673 RequestGroupActionComponent dst = new RequestGroupActionComponent(); 3674 copyValues(dst); 3675 return dst; 3676 } 3677 3678 public void copyValues(RequestGroupActionComponent dst) { 3679 super.copyValues(dst); 3680 dst.prefix = prefix == null ? null : prefix.copy(); 3681 dst.title = title == null ? null : title.copy(); 3682 dst.description = description == null ? null : description.copy(); 3683 dst.textEquivalent = textEquivalent == null ? null : textEquivalent.copy(); 3684 dst.priority = priority == null ? null : priority.copy(); 3685 if (code != null) { 3686 dst.code = new ArrayList<CodeableConcept>(); 3687 for (CodeableConcept i : code) 3688 dst.code.add(i.copy()); 3689 } 3690 ; 3691 if (documentation != null) { 3692 dst.documentation = new ArrayList<RelatedArtifact>(); 3693 for (RelatedArtifact i : documentation) 3694 dst.documentation.add(i.copy()); 3695 } 3696 ; 3697 if (condition != null) { 3698 dst.condition = new ArrayList<RequestGroupActionConditionComponent>(); 3699 for (RequestGroupActionConditionComponent i : condition) 3700 dst.condition.add(i.copy()); 3701 } 3702 ; 3703 if (relatedAction != null) { 3704 dst.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>(); 3705 for (RequestGroupActionRelatedActionComponent i : relatedAction) 3706 dst.relatedAction.add(i.copy()); 3707 } 3708 ; 3709 dst.timing = timing == null ? null : timing.copy(); 3710 if (participant != null) { 3711 dst.participant = new ArrayList<Reference>(); 3712 for (Reference i : participant) 3713 dst.participant.add(i.copy()); 3714 } 3715 ; 3716 dst.type = type == null ? null : type.copy(); 3717 dst.groupingBehavior = groupingBehavior == null ? null : groupingBehavior.copy(); 3718 dst.selectionBehavior = selectionBehavior == null ? null : selectionBehavior.copy(); 3719 dst.requiredBehavior = requiredBehavior == null ? null : requiredBehavior.copy(); 3720 dst.precheckBehavior = precheckBehavior == null ? null : precheckBehavior.copy(); 3721 dst.cardinalityBehavior = cardinalityBehavior == null ? null : cardinalityBehavior.copy(); 3722 dst.resource = resource == null ? null : resource.copy(); 3723 if (action != null) { 3724 dst.action = new ArrayList<RequestGroupActionComponent>(); 3725 for (RequestGroupActionComponent i : action) 3726 dst.action.add(i.copy()); 3727 } 3728 ; 3729 } 3730 3731 @Override 3732 public boolean equalsDeep(Base other_) { 3733 if (!super.equalsDeep(other_)) 3734 return false; 3735 if (!(other_ instanceof RequestGroupActionComponent)) 3736 return false; 3737 RequestGroupActionComponent o = (RequestGroupActionComponent) other_; 3738 return compareDeep(prefix, o.prefix, true) && compareDeep(title, o.title, true) 3739 && compareDeep(description, o.description, true) && compareDeep(textEquivalent, o.textEquivalent, true) 3740 && compareDeep(priority, o.priority, true) && compareDeep(code, o.code, true) 3741 && compareDeep(documentation, o.documentation, true) && compareDeep(condition, o.condition, true) 3742 && compareDeep(relatedAction, o.relatedAction, true) && compareDeep(timing, o.timing, true) 3743 && compareDeep(participant, o.participant, true) && compareDeep(type, o.type, true) 3744 && compareDeep(groupingBehavior, o.groupingBehavior, true) 3745 && compareDeep(selectionBehavior, o.selectionBehavior, true) 3746 && compareDeep(requiredBehavior, o.requiredBehavior, true) 3747 && compareDeep(precheckBehavior, o.precheckBehavior, true) 3748 && compareDeep(cardinalityBehavior, o.cardinalityBehavior, true) && compareDeep(resource, o.resource, true) 3749 && compareDeep(action, o.action, true); 3750 } 3751 3752 @Override 3753 public boolean equalsShallow(Base other_) { 3754 if (!super.equalsShallow(other_)) 3755 return false; 3756 if (!(other_ instanceof RequestGroupActionComponent)) 3757 return false; 3758 RequestGroupActionComponent o = (RequestGroupActionComponent) other_; 3759 return compareValues(prefix, o.prefix, true) && compareValues(title, o.title, true) 3760 && compareValues(description, o.description, true) && compareValues(textEquivalent, o.textEquivalent, true) 3761 && compareValues(priority, o.priority, true) && compareValues(groupingBehavior, o.groupingBehavior, true) 3762 && compareValues(selectionBehavior, o.selectionBehavior, true) 3763 && compareValues(requiredBehavior, o.requiredBehavior, true) 3764 && compareValues(precheckBehavior, o.precheckBehavior, true) 3765 && compareValues(cardinalityBehavior, o.cardinalityBehavior, true); 3766 } 3767 3768 public boolean isEmpty() { 3769 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(prefix, title, description, textEquivalent, 3770 priority, code, documentation, condition, relatedAction, timing, participant, type, groupingBehavior, 3771 selectionBehavior, requiredBehavior, precheckBehavior, cardinalityBehavior, resource, action); 3772 } 3773 3774 public String fhirType() { 3775 return "RequestGroup.action"; 3776 3777 } 3778 3779 } 3780 3781 @Block() 3782 public static class RequestGroupActionConditionComponent extends BackboneElement implements IBaseBackboneElement { 3783 /** 3784 * The kind of condition. 3785 */ 3786 @Child(name = "kind", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false) 3787 @Description(shortDefinition = "applicability | start | stop", formalDefinition = "The kind of condition.") 3788 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-condition-kind") 3789 protected Enumeration<ActionConditionKind> kind; 3790 3791 /** 3792 * An expression that returns true or false, indicating whether or not the 3793 * condition is satisfied. 3794 */ 3795 @Child(name = "expression", type = { 3796 Expression.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 3797 @Description(shortDefinition = "Boolean-valued expression", formalDefinition = "An expression that returns true or false, indicating whether or not the condition is satisfied.") 3798 protected Expression expression; 3799 3800 private static final long serialVersionUID = -455150438L; 3801 3802 /** 3803 * Constructor 3804 */ 3805 public RequestGroupActionConditionComponent() { 3806 super(); 3807 } 3808 3809 /** 3810 * Constructor 3811 */ 3812 public RequestGroupActionConditionComponent(Enumeration<ActionConditionKind> kind) { 3813 super(); 3814 this.kind = kind; 3815 } 3816 3817 /** 3818 * @return {@link #kind} (The kind of condition.). This is the underlying object 3819 * with id, value and extensions. The accessor "getKind" gives direct 3820 * access to the value 3821 */ 3822 public Enumeration<ActionConditionKind> getKindElement() { 3823 if (this.kind == null) 3824 if (Configuration.errorOnAutoCreate()) 3825 throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.kind"); 3826 else if (Configuration.doAutoCreate()) 3827 this.kind = new Enumeration<ActionConditionKind>(new ActionConditionKindEnumFactory()); // bb 3828 return this.kind; 3829 } 3830 3831 public boolean hasKindElement() { 3832 return this.kind != null && !this.kind.isEmpty(); 3833 } 3834 3835 public boolean hasKind() { 3836 return this.kind != null && !this.kind.isEmpty(); 3837 } 3838 3839 /** 3840 * @param value {@link #kind} (The kind of condition.). This is the underlying 3841 * object with id, value and extensions. The accessor "getKind" 3842 * gives direct access to the value 3843 */ 3844 public RequestGroupActionConditionComponent setKindElement(Enumeration<ActionConditionKind> value) { 3845 this.kind = value; 3846 return this; 3847 } 3848 3849 /** 3850 * @return The kind of condition. 3851 */ 3852 public ActionConditionKind getKind() { 3853 return this.kind == null ? null : this.kind.getValue(); 3854 } 3855 3856 /** 3857 * @param value The kind of condition. 3858 */ 3859 public RequestGroupActionConditionComponent setKind(ActionConditionKind value) { 3860 if (this.kind == null) 3861 this.kind = new Enumeration<ActionConditionKind>(new ActionConditionKindEnumFactory()); 3862 this.kind.setValue(value); 3863 return this; 3864 } 3865 3866 /** 3867 * @return {@link #expression} (An expression that returns true or false, 3868 * indicating whether or not the condition is satisfied.) 3869 */ 3870 public Expression getExpression() { 3871 if (this.expression == null) 3872 if (Configuration.errorOnAutoCreate()) 3873 throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.expression"); 3874 else if (Configuration.doAutoCreate()) 3875 this.expression = new Expression(); // cc 3876 return this.expression; 3877 } 3878 3879 public boolean hasExpression() { 3880 return this.expression != null && !this.expression.isEmpty(); 3881 } 3882 3883 /** 3884 * @param value {@link #expression} (An expression that returns true or false, 3885 * indicating whether or not the condition is satisfied.) 3886 */ 3887 public RequestGroupActionConditionComponent setExpression(Expression value) { 3888 this.expression = value; 3889 return this; 3890 } 3891 3892 protected void listChildren(List<Property> children) { 3893 super.listChildren(children); 3894 children.add(new Property("kind", "code", "The kind of condition.", 0, 1, kind)); 3895 children.add(new Property("expression", "Expression", 3896 "An expression that returns true or false, indicating whether or not the condition is satisfied.", 0, 1, 3897 expression)); 3898 } 3899 3900 @Override 3901 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3902 switch (_hash) { 3903 case 3292052: 3904 /* kind */ return new Property("kind", "code", "The kind of condition.", 0, 1, kind); 3905 case -1795452264: 3906 /* expression */ return new Property("expression", "Expression", 3907 "An expression that returns true or false, indicating whether or not the condition is satisfied.", 0, 1, 3908 expression); 3909 default: 3910 return super.getNamedProperty(_hash, _name, _checkValid); 3911 } 3912 3913 } 3914 3915 @Override 3916 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3917 switch (hash) { 3918 case 3292052: 3919 /* kind */ return this.kind == null ? new Base[0] : new Base[] { this.kind }; // Enumeration<ActionConditionKind> 3920 case -1795452264: 3921 /* expression */ return this.expression == null ? new Base[0] : new Base[] { this.expression }; // Expression 3922 default: 3923 return super.getProperty(hash, name, checkValid); 3924 } 3925 3926 } 3927 3928 @Override 3929 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3930 switch (hash) { 3931 case 3292052: // kind 3932 value = new ActionConditionKindEnumFactory().fromType(castToCode(value)); 3933 this.kind = (Enumeration) value; // Enumeration<ActionConditionKind> 3934 return value; 3935 case -1795452264: // expression 3936 this.expression = castToExpression(value); // Expression 3937 return value; 3938 default: 3939 return super.setProperty(hash, name, value); 3940 } 3941 3942 } 3943 3944 @Override 3945 public Base setProperty(String name, Base value) throws FHIRException { 3946 if (name.equals("kind")) { 3947 value = new ActionConditionKindEnumFactory().fromType(castToCode(value)); 3948 this.kind = (Enumeration) value; // Enumeration<ActionConditionKind> 3949 } else if (name.equals("expression")) { 3950 this.expression = castToExpression(value); // Expression 3951 } else 3952 return super.setProperty(name, value); 3953 return value; 3954 } 3955 3956 @Override 3957 public void removeChild(String name, Base value) throws FHIRException { 3958 if (name.equals("kind")) { 3959 this.kind = null; 3960 } else if (name.equals("expression")) { 3961 this.expression = null; 3962 } else 3963 super.removeChild(name, value); 3964 3965 } 3966 3967 @Override 3968 public Base makeProperty(int hash, String name) throws FHIRException { 3969 switch (hash) { 3970 case 3292052: 3971 return getKindElement(); 3972 case -1795452264: 3973 return getExpression(); 3974 default: 3975 return super.makeProperty(hash, name); 3976 } 3977 3978 } 3979 3980 @Override 3981 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3982 switch (hash) { 3983 case 3292052: 3984 /* kind */ return new String[] { "code" }; 3985 case -1795452264: 3986 /* expression */ return new String[] { "Expression" }; 3987 default: 3988 return super.getTypesForProperty(hash, name); 3989 } 3990 3991 } 3992 3993 @Override 3994 public Base addChild(String name) throws FHIRException { 3995 if (name.equals("kind")) { 3996 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.kind"); 3997 } else if (name.equals("expression")) { 3998 this.expression = new Expression(); 3999 return this.expression; 4000 } else 4001 return super.addChild(name); 4002 } 4003 4004 public RequestGroupActionConditionComponent copy() { 4005 RequestGroupActionConditionComponent dst = new RequestGroupActionConditionComponent(); 4006 copyValues(dst); 4007 return dst; 4008 } 4009 4010 public void copyValues(RequestGroupActionConditionComponent dst) { 4011 super.copyValues(dst); 4012 dst.kind = kind == null ? null : kind.copy(); 4013 dst.expression = expression == null ? null : expression.copy(); 4014 } 4015 4016 @Override 4017 public boolean equalsDeep(Base other_) { 4018 if (!super.equalsDeep(other_)) 4019 return false; 4020 if (!(other_ instanceof RequestGroupActionConditionComponent)) 4021 return false; 4022 RequestGroupActionConditionComponent o = (RequestGroupActionConditionComponent) other_; 4023 return compareDeep(kind, o.kind, true) && compareDeep(expression, o.expression, true); 4024 } 4025 4026 @Override 4027 public boolean equalsShallow(Base other_) { 4028 if (!super.equalsShallow(other_)) 4029 return false; 4030 if (!(other_ instanceof RequestGroupActionConditionComponent)) 4031 return false; 4032 RequestGroupActionConditionComponent o = (RequestGroupActionConditionComponent) other_; 4033 return compareValues(kind, o.kind, true); 4034 } 4035 4036 public boolean isEmpty() { 4037 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(kind, expression); 4038 } 4039 4040 public String fhirType() { 4041 return "RequestGroup.action.condition"; 4042 4043 } 4044 4045 } 4046 4047 @Block() 4048 public static class RequestGroupActionRelatedActionComponent extends BackboneElement implements IBaseBackboneElement { 4049 /** 4050 * The element id of the action this is related to. 4051 */ 4052 @Child(name = "actionId", type = { IdType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false) 4053 @Description(shortDefinition = "What action this is related to", formalDefinition = "The element id of the action this is related to.") 4054 protected IdType actionId; 4055 4056 /** 4057 * The relationship of this action to the related action. 4058 */ 4059 @Child(name = "relationship", type = { 4060 CodeType.class }, order = 2, min = 1, max = 1, modifier = false, summary = false) 4061 @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.") 4062 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/action-relationship-type") 4063 protected Enumeration<ActionRelationshipType> relationship; 4064 4065 /** 4066 * A duration or range of durations to apply to the relationship. For example, 4067 * 30-60 minutes before. 4068 */ 4069 @Child(name = "offset", type = { Duration.class, 4070 Range.class }, order = 3, min = 0, max = 1, modifier = false, summary = false) 4071 @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.") 4072 protected Type offset; 4073 4074 private static final long serialVersionUID = 1063306770L; 4075 4076 /** 4077 * Constructor 4078 */ 4079 public RequestGroupActionRelatedActionComponent() { 4080 super(); 4081 } 4082 4083 /** 4084 * Constructor 4085 */ 4086 public RequestGroupActionRelatedActionComponent(IdType actionId, Enumeration<ActionRelationshipType> relationship) { 4087 super(); 4088 this.actionId = actionId; 4089 this.relationship = relationship; 4090 } 4091 4092 /** 4093 * @return {@link #actionId} (The element id of the action this is related to.). 4094 * This is the underlying object with id, value and extensions. The 4095 * accessor "getActionId" gives direct access to the value 4096 */ 4097 public IdType getActionIdElement() { 4098 if (this.actionId == null) 4099 if (Configuration.errorOnAutoCreate()) 4100 throw new Error("Attempt to auto-create RequestGroupActionRelatedActionComponent.actionId"); 4101 else if (Configuration.doAutoCreate()) 4102 this.actionId = new IdType(); // bb 4103 return this.actionId; 4104 } 4105 4106 public boolean hasActionIdElement() { 4107 return this.actionId != null && !this.actionId.isEmpty(); 4108 } 4109 4110 public boolean hasActionId() { 4111 return this.actionId != null && !this.actionId.isEmpty(); 4112 } 4113 4114 /** 4115 * @param value {@link #actionId} (The element id of the action this is related 4116 * to.). This is the underlying object with id, value and 4117 * extensions. The accessor "getActionId" gives direct access to 4118 * the value 4119 */ 4120 public RequestGroupActionRelatedActionComponent setActionIdElement(IdType value) { 4121 this.actionId = value; 4122 return this; 4123 } 4124 4125 /** 4126 * @return The element id of the action this is related to. 4127 */ 4128 public String getActionId() { 4129 return this.actionId == null ? null : this.actionId.getValue(); 4130 } 4131 4132 /** 4133 * @param value The element id of the action this is related to. 4134 */ 4135 public RequestGroupActionRelatedActionComponent setActionId(String value) { 4136 if (this.actionId == null) 4137 this.actionId = new IdType(); 4138 this.actionId.setValue(value); 4139 return this; 4140 } 4141 4142 /** 4143 * @return {@link #relationship} (The relationship of this action to the related 4144 * action.). This is the underlying object with id, value and 4145 * extensions. The accessor "getRelationship" gives direct access to the 4146 * value 4147 */ 4148 public Enumeration<ActionRelationshipType> getRelationshipElement() { 4149 if (this.relationship == null) 4150 if (Configuration.errorOnAutoCreate()) 4151 throw new Error("Attempt to auto-create RequestGroupActionRelatedActionComponent.relationship"); 4152 else if (Configuration.doAutoCreate()) 4153 this.relationship = new Enumeration<ActionRelationshipType>(new ActionRelationshipTypeEnumFactory()); // bb 4154 return this.relationship; 4155 } 4156 4157 public boolean hasRelationshipElement() { 4158 return this.relationship != null && !this.relationship.isEmpty(); 4159 } 4160 4161 public boolean hasRelationship() { 4162 return this.relationship != null && !this.relationship.isEmpty(); 4163 } 4164 4165 /** 4166 * @param value {@link #relationship} (The relationship of this action to the 4167 * related action.). This is the underlying object with id, value 4168 * and extensions. The accessor "getRelationship" gives direct 4169 * access to the value 4170 */ 4171 public RequestGroupActionRelatedActionComponent setRelationshipElement(Enumeration<ActionRelationshipType> value) { 4172 this.relationship = value; 4173 return this; 4174 } 4175 4176 /** 4177 * @return The relationship of this action to the related action. 4178 */ 4179 public ActionRelationshipType getRelationship() { 4180 return this.relationship == null ? null : this.relationship.getValue(); 4181 } 4182 4183 /** 4184 * @param value The relationship of this action to the related action. 4185 */ 4186 public RequestGroupActionRelatedActionComponent setRelationship(ActionRelationshipType value) { 4187 if (this.relationship == null) 4188 this.relationship = new Enumeration<ActionRelationshipType>(new ActionRelationshipTypeEnumFactory()); 4189 this.relationship.setValue(value); 4190 return this; 4191 } 4192 4193 /** 4194 * @return {@link #offset} (A duration or range of durations to apply to the 4195 * relationship. For example, 30-60 minutes before.) 4196 */ 4197 public Type getOffset() { 4198 return this.offset; 4199 } 4200 4201 /** 4202 * @return {@link #offset} (A duration or range of durations to apply to the 4203 * relationship. For example, 30-60 minutes before.) 4204 */ 4205 public Duration getOffsetDuration() throws FHIRException { 4206 if (this.offset == null) 4207 this.offset = new Duration(); 4208 if (!(this.offset instanceof Duration)) 4209 throw new FHIRException("Type mismatch: the type Duration was expected, but " + this.offset.getClass().getName() 4210 + " was encountered"); 4211 return (Duration) this.offset; 4212 } 4213 4214 public boolean hasOffsetDuration() { 4215 return this != null && this.offset instanceof Duration; 4216 } 4217 4218 /** 4219 * @return {@link #offset} (A duration or range of durations to apply to the 4220 * relationship. For example, 30-60 minutes before.) 4221 */ 4222 public Range getOffsetRange() throws FHIRException { 4223 if (this.offset == null) 4224 this.offset = new Range(); 4225 if (!(this.offset instanceof Range)) 4226 throw new FHIRException( 4227 "Type mismatch: the type Range was expected, but " + this.offset.getClass().getName() + " was encountered"); 4228 return (Range) this.offset; 4229 } 4230 4231 public boolean hasOffsetRange() { 4232 return this != null && this.offset instanceof Range; 4233 } 4234 4235 public boolean hasOffset() { 4236 return this.offset != null && !this.offset.isEmpty(); 4237 } 4238 4239 /** 4240 * @param value {@link #offset} (A duration or range of durations to apply to 4241 * the relationship. For example, 30-60 minutes before.) 4242 */ 4243 public RequestGroupActionRelatedActionComponent setOffset(Type value) { 4244 if (value != null && !(value instanceof Duration || value instanceof Range)) 4245 throw new Error("Not the right type for RequestGroup.action.relatedAction.offset[x]: " + value.fhirType()); 4246 this.offset = value; 4247 return this; 4248 } 4249 4250 protected void listChildren(List<Property> children) { 4251 super.listChildren(children); 4252 children.add(new Property("actionId", "id", "The element id of the action this is related to.", 0, 1, actionId)); 4253 children.add(new Property("relationship", "code", "The relationship of this action to the related action.", 0, 1, 4254 relationship)); 4255 children.add(new Property("offset[x]", "Duration|Range", 4256 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 4257 offset)); 4258 } 4259 4260 @Override 4261 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4262 switch (_hash) { 4263 case -1656172047: 4264 /* actionId */ return new Property("actionId", "id", "The element id of the action this is related to.", 0, 1, 4265 actionId); 4266 case -261851592: 4267 /* relationship */ return new Property("relationship", "code", 4268 "The relationship of this action to the related action.", 0, 1, relationship); 4269 case -1960684787: 4270 /* offset[x] */ return new Property("offset[x]", "Duration|Range", 4271 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 4272 offset); 4273 case -1019779949: 4274 /* offset */ return new Property("offset[x]", "Duration|Range", 4275 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 4276 offset); 4277 case 134075207: 4278 /* offsetDuration */ return new Property("offset[x]", "Duration|Range", 4279 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 4280 offset); 4281 case 1263585386: 4282 /* offsetRange */ return new Property("offset[x]", "Duration|Range", 4283 "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, 4284 offset); 4285 default: 4286 return super.getNamedProperty(_hash, _name, _checkValid); 4287 } 4288 4289 } 4290 4291 @Override 4292 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4293 switch (hash) { 4294 case -1656172047: 4295 /* actionId */ return this.actionId == null ? new Base[0] : new Base[] { this.actionId }; // IdType 4296 case -261851592: 4297 /* relationship */ return this.relationship == null ? new Base[0] : new Base[] { this.relationship }; // Enumeration<ActionRelationshipType> 4298 case -1019779949: 4299 /* offset */ return this.offset == null ? new Base[0] : new Base[] { this.offset }; // Type 4300 default: 4301 return super.getProperty(hash, name, checkValid); 4302 } 4303 4304 } 4305 4306 @Override 4307 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4308 switch (hash) { 4309 case -1656172047: // actionId 4310 this.actionId = castToId(value); // IdType 4311 return value; 4312 case -261851592: // relationship 4313 value = new ActionRelationshipTypeEnumFactory().fromType(castToCode(value)); 4314 this.relationship = (Enumeration) value; // Enumeration<ActionRelationshipType> 4315 return value; 4316 case -1019779949: // offset 4317 this.offset = castToType(value); // Type 4318 return value; 4319 default: 4320 return super.setProperty(hash, name, value); 4321 } 4322 4323 } 4324 4325 @Override 4326 public Base setProperty(String name, Base value) throws FHIRException { 4327 if (name.equals("actionId")) { 4328 this.actionId = castToId(value); // IdType 4329 } else if (name.equals("relationship")) { 4330 value = new ActionRelationshipTypeEnumFactory().fromType(castToCode(value)); 4331 this.relationship = (Enumeration) value; // Enumeration<ActionRelationshipType> 4332 } else if (name.equals("offset[x]")) { 4333 this.offset = castToType(value); // Type 4334 } else 4335 return super.setProperty(name, value); 4336 return value; 4337 } 4338 4339 @Override 4340 public void removeChild(String name, Base value) throws FHIRException { 4341 if (name.equals("actionId")) { 4342 this.actionId = null; 4343 } else if (name.equals("relationship")) { 4344 this.relationship = null; 4345 } else if (name.equals("offset[x]")) { 4346 this.offset = null; 4347 } else 4348 super.removeChild(name, value); 4349 4350 } 4351 4352 @Override 4353 public Base makeProperty(int hash, String name) throws FHIRException { 4354 switch (hash) { 4355 case -1656172047: 4356 return getActionIdElement(); 4357 case -261851592: 4358 return getRelationshipElement(); 4359 case -1960684787: 4360 return getOffset(); 4361 case -1019779949: 4362 return getOffset(); 4363 default: 4364 return super.makeProperty(hash, name); 4365 } 4366 4367 } 4368 4369 @Override 4370 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4371 switch (hash) { 4372 case -1656172047: 4373 /* actionId */ return new String[] { "id" }; 4374 case -261851592: 4375 /* relationship */ return new String[] { "code" }; 4376 case -1019779949: 4377 /* offset */ return new String[] { "Duration", "Range" }; 4378 default: 4379 return super.getTypesForProperty(hash, name); 4380 } 4381 4382 } 4383 4384 @Override 4385 public Base addChild(String name) throws FHIRException { 4386 if (name.equals("actionId")) { 4387 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.actionId"); 4388 } else if (name.equals("relationship")) { 4389 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.relationship"); 4390 } else if (name.equals("offsetDuration")) { 4391 this.offset = new Duration(); 4392 return this.offset; 4393 } else if (name.equals("offsetRange")) { 4394 this.offset = new Range(); 4395 return this.offset; 4396 } else 4397 return super.addChild(name); 4398 } 4399 4400 public RequestGroupActionRelatedActionComponent copy() { 4401 RequestGroupActionRelatedActionComponent dst = new RequestGroupActionRelatedActionComponent(); 4402 copyValues(dst); 4403 return dst; 4404 } 4405 4406 public void copyValues(RequestGroupActionRelatedActionComponent dst) { 4407 super.copyValues(dst); 4408 dst.actionId = actionId == null ? null : actionId.copy(); 4409 dst.relationship = relationship == null ? null : relationship.copy(); 4410 dst.offset = offset == null ? null : offset.copy(); 4411 } 4412 4413 @Override 4414 public boolean equalsDeep(Base other_) { 4415 if (!super.equalsDeep(other_)) 4416 return false; 4417 if (!(other_ instanceof RequestGroupActionRelatedActionComponent)) 4418 return false; 4419 RequestGroupActionRelatedActionComponent o = (RequestGroupActionRelatedActionComponent) other_; 4420 return compareDeep(actionId, o.actionId, true) && compareDeep(relationship, o.relationship, true) 4421 && compareDeep(offset, o.offset, true); 4422 } 4423 4424 @Override 4425 public boolean equalsShallow(Base other_) { 4426 if (!super.equalsShallow(other_)) 4427 return false; 4428 if (!(other_ instanceof RequestGroupActionRelatedActionComponent)) 4429 return false; 4430 RequestGroupActionRelatedActionComponent o = (RequestGroupActionRelatedActionComponent) other_; 4431 return compareValues(actionId, o.actionId, true) && compareValues(relationship, o.relationship, true); 4432 } 4433 4434 public boolean isEmpty() { 4435 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(actionId, relationship, offset); 4436 } 4437 4438 public String fhirType() { 4439 return "RequestGroup.action.relatedAction"; 4440 4441 } 4442 4443 } 4444 4445 /** 4446 * Allows a service to provide a unique, business identifier for the request. 4447 */ 4448 @Child(name = "identifier", type = { 4449 Identifier.class }, order = 0, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 4450 @Description(shortDefinition = "Business identifier", formalDefinition = "Allows a service to provide a unique, business identifier for the request.") 4451 protected List<Identifier> identifier; 4452 4453 /** 4454 * A canonical URL referencing a FHIR-defined protocol, guideline, orderset or 4455 * other definition that is adhered to in whole or in part by this request. 4456 */ 4457 @Child(name = "instantiatesCanonical", type = { 4458 CanonicalType.class }, order = 1, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 4459 @Description(shortDefinition = "Instantiates FHIR protocol or definition", formalDefinition = "A canonical URL referencing a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.") 4460 protected List<CanonicalType> instantiatesCanonical; 4461 4462 /** 4463 * A URL referencing an externally defined protocol, guideline, orderset or 4464 * other definition that is adhered to in whole or in part by this request. 4465 */ 4466 @Child(name = "instantiatesUri", type = { 4467 UriType.class }, order = 2, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 4468 @Description(shortDefinition = "Instantiates external protocol or definition", formalDefinition = "A URL referencing an externally defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.") 4469 protected List<UriType> instantiatesUri; 4470 4471 /** 4472 * A plan, proposal or order that is fulfilled in whole or in part by this 4473 * request. 4474 */ 4475 @Child(name = "basedOn", type = { 4476 Reference.class }, order = 3, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 4477 @Description(shortDefinition = "Fulfills plan, proposal, or order", formalDefinition = "A plan, proposal or order that is fulfilled in whole or in part by this request.") 4478 protected List<Reference> basedOn; 4479 /** 4480 * The actual objects that are the target of the reference (A plan, proposal or 4481 * order that is fulfilled in whole or in part by this request.) 4482 */ 4483 protected List<Resource> basedOnTarget; 4484 4485 /** 4486 * Completed or terminated request(s) whose function is taken by this new 4487 * request. 4488 */ 4489 @Child(name = "replaces", type = { 4490 Reference.class }, order = 4, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 4491 @Description(shortDefinition = "Request(s) replaced by this request", formalDefinition = "Completed or terminated request(s) whose function is taken by this new request.") 4492 protected List<Reference> replaces; 4493 /** 4494 * The actual objects that are the target of the reference (Completed or 4495 * terminated request(s) whose function is taken by this new request.) 4496 */ 4497 protected List<Resource> replacesTarget; 4498 4499 /** 4500 * A shared identifier common to all requests that were authorized more or less 4501 * simultaneously by a single author, representing the identifier of the 4502 * requisition, prescription or similar form. 4503 */ 4504 @Child(name = "groupIdentifier", type = { 4505 Identifier.class }, order = 5, min = 0, max = 1, modifier = false, summary = true) 4506 @Description(shortDefinition = "Composite request this is part of", formalDefinition = "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.") 4507 protected Identifier groupIdentifier; 4508 4509 /** 4510 * The current state of the request. For request groups, the status reflects the 4511 * status of all the requests in the group. 4512 */ 4513 @Child(name = "status", type = { CodeType.class }, order = 6, min = 1, max = 1, modifier = true, summary = true) 4514 @Description(shortDefinition = "draft | active | on-hold | revoked | completed | entered-in-error | unknown", formalDefinition = "The current state of the request. For request groups, the status reflects the status of all the requests in the group.") 4515 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/request-status") 4516 protected Enumeration<RequestStatus> status; 4517 4518 /** 4519 * Indicates the level of authority/intentionality associated with the request 4520 * and where the request fits into the workflow chain. 4521 */ 4522 @Child(name = "intent", type = { CodeType.class }, order = 7, min = 1, max = 1, modifier = true, summary = true) 4523 @Description(shortDefinition = "proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option", formalDefinition = "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.") 4524 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/request-intent") 4525 protected Enumeration<RequestIntent> intent; 4526 4527 /** 4528 * Indicates how quickly the request should be addressed with respect to other 4529 * requests. 4530 */ 4531 @Child(name = "priority", type = { CodeType.class }, order = 8, min = 0, max = 1, modifier = false, summary = true) 4532 @Description(shortDefinition = "routine | urgent | asap | stat", formalDefinition = "Indicates how quickly the request should be addressed with respect to other requests.") 4533 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/request-priority") 4534 protected Enumeration<RequestPriority> priority; 4535 4536 /** 4537 * A code that identifies what the overall request group is. 4538 */ 4539 @Child(name = "code", type = { CodeableConcept.class }, order = 9, min = 0, max = 1, modifier = false, summary = true) 4540 @Description(shortDefinition = "What's being requested/ordered", formalDefinition = "A code that identifies what the overall request group is.") 4541 protected CodeableConcept code; 4542 4543 /** 4544 * The subject for which the request group was created. 4545 */ 4546 @Child(name = "subject", type = { Patient.class, 4547 Group.class }, order = 10, min = 0, max = 1, modifier = false, summary = false) 4548 @Description(shortDefinition = "Who the request group is about", formalDefinition = "The subject for which the request group was created.") 4549 protected Reference subject; 4550 4551 /** 4552 * The actual object that is the target of the reference (The subject for which 4553 * the request group was created.) 4554 */ 4555 protected Resource subjectTarget; 4556 4557 /** 4558 * Describes the context of the request group, if any. 4559 */ 4560 @Child(name = "encounter", type = { 4561 Encounter.class }, order = 11, min = 0, max = 1, modifier = false, summary = false) 4562 @Description(shortDefinition = "Created as part of", formalDefinition = "Describes the context of the request group, if any.") 4563 protected Reference encounter; 4564 4565 /** 4566 * The actual object that is the target of the reference (Describes the context 4567 * of the request group, if any.) 4568 */ 4569 protected Encounter encounterTarget; 4570 4571 /** 4572 * Indicates when the request group was created. 4573 */ 4574 @Child(name = "authoredOn", type = { 4575 DateTimeType.class }, order = 12, min = 0, max = 1, modifier = false, summary = false) 4576 @Description(shortDefinition = "When the request group was authored", formalDefinition = "Indicates when the request group was created.") 4577 protected DateTimeType authoredOn; 4578 4579 /** 4580 * Provides a reference to the author of the request group. 4581 */ 4582 @Child(name = "author", type = { Device.class, Practitioner.class, 4583 PractitionerRole.class }, order = 13, min = 0, max = 1, modifier = false, summary = false) 4584 @Description(shortDefinition = "Device or practitioner that authored the request group", formalDefinition = "Provides a reference to the author of the request group.") 4585 protected Reference author; 4586 4587 /** 4588 * The actual object that is the target of the reference (Provides a reference 4589 * to the author of the request group.) 4590 */ 4591 protected Resource authorTarget; 4592 4593 /** 4594 * Describes the reason for the request group in coded or textual form. 4595 */ 4596 @Child(name = "reasonCode", type = { 4597 CodeableConcept.class }, order = 14, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 4598 @Description(shortDefinition = "Why the request group is needed", formalDefinition = "Describes the reason for the request group in coded or textual form.") 4599 protected List<CodeableConcept> reasonCode; 4600 4601 /** 4602 * Indicates another resource whose existence justifies this request group. 4603 */ 4604 @Child(name = "reasonReference", type = { Condition.class, Observation.class, DiagnosticReport.class, 4605 DocumentReference.class }, order = 15, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 4606 @Description(shortDefinition = "Why the request group is needed", formalDefinition = "Indicates another resource whose existence justifies this request group.") 4607 protected List<Reference> reasonReference; 4608 /** 4609 * The actual objects that are the target of the reference (Indicates another 4610 * resource whose existence justifies this request group.) 4611 */ 4612 protected List<Resource> reasonReferenceTarget; 4613 4614 /** 4615 * Provides a mechanism to communicate additional information about the 4616 * response. 4617 */ 4618 @Child(name = "note", type = { 4619 Annotation.class }, order = 16, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 4620 @Description(shortDefinition = "Additional notes about the response", formalDefinition = "Provides a mechanism to communicate additional information about the response.") 4621 protected List<Annotation> note; 4622 4623 /** 4624 * The actions, if any, produced by the evaluation of the artifact. 4625 */ 4626 @Child(name = "action", type = {}, order = 17, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 4627 @Description(shortDefinition = "Proposed actions, if any", formalDefinition = "The actions, if any, produced by the evaluation of the artifact.") 4628 protected List<RequestGroupActionComponent> action; 4629 4630 private static final long serialVersionUID = -2053492070L; 4631 4632 /** 4633 * Constructor 4634 */ 4635 public RequestGroup() { 4636 super(); 4637 } 4638 4639 /** 4640 * Constructor 4641 */ 4642 public RequestGroup(Enumeration<RequestStatus> status, Enumeration<RequestIntent> intent) { 4643 super(); 4644 this.status = status; 4645 this.intent = intent; 4646 } 4647 4648 /** 4649 * @return {@link #identifier} (Allows a service to provide a unique, business 4650 * identifier for the request.) 4651 */ 4652 public List<Identifier> getIdentifier() { 4653 if (this.identifier == null) 4654 this.identifier = new ArrayList<Identifier>(); 4655 return this.identifier; 4656 } 4657 4658 /** 4659 * @return Returns a reference to <code>this</code> for easy method chaining 4660 */ 4661 public RequestGroup setIdentifier(List<Identifier> theIdentifier) { 4662 this.identifier = theIdentifier; 4663 return this; 4664 } 4665 4666 public boolean hasIdentifier() { 4667 if (this.identifier == null) 4668 return false; 4669 for (Identifier item : this.identifier) 4670 if (!item.isEmpty()) 4671 return true; 4672 return false; 4673 } 4674 4675 public Identifier addIdentifier() { // 3 4676 Identifier t = new Identifier(); 4677 if (this.identifier == null) 4678 this.identifier = new ArrayList<Identifier>(); 4679 this.identifier.add(t); 4680 return t; 4681 } 4682 4683 public RequestGroup addIdentifier(Identifier t) { // 3 4684 if (t == null) 4685 return this; 4686 if (this.identifier == null) 4687 this.identifier = new ArrayList<Identifier>(); 4688 this.identifier.add(t); 4689 return this; 4690 } 4691 4692 /** 4693 * @return The first repetition of repeating field {@link #identifier}, creating 4694 * it if it does not already exist 4695 */ 4696 public Identifier getIdentifierFirstRep() { 4697 if (getIdentifier().isEmpty()) { 4698 addIdentifier(); 4699 } 4700 return getIdentifier().get(0); 4701 } 4702 4703 /** 4704 * @return {@link #instantiatesCanonical} (A canonical URL referencing a 4705 * FHIR-defined protocol, guideline, orderset or other definition that 4706 * is adhered to in whole or in part by this request.) 4707 */ 4708 public List<CanonicalType> getInstantiatesCanonical() { 4709 if (this.instantiatesCanonical == null) 4710 this.instantiatesCanonical = new ArrayList<CanonicalType>(); 4711 return this.instantiatesCanonical; 4712 } 4713 4714 /** 4715 * @return Returns a reference to <code>this</code> for easy method chaining 4716 */ 4717 public RequestGroup setInstantiatesCanonical(List<CanonicalType> theInstantiatesCanonical) { 4718 this.instantiatesCanonical = theInstantiatesCanonical; 4719 return this; 4720 } 4721 4722 public boolean hasInstantiatesCanonical() { 4723 if (this.instantiatesCanonical == null) 4724 return false; 4725 for (CanonicalType item : this.instantiatesCanonical) 4726 if (!item.isEmpty()) 4727 return true; 4728 return false; 4729 } 4730 4731 /** 4732 * @return {@link #instantiatesCanonical} (A canonical URL referencing a 4733 * FHIR-defined protocol, guideline, orderset or other definition that 4734 * is adhered to in whole or in part by this request.) 4735 */ 4736 public CanonicalType addInstantiatesCanonicalElement() {// 2 4737 CanonicalType t = new CanonicalType(); 4738 if (this.instantiatesCanonical == null) 4739 this.instantiatesCanonical = new ArrayList<CanonicalType>(); 4740 this.instantiatesCanonical.add(t); 4741 return t; 4742 } 4743 4744 /** 4745 * @param value {@link #instantiatesCanonical} (A canonical URL referencing a 4746 * FHIR-defined protocol, guideline, orderset or other definition 4747 * that is adhered to in whole or in part by this request.) 4748 */ 4749 public RequestGroup addInstantiatesCanonical(String value) { // 1 4750 CanonicalType t = new CanonicalType(); 4751 t.setValue(value); 4752 if (this.instantiatesCanonical == null) 4753 this.instantiatesCanonical = new ArrayList<CanonicalType>(); 4754 this.instantiatesCanonical.add(t); 4755 return this; 4756 } 4757 4758 /** 4759 * @param value {@link #instantiatesCanonical} (A canonical URL referencing a 4760 * FHIR-defined protocol, guideline, orderset or other definition 4761 * that is adhered to in whole or in part by this request.) 4762 */ 4763 public boolean hasInstantiatesCanonical(String value) { 4764 if (this.instantiatesCanonical == null) 4765 return false; 4766 for (CanonicalType v : this.instantiatesCanonical) 4767 if (v.getValue().equals(value)) // canonical 4768 return true; 4769 return false; 4770 } 4771 4772 /** 4773 * @return {@link #instantiatesUri} (A URL referencing an externally defined 4774 * protocol, guideline, orderset or other definition that is adhered to 4775 * in whole or in part by this request.) 4776 */ 4777 public List<UriType> getInstantiatesUri() { 4778 if (this.instantiatesUri == null) 4779 this.instantiatesUri = new ArrayList<UriType>(); 4780 return this.instantiatesUri; 4781 } 4782 4783 /** 4784 * @return Returns a reference to <code>this</code> for easy method chaining 4785 */ 4786 public RequestGroup setInstantiatesUri(List<UriType> theInstantiatesUri) { 4787 this.instantiatesUri = theInstantiatesUri; 4788 return this; 4789 } 4790 4791 public boolean hasInstantiatesUri() { 4792 if (this.instantiatesUri == null) 4793 return false; 4794 for (UriType item : this.instantiatesUri) 4795 if (!item.isEmpty()) 4796 return true; 4797 return false; 4798 } 4799 4800 /** 4801 * @return {@link #instantiatesUri} (A URL referencing an externally defined 4802 * protocol, guideline, orderset or other definition that is adhered to 4803 * in whole or in part by this request.) 4804 */ 4805 public UriType addInstantiatesUriElement() {// 2 4806 UriType t = new UriType(); 4807 if (this.instantiatesUri == null) 4808 this.instantiatesUri = new ArrayList<UriType>(); 4809 this.instantiatesUri.add(t); 4810 return t; 4811 } 4812 4813 /** 4814 * @param value {@link #instantiatesUri} (A URL referencing an externally 4815 * defined protocol, guideline, orderset or other definition that 4816 * is adhered to in whole or in part by this request.) 4817 */ 4818 public RequestGroup addInstantiatesUri(String value) { // 1 4819 UriType t = new UriType(); 4820 t.setValue(value); 4821 if (this.instantiatesUri == null) 4822 this.instantiatesUri = new ArrayList<UriType>(); 4823 this.instantiatesUri.add(t); 4824 return this; 4825 } 4826 4827 /** 4828 * @param value {@link #instantiatesUri} (A URL referencing an externally 4829 * defined protocol, guideline, orderset or other definition that 4830 * is adhered to in whole or in part by this request.) 4831 */ 4832 public boolean hasInstantiatesUri(String value) { 4833 if (this.instantiatesUri == null) 4834 return false; 4835 for (UriType v : this.instantiatesUri) 4836 if (v.getValue().equals(value)) // uri 4837 return true; 4838 return false; 4839 } 4840 4841 /** 4842 * @return {@link #basedOn} (A plan, proposal or order that is fulfilled in 4843 * whole or in part by this request.) 4844 */ 4845 public List<Reference> getBasedOn() { 4846 if (this.basedOn == null) 4847 this.basedOn = new ArrayList<Reference>(); 4848 return this.basedOn; 4849 } 4850 4851 /** 4852 * @return Returns a reference to <code>this</code> for easy method chaining 4853 */ 4854 public RequestGroup setBasedOn(List<Reference> theBasedOn) { 4855 this.basedOn = theBasedOn; 4856 return this; 4857 } 4858 4859 public boolean hasBasedOn() { 4860 if (this.basedOn == null) 4861 return false; 4862 for (Reference item : this.basedOn) 4863 if (!item.isEmpty()) 4864 return true; 4865 return false; 4866 } 4867 4868 public Reference addBasedOn() { // 3 4869 Reference t = new Reference(); 4870 if (this.basedOn == null) 4871 this.basedOn = new ArrayList<Reference>(); 4872 this.basedOn.add(t); 4873 return t; 4874 } 4875 4876 public RequestGroup addBasedOn(Reference t) { // 3 4877 if (t == null) 4878 return this; 4879 if (this.basedOn == null) 4880 this.basedOn = new ArrayList<Reference>(); 4881 this.basedOn.add(t); 4882 return this; 4883 } 4884 4885 /** 4886 * @return The first repetition of repeating field {@link #basedOn}, creating it 4887 * if it does not already exist 4888 */ 4889 public Reference getBasedOnFirstRep() { 4890 if (getBasedOn().isEmpty()) { 4891 addBasedOn(); 4892 } 4893 return getBasedOn().get(0); 4894 } 4895 4896 /** 4897 * @deprecated Use Reference#setResource(IBaseResource) instead 4898 */ 4899 @Deprecated 4900 public List<Resource> getBasedOnTarget() { 4901 if (this.basedOnTarget == null) 4902 this.basedOnTarget = new ArrayList<Resource>(); 4903 return this.basedOnTarget; 4904 } 4905 4906 /** 4907 * @return {@link #replaces} (Completed or terminated request(s) whose function 4908 * is taken by this new request.) 4909 */ 4910 public List<Reference> getReplaces() { 4911 if (this.replaces == null) 4912 this.replaces = new ArrayList<Reference>(); 4913 return this.replaces; 4914 } 4915 4916 /** 4917 * @return Returns a reference to <code>this</code> for easy method chaining 4918 */ 4919 public RequestGroup setReplaces(List<Reference> theReplaces) { 4920 this.replaces = theReplaces; 4921 return this; 4922 } 4923 4924 public boolean hasReplaces() { 4925 if (this.replaces == null) 4926 return false; 4927 for (Reference item : this.replaces) 4928 if (!item.isEmpty()) 4929 return true; 4930 return false; 4931 } 4932 4933 public Reference addReplaces() { // 3 4934 Reference t = new Reference(); 4935 if (this.replaces == null) 4936 this.replaces = new ArrayList<Reference>(); 4937 this.replaces.add(t); 4938 return t; 4939 } 4940 4941 public RequestGroup addReplaces(Reference t) { // 3 4942 if (t == null) 4943 return this; 4944 if (this.replaces == null) 4945 this.replaces = new ArrayList<Reference>(); 4946 this.replaces.add(t); 4947 return this; 4948 } 4949 4950 /** 4951 * @return The first repetition of repeating field {@link #replaces}, creating 4952 * it if it does not already exist 4953 */ 4954 public Reference getReplacesFirstRep() { 4955 if (getReplaces().isEmpty()) { 4956 addReplaces(); 4957 } 4958 return getReplaces().get(0); 4959 } 4960 4961 /** 4962 * @deprecated Use Reference#setResource(IBaseResource) instead 4963 */ 4964 @Deprecated 4965 public List<Resource> getReplacesTarget() { 4966 if (this.replacesTarget == null) 4967 this.replacesTarget = new ArrayList<Resource>(); 4968 return this.replacesTarget; 4969 } 4970 4971 /** 4972 * @return {@link #groupIdentifier} (A shared identifier common to all requests 4973 * that were authorized more or less simultaneously by a single author, 4974 * representing the identifier of the requisition, prescription or 4975 * similar form.) 4976 */ 4977 public Identifier getGroupIdentifier() { 4978 if (this.groupIdentifier == null) 4979 if (Configuration.errorOnAutoCreate()) 4980 throw new Error("Attempt to auto-create RequestGroup.groupIdentifier"); 4981 else if (Configuration.doAutoCreate()) 4982 this.groupIdentifier = new Identifier(); // cc 4983 return this.groupIdentifier; 4984 } 4985 4986 public boolean hasGroupIdentifier() { 4987 return this.groupIdentifier != null && !this.groupIdentifier.isEmpty(); 4988 } 4989 4990 /** 4991 * @param value {@link #groupIdentifier} (A shared identifier common to all 4992 * requests that were authorized more or less simultaneously by a 4993 * single author, representing the identifier of the requisition, 4994 * prescription or similar form.) 4995 */ 4996 public RequestGroup setGroupIdentifier(Identifier value) { 4997 this.groupIdentifier = value; 4998 return this; 4999 } 5000 5001 /** 5002 * @return {@link #status} (The current state of the request. For request 5003 * groups, the status reflects the status of all the requests in the 5004 * group.). This is the underlying object with id, value and extensions. 5005 * The accessor "getStatus" gives direct access to the value 5006 */ 5007 public Enumeration<RequestStatus> getStatusElement() { 5008 if (this.status == null) 5009 if (Configuration.errorOnAutoCreate()) 5010 throw new Error("Attempt to auto-create RequestGroup.status"); 5011 else if (Configuration.doAutoCreate()) 5012 this.status = new Enumeration<RequestStatus>(new RequestStatusEnumFactory()); // bb 5013 return this.status; 5014 } 5015 5016 public boolean hasStatusElement() { 5017 return this.status != null && !this.status.isEmpty(); 5018 } 5019 5020 public boolean hasStatus() { 5021 return this.status != null && !this.status.isEmpty(); 5022 } 5023 5024 /** 5025 * @param value {@link #status} (The current state of the request. For request 5026 * groups, the status reflects the status of all the requests in 5027 * the group.). This is the underlying object with id, value and 5028 * extensions. The accessor "getStatus" gives direct access to the 5029 * value 5030 */ 5031 public RequestGroup setStatusElement(Enumeration<RequestStatus> value) { 5032 this.status = value; 5033 return this; 5034 } 5035 5036 /** 5037 * @return The current state of the request. For request groups, the status 5038 * reflects the status of all the requests in the group. 5039 */ 5040 public RequestStatus getStatus() { 5041 return this.status == null ? null : this.status.getValue(); 5042 } 5043 5044 /** 5045 * @param value The current state of the request. For request groups, the status 5046 * reflects the status of all the requests in the group. 5047 */ 5048 public RequestGroup setStatus(RequestStatus value) { 5049 if (this.status == null) 5050 this.status = new Enumeration<RequestStatus>(new RequestStatusEnumFactory()); 5051 this.status.setValue(value); 5052 return this; 5053 } 5054 5055 /** 5056 * @return {@link #intent} (Indicates the level of authority/intentionality 5057 * associated with the request and where the request fits into the 5058 * workflow chain.). This is the underlying object with id, value and 5059 * extensions. The accessor "getIntent" gives direct access to the value 5060 */ 5061 public Enumeration<RequestIntent> getIntentElement() { 5062 if (this.intent == null) 5063 if (Configuration.errorOnAutoCreate()) 5064 throw new Error("Attempt to auto-create RequestGroup.intent"); 5065 else if (Configuration.doAutoCreate()) 5066 this.intent = new Enumeration<RequestIntent>(new RequestIntentEnumFactory()); // bb 5067 return this.intent; 5068 } 5069 5070 public boolean hasIntentElement() { 5071 return this.intent != null && !this.intent.isEmpty(); 5072 } 5073 5074 public boolean hasIntent() { 5075 return this.intent != null && !this.intent.isEmpty(); 5076 } 5077 5078 /** 5079 * @param value {@link #intent} (Indicates the level of authority/intentionality 5080 * associated with the request and where the request fits into the 5081 * workflow chain.). This is the underlying object with id, value 5082 * and extensions. The accessor "getIntent" gives direct access to 5083 * the value 5084 */ 5085 public RequestGroup setIntentElement(Enumeration<RequestIntent> value) { 5086 this.intent = value; 5087 return this; 5088 } 5089 5090 /** 5091 * @return Indicates the level of authority/intentionality associated with the 5092 * request and where the request fits into the workflow chain. 5093 */ 5094 public RequestIntent getIntent() { 5095 return this.intent == null ? null : this.intent.getValue(); 5096 } 5097 5098 /** 5099 * @param value Indicates the level of authority/intentionality associated with 5100 * the request and where the request fits into the workflow chain. 5101 */ 5102 public RequestGroup setIntent(RequestIntent value) { 5103 if (this.intent == null) 5104 this.intent = new Enumeration<RequestIntent>(new RequestIntentEnumFactory()); 5105 this.intent.setValue(value); 5106 return this; 5107 } 5108 5109 /** 5110 * @return {@link #priority} (Indicates how quickly the request should be 5111 * addressed with respect to other requests.). This is the underlying 5112 * object with id, value and extensions. The accessor "getPriority" 5113 * gives direct access to the value 5114 */ 5115 public Enumeration<RequestPriority> getPriorityElement() { 5116 if (this.priority == null) 5117 if (Configuration.errorOnAutoCreate()) 5118 throw new Error("Attempt to auto-create RequestGroup.priority"); 5119 else if (Configuration.doAutoCreate()) 5120 this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); // bb 5121 return this.priority; 5122 } 5123 5124 public boolean hasPriorityElement() { 5125 return this.priority != null && !this.priority.isEmpty(); 5126 } 5127 5128 public boolean hasPriority() { 5129 return this.priority != null && !this.priority.isEmpty(); 5130 } 5131 5132 /** 5133 * @param value {@link #priority} (Indicates how quickly the request should be 5134 * addressed with respect to other requests.). This is the 5135 * underlying object with id, value and extensions. The accessor 5136 * "getPriority" gives direct access to the value 5137 */ 5138 public RequestGroup setPriorityElement(Enumeration<RequestPriority> value) { 5139 this.priority = value; 5140 return this; 5141 } 5142 5143 /** 5144 * @return Indicates how quickly the request should be addressed with respect to 5145 * other requests. 5146 */ 5147 public RequestPriority getPriority() { 5148 return this.priority == null ? null : this.priority.getValue(); 5149 } 5150 5151 /** 5152 * @param value Indicates how quickly the request should be addressed with 5153 * respect to other requests. 5154 */ 5155 public RequestGroup setPriority(RequestPriority value) { 5156 if (value == null) 5157 this.priority = null; 5158 else { 5159 if (this.priority == null) 5160 this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); 5161 this.priority.setValue(value); 5162 } 5163 return this; 5164 } 5165 5166 /** 5167 * @return {@link #code} (A code that identifies what the overall request group 5168 * is.) 5169 */ 5170 public CodeableConcept getCode() { 5171 if (this.code == null) 5172 if (Configuration.errorOnAutoCreate()) 5173 throw new Error("Attempt to auto-create RequestGroup.code"); 5174 else if (Configuration.doAutoCreate()) 5175 this.code = new CodeableConcept(); // cc 5176 return this.code; 5177 } 5178 5179 public boolean hasCode() { 5180 return this.code != null && !this.code.isEmpty(); 5181 } 5182 5183 /** 5184 * @param value {@link #code} (A code that identifies what the overall request 5185 * group is.) 5186 */ 5187 public RequestGroup setCode(CodeableConcept value) { 5188 this.code = value; 5189 return this; 5190 } 5191 5192 /** 5193 * @return {@link #subject} (The subject for which the request group was 5194 * created.) 5195 */ 5196 public Reference getSubject() { 5197 if (this.subject == null) 5198 if (Configuration.errorOnAutoCreate()) 5199 throw new Error("Attempt to auto-create RequestGroup.subject"); 5200 else if (Configuration.doAutoCreate()) 5201 this.subject = new Reference(); // cc 5202 return this.subject; 5203 } 5204 5205 public boolean hasSubject() { 5206 return this.subject != null && !this.subject.isEmpty(); 5207 } 5208 5209 /** 5210 * @param value {@link #subject} (The subject for which the request group was 5211 * created.) 5212 */ 5213 public RequestGroup setSubject(Reference value) { 5214 this.subject = value; 5215 return this; 5216 } 5217 5218 /** 5219 * @return {@link #subject} The actual object that is the target of the 5220 * reference. The reference library doesn't populate this, but you can 5221 * use it to hold the resource if you resolve it. (The subject for which 5222 * the request group was created.) 5223 */ 5224 public Resource getSubjectTarget() { 5225 return this.subjectTarget; 5226 } 5227 5228 /** 5229 * @param value {@link #subject} The actual object that is the target of the 5230 * reference. The reference library doesn't use these, but you can 5231 * use it to hold the resource if you resolve it. (The subject for 5232 * which the request group was created.) 5233 */ 5234 public RequestGroup setSubjectTarget(Resource value) { 5235 this.subjectTarget = value; 5236 return this; 5237 } 5238 5239 /** 5240 * @return {@link #encounter} (Describes the context of the request group, if 5241 * any.) 5242 */ 5243 public Reference getEncounter() { 5244 if (this.encounter == null) 5245 if (Configuration.errorOnAutoCreate()) 5246 throw new Error("Attempt to auto-create RequestGroup.encounter"); 5247 else if (Configuration.doAutoCreate()) 5248 this.encounter = new Reference(); // cc 5249 return this.encounter; 5250 } 5251 5252 public boolean hasEncounter() { 5253 return this.encounter != null && !this.encounter.isEmpty(); 5254 } 5255 5256 /** 5257 * @param value {@link #encounter} (Describes the context of the request group, 5258 * if any.) 5259 */ 5260 public RequestGroup setEncounter(Reference value) { 5261 this.encounter = value; 5262 return this; 5263 } 5264 5265 /** 5266 * @return {@link #encounter} The actual object that is the target of the 5267 * reference. The reference library doesn't populate this, but you can 5268 * use it to hold the resource if you resolve it. (Describes the context 5269 * of the request group, if any.) 5270 */ 5271 public Encounter getEncounterTarget() { 5272 if (this.encounterTarget == null) 5273 if (Configuration.errorOnAutoCreate()) 5274 throw new Error("Attempt to auto-create RequestGroup.encounter"); 5275 else if (Configuration.doAutoCreate()) 5276 this.encounterTarget = new Encounter(); // aa 5277 return this.encounterTarget; 5278 } 5279 5280 /** 5281 * @param value {@link #encounter} The actual object that is the target of the 5282 * reference. The reference library doesn't use these, but you can 5283 * use it to hold the resource if you resolve it. (Describes the 5284 * context of the request group, if any.) 5285 */ 5286 public RequestGroup setEncounterTarget(Encounter value) { 5287 this.encounterTarget = value; 5288 return this; 5289 } 5290 5291 /** 5292 * @return {@link #authoredOn} (Indicates when the request group was created.). 5293 * This is the underlying object with id, value and extensions. The 5294 * accessor "getAuthoredOn" gives direct access to the value 5295 */ 5296 public DateTimeType getAuthoredOnElement() { 5297 if (this.authoredOn == null) 5298 if (Configuration.errorOnAutoCreate()) 5299 throw new Error("Attempt to auto-create RequestGroup.authoredOn"); 5300 else if (Configuration.doAutoCreate()) 5301 this.authoredOn = new DateTimeType(); // bb 5302 return this.authoredOn; 5303 } 5304 5305 public boolean hasAuthoredOnElement() { 5306 return this.authoredOn != null && !this.authoredOn.isEmpty(); 5307 } 5308 5309 public boolean hasAuthoredOn() { 5310 return this.authoredOn != null && !this.authoredOn.isEmpty(); 5311 } 5312 5313 /** 5314 * @param value {@link #authoredOn} (Indicates when the request group was 5315 * created.). This is the underlying object with id, value and 5316 * extensions. The accessor "getAuthoredOn" gives direct access to 5317 * the value 5318 */ 5319 public RequestGroup setAuthoredOnElement(DateTimeType value) { 5320 this.authoredOn = value; 5321 return this; 5322 } 5323 5324 /** 5325 * @return Indicates when the request group was created. 5326 */ 5327 public Date getAuthoredOn() { 5328 return this.authoredOn == null ? null : this.authoredOn.getValue(); 5329 } 5330 5331 /** 5332 * @param value Indicates when the request group was created. 5333 */ 5334 public RequestGroup setAuthoredOn(Date value) { 5335 if (value == null) 5336 this.authoredOn = null; 5337 else { 5338 if (this.authoredOn == null) 5339 this.authoredOn = new DateTimeType(); 5340 this.authoredOn.setValue(value); 5341 } 5342 return this; 5343 } 5344 5345 /** 5346 * @return {@link #author} (Provides a reference to the author of the request 5347 * group.) 5348 */ 5349 public Reference getAuthor() { 5350 if (this.author == null) 5351 if (Configuration.errorOnAutoCreate()) 5352 throw new Error("Attempt to auto-create RequestGroup.author"); 5353 else if (Configuration.doAutoCreate()) 5354 this.author = new Reference(); // cc 5355 return this.author; 5356 } 5357 5358 public boolean hasAuthor() { 5359 return this.author != null && !this.author.isEmpty(); 5360 } 5361 5362 /** 5363 * @param value {@link #author} (Provides a reference to the author of the 5364 * request group.) 5365 */ 5366 public RequestGroup setAuthor(Reference value) { 5367 this.author = value; 5368 return this; 5369 } 5370 5371 /** 5372 * @return {@link #author} The actual object that is the target of the 5373 * reference. The reference library doesn't populate this, but you can 5374 * use it to hold the resource if you resolve it. (Provides a reference 5375 * to the author of the request group.) 5376 */ 5377 public Resource getAuthorTarget() { 5378 return this.authorTarget; 5379 } 5380 5381 /** 5382 * @param value {@link #author} The actual object that is the target of the 5383 * reference. The reference library doesn't use these, but you can 5384 * use it to hold the resource if you resolve it. (Provides a 5385 * reference to the author of the request group.) 5386 */ 5387 public RequestGroup setAuthorTarget(Resource value) { 5388 this.authorTarget = value; 5389 return this; 5390 } 5391 5392 /** 5393 * @return {@link #reasonCode} (Describes the reason for the request group in 5394 * coded or textual form.) 5395 */ 5396 public List<CodeableConcept> getReasonCode() { 5397 if (this.reasonCode == null) 5398 this.reasonCode = new ArrayList<CodeableConcept>(); 5399 return this.reasonCode; 5400 } 5401 5402 /** 5403 * @return Returns a reference to <code>this</code> for easy method chaining 5404 */ 5405 public RequestGroup setReasonCode(List<CodeableConcept> theReasonCode) { 5406 this.reasonCode = theReasonCode; 5407 return this; 5408 } 5409 5410 public boolean hasReasonCode() { 5411 if (this.reasonCode == null) 5412 return false; 5413 for (CodeableConcept item : this.reasonCode) 5414 if (!item.isEmpty()) 5415 return true; 5416 return false; 5417 } 5418 5419 public CodeableConcept addReasonCode() { // 3 5420 CodeableConcept t = new CodeableConcept(); 5421 if (this.reasonCode == null) 5422 this.reasonCode = new ArrayList<CodeableConcept>(); 5423 this.reasonCode.add(t); 5424 return t; 5425 } 5426 5427 public RequestGroup addReasonCode(CodeableConcept t) { // 3 5428 if (t == null) 5429 return this; 5430 if (this.reasonCode == null) 5431 this.reasonCode = new ArrayList<CodeableConcept>(); 5432 this.reasonCode.add(t); 5433 return this; 5434 } 5435 5436 /** 5437 * @return The first repetition of repeating field {@link #reasonCode}, creating 5438 * it if it does not already exist 5439 */ 5440 public CodeableConcept getReasonCodeFirstRep() { 5441 if (getReasonCode().isEmpty()) { 5442 addReasonCode(); 5443 } 5444 return getReasonCode().get(0); 5445 } 5446 5447 /** 5448 * @return {@link #reasonReference} (Indicates another resource whose existence 5449 * justifies this request group.) 5450 */ 5451 public List<Reference> getReasonReference() { 5452 if (this.reasonReference == null) 5453 this.reasonReference = new ArrayList<Reference>(); 5454 return this.reasonReference; 5455 } 5456 5457 /** 5458 * @return Returns a reference to <code>this</code> for easy method chaining 5459 */ 5460 public RequestGroup setReasonReference(List<Reference> theReasonReference) { 5461 this.reasonReference = theReasonReference; 5462 return this; 5463 } 5464 5465 public boolean hasReasonReference() { 5466 if (this.reasonReference == null) 5467 return false; 5468 for (Reference item : this.reasonReference) 5469 if (!item.isEmpty()) 5470 return true; 5471 return false; 5472 } 5473 5474 public Reference addReasonReference() { // 3 5475 Reference t = new Reference(); 5476 if (this.reasonReference == null) 5477 this.reasonReference = new ArrayList<Reference>(); 5478 this.reasonReference.add(t); 5479 return t; 5480 } 5481 5482 public RequestGroup addReasonReference(Reference t) { // 3 5483 if (t == null) 5484 return this; 5485 if (this.reasonReference == null) 5486 this.reasonReference = new ArrayList<Reference>(); 5487 this.reasonReference.add(t); 5488 return this; 5489 } 5490 5491 /** 5492 * @return The first repetition of repeating field {@link #reasonReference}, 5493 * creating it if it does not already exist 5494 */ 5495 public Reference getReasonReferenceFirstRep() { 5496 if (getReasonReference().isEmpty()) { 5497 addReasonReference(); 5498 } 5499 return getReasonReference().get(0); 5500 } 5501 5502 /** 5503 * @deprecated Use Reference#setResource(IBaseResource) instead 5504 */ 5505 @Deprecated 5506 public List<Resource> getReasonReferenceTarget() { 5507 if (this.reasonReferenceTarget == null) 5508 this.reasonReferenceTarget = new ArrayList<Resource>(); 5509 return this.reasonReferenceTarget; 5510 } 5511 5512 /** 5513 * @return {@link #note} (Provides a mechanism to communicate additional 5514 * information about the response.) 5515 */ 5516 public List<Annotation> getNote() { 5517 if (this.note == null) 5518 this.note = new ArrayList<Annotation>(); 5519 return this.note; 5520 } 5521 5522 /** 5523 * @return Returns a reference to <code>this</code> for easy method chaining 5524 */ 5525 public RequestGroup setNote(List<Annotation> theNote) { 5526 this.note = theNote; 5527 return this; 5528 } 5529 5530 public boolean hasNote() { 5531 if (this.note == null) 5532 return false; 5533 for (Annotation item : this.note) 5534 if (!item.isEmpty()) 5535 return true; 5536 return false; 5537 } 5538 5539 public Annotation addNote() { // 3 5540 Annotation t = new Annotation(); 5541 if (this.note == null) 5542 this.note = new ArrayList<Annotation>(); 5543 this.note.add(t); 5544 return t; 5545 } 5546 5547 public RequestGroup addNote(Annotation t) { // 3 5548 if (t == null) 5549 return this; 5550 if (this.note == null) 5551 this.note = new ArrayList<Annotation>(); 5552 this.note.add(t); 5553 return this; 5554 } 5555 5556 /** 5557 * @return The first repetition of repeating field {@link #note}, creating it if 5558 * it does not already exist 5559 */ 5560 public Annotation getNoteFirstRep() { 5561 if (getNote().isEmpty()) { 5562 addNote(); 5563 } 5564 return getNote().get(0); 5565 } 5566 5567 /** 5568 * @return {@link #action} (The actions, if any, produced by the evaluation of 5569 * the artifact.) 5570 */ 5571 public List<RequestGroupActionComponent> getAction() { 5572 if (this.action == null) 5573 this.action = new ArrayList<RequestGroupActionComponent>(); 5574 return this.action; 5575 } 5576 5577 /** 5578 * @return Returns a reference to <code>this</code> for easy method chaining 5579 */ 5580 public RequestGroup setAction(List<RequestGroupActionComponent> theAction) { 5581 this.action = theAction; 5582 return this; 5583 } 5584 5585 public boolean hasAction() { 5586 if (this.action == null) 5587 return false; 5588 for (RequestGroupActionComponent item : this.action) 5589 if (!item.isEmpty()) 5590 return true; 5591 return false; 5592 } 5593 5594 public RequestGroupActionComponent addAction() { // 3 5595 RequestGroupActionComponent t = new RequestGroupActionComponent(); 5596 if (this.action == null) 5597 this.action = new ArrayList<RequestGroupActionComponent>(); 5598 this.action.add(t); 5599 return t; 5600 } 5601 5602 public RequestGroup addAction(RequestGroupActionComponent t) { // 3 5603 if (t == null) 5604 return this; 5605 if (this.action == null) 5606 this.action = new ArrayList<RequestGroupActionComponent>(); 5607 this.action.add(t); 5608 return this; 5609 } 5610 5611 /** 5612 * @return The first repetition of repeating field {@link #action}, creating it 5613 * if it does not already exist 5614 */ 5615 public RequestGroupActionComponent getActionFirstRep() { 5616 if (getAction().isEmpty()) { 5617 addAction(); 5618 } 5619 return getAction().get(0); 5620 } 5621 5622 protected void listChildren(List<Property> children) { 5623 super.listChildren(children); 5624 children.add(new Property("identifier", "Identifier", 5625 "Allows a service to provide a unique, business identifier for the request.", 0, java.lang.Integer.MAX_VALUE, 5626 identifier)); 5627 children.add(new Property("instantiatesCanonical", "canonical", 5628 "A canonical URL referencing a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.", 5629 0, java.lang.Integer.MAX_VALUE, instantiatesCanonical)); 5630 children.add(new Property("instantiatesUri", "uri", 5631 "A URL referencing an externally defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.", 5632 0, java.lang.Integer.MAX_VALUE, instantiatesUri)); 5633 children.add(new Property("basedOn", "Reference(Any)", 5634 "A plan, proposal or order that is fulfilled in whole or in part by this request.", 0, 5635 java.lang.Integer.MAX_VALUE, basedOn)); 5636 children.add(new Property("replaces", "Reference(Any)", 5637 "Completed or terminated request(s) whose function is taken by this new request.", 0, 5638 java.lang.Integer.MAX_VALUE, replaces)); 5639 children.add(new Property("groupIdentifier", "Identifier", 5640 "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.", 5641 0, 1, groupIdentifier)); 5642 children.add(new Property("status", "code", 5643 "The current state of the request. For request groups, the status reflects the status of all the requests in the group.", 5644 0, 1, status)); 5645 children.add(new Property("intent", "code", 5646 "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.", 5647 0, 1, intent)); 5648 children.add(new Property("priority", "code", 5649 "Indicates how quickly the request should be addressed with respect to other requests.", 0, 1, priority)); 5650 children.add(new Property("code", "CodeableConcept", "A code that identifies what the overall request group is.", 0, 5651 1, code)); 5652 children.add(new Property("subject", "Reference(Patient|Group)", 5653 "The subject for which the request group was created.", 0, 1, subject)); 5654 children.add(new Property("encounter", "Reference(Encounter)", 5655 "Describes the context of the request group, if any.", 0, 1, encounter)); 5656 children 5657 .add(new Property("authoredOn", "dateTime", "Indicates when the request group was created.", 0, 1, authoredOn)); 5658 children.add(new Property("author", "Reference(Device|Practitioner|PractitionerRole)", 5659 "Provides a reference to the author of the request group.", 0, 1, author)); 5660 children.add(new Property("reasonCode", "CodeableConcept", 5661 "Describes the reason for the request group in coded or textual form.", 0, java.lang.Integer.MAX_VALUE, 5662 reasonCode)); 5663 children.add(new Property("reasonReference", "Reference(Condition|Observation|DiagnosticReport|DocumentReference)", 5664 "Indicates another resource whose existence justifies this request group.", 0, java.lang.Integer.MAX_VALUE, 5665 reasonReference)); 5666 children.add(new Property("note", "Annotation", 5667 "Provides a mechanism to communicate additional information about the response.", 0, 5668 java.lang.Integer.MAX_VALUE, note)); 5669 children.add(new Property("action", "", "The actions, if any, produced by the evaluation of the artifact.", 0, 5670 java.lang.Integer.MAX_VALUE, action)); 5671 } 5672 5673 @Override 5674 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5675 switch (_hash) { 5676 case -1618432855: 5677 /* identifier */ return new Property("identifier", "Identifier", 5678 "Allows a service to provide a unique, business identifier for the request.", 0, java.lang.Integer.MAX_VALUE, 5679 identifier); 5680 case 8911915: 5681 /* instantiatesCanonical */ return new Property("instantiatesCanonical", "canonical", 5682 "A canonical URL referencing a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.", 5683 0, java.lang.Integer.MAX_VALUE, instantiatesCanonical); 5684 case -1926393373: 5685 /* instantiatesUri */ return new Property("instantiatesUri", "uri", 5686 "A URL referencing an externally defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.", 5687 0, java.lang.Integer.MAX_VALUE, instantiatesUri); 5688 case -332612366: 5689 /* basedOn */ return new Property("basedOn", "Reference(Any)", 5690 "A plan, proposal or order that is fulfilled in whole or in part by this request.", 0, 5691 java.lang.Integer.MAX_VALUE, basedOn); 5692 case -430332865: 5693 /* replaces */ return new Property("replaces", "Reference(Any)", 5694 "Completed or terminated request(s) whose function is taken by this new request.", 0, 5695 java.lang.Integer.MAX_VALUE, replaces); 5696 case -445338488: 5697 /* groupIdentifier */ return new Property("groupIdentifier", "Identifier", 5698 "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.", 5699 0, 1, groupIdentifier); 5700 case -892481550: 5701 /* status */ return new Property("status", "code", 5702 "The current state of the request. For request groups, the status reflects the status of all the requests in the group.", 5703 0, 1, status); 5704 case -1183762788: 5705 /* intent */ return new Property("intent", "code", 5706 "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.", 5707 0, 1, intent); 5708 case -1165461084: 5709 /* priority */ return new Property("priority", "code", 5710 "Indicates how quickly the request should be addressed with respect to other requests.", 0, 1, priority); 5711 case 3059181: 5712 /* code */ return new Property("code", "CodeableConcept", 5713 "A code that identifies what the overall request group is.", 0, 1, code); 5714 case -1867885268: 5715 /* subject */ return new Property("subject", "Reference(Patient|Group)", 5716 "The subject for which the request group was created.", 0, 1, subject); 5717 case 1524132147: 5718 /* encounter */ return new Property("encounter", "Reference(Encounter)", 5719 "Describes the context of the request group, if any.", 0, 1, encounter); 5720 case -1500852503: 5721 /* authoredOn */ return new Property("authoredOn", "dateTime", "Indicates when the request group was created.", 0, 5722 1, authoredOn); 5723 case -1406328437: 5724 /* author */ return new Property("author", "Reference(Device|Practitioner|PractitionerRole)", 5725 "Provides a reference to the author of the request group.", 0, 1, author); 5726 case 722137681: 5727 /* reasonCode */ return new Property("reasonCode", "CodeableConcept", 5728 "Describes the reason for the request group in coded or textual form.", 0, java.lang.Integer.MAX_VALUE, 5729 reasonCode); 5730 case -1146218137: 5731 /* reasonReference */ return new Property("reasonReference", 5732 "Reference(Condition|Observation|DiagnosticReport|DocumentReference)", 5733 "Indicates another resource whose existence justifies this request group.", 0, java.lang.Integer.MAX_VALUE, 5734 reasonReference); 5735 case 3387378: 5736 /* note */ return new Property("note", "Annotation", 5737 "Provides a mechanism to communicate additional information about the response.", 0, 5738 java.lang.Integer.MAX_VALUE, note); 5739 case -1422950858: 5740 /* action */ return new Property("action", "", "The actions, if any, produced by the evaluation of the artifact.", 5741 0, java.lang.Integer.MAX_VALUE, action); 5742 default: 5743 return super.getNamedProperty(_hash, _name, _checkValid); 5744 } 5745 5746 } 5747 5748 @Override 5749 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5750 switch (hash) { 5751 case -1618432855: 5752 /* identifier */ return this.identifier == null ? new Base[0] 5753 : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 5754 case 8911915: 5755 /* instantiatesCanonical */ return this.instantiatesCanonical == null ? new Base[0] 5756 : this.instantiatesCanonical.toArray(new Base[this.instantiatesCanonical.size()]); // CanonicalType 5757 case -1926393373: 5758 /* instantiatesUri */ return this.instantiatesUri == null ? new Base[0] 5759 : this.instantiatesUri.toArray(new Base[this.instantiatesUri.size()]); // UriType 5760 case -332612366: 5761 /* basedOn */ return this.basedOn == null ? new Base[0] : this.basedOn.toArray(new Base[this.basedOn.size()]); // Reference 5762 case -430332865: 5763 /* replaces */ return this.replaces == null ? new Base[0] : this.replaces.toArray(new Base[this.replaces.size()]); // Reference 5764 case -445338488: 5765 /* groupIdentifier */ return this.groupIdentifier == null ? new Base[0] : new Base[] { this.groupIdentifier }; // Identifier 5766 case -892481550: 5767 /* status */ return this.status == null ? new Base[0] : new Base[] { this.status }; // Enumeration<RequestStatus> 5768 case -1183762788: 5769 /* intent */ return this.intent == null ? new Base[0] : new Base[] { this.intent }; // Enumeration<RequestIntent> 5770 case -1165461084: 5771 /* priority */ return this.priority == null ? new Base[0] : new Base[] { this.priority }; // Enumeration<RequestPriority> 5772 case 3059181: 5773 /* code */ return this.code == null ? new Base[0] : new Base[] { this.code }; // CodeableConcept 5774 case -1867885268: 5775 /* subject */ return this.subject == null ? new Base[0] : new Base[] { this.subject }; // Reference 5776 case 1524132147: 5777 /* encounter */ return this.encounter == null ? new Base[0] : new Base[] { this.encounter }; // Reference 5778 case -1500852503: 5779 /* authoredOn */ return this.authoredOn == null ? new Base[0] : new Base[] { this.authoredOn }; // DateTimeType 5780 case -1406328437: 5781 /* author */ return this.author == null ? new Base[0] : new Base[] { this.author }; // Reference 5782 case 722137681: 5783 /* reasonCode */ return this.reasonCode == null ? new Base[0] 5784 : this.reasonCode.toArray(new Base[this.reasonCode.size()]); // CodeableConcept 5785 case -1146218137: 5786 /* reasonReference */ return this.reasonReference == null ? new Base[0] 5787 : this.reasonReference.toArray(new Base[this.reasonReference.size()]); // Reference 5788 case 3387378: 5789 /* note */ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation 5790 case -1422950858: 5791 /* action */ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // RequestGroupActionComponent 5792 default: 5793 return super.getProperty(hash, name, checkValid); 5794 } 5795 5796 } 5797 5798 @Override 5799 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5800 switch (hash) { 5801 case -1618432855: // identifier 5802 this.getIdentifier().add(castToIdentifier(value)); // Identifier 5803 return value; 5804 case 8911915: // instantiatesCanonical 5805 this.getInstantiatesCanonical().add(castToCanonical(value)); // CanonicalType 5806 return value; 5807 case -1926393373: // instantiatesUri 5808 this.getInstantiatesUri().add(castToUri(value)); // UriType 5809 return value; 5810 case -332612366: // basedOn 5811 this.getBasedOn().add(castToReference(value)); // Reference 5812 return value; 5813 case -430332865: // replaces 5814 this.getReplaces().add(castToReference(value)); // Reference 5815 return value; 5816 case -445338488: // groupIdentifier 5817 this.groupIdentifier = castToIdentifier(value); // Identifier 5818 return value; 5819 case -892481550: // status 5820 value = new RequestStatusEnumFactory().fromType(castToCode(value)); 5821 this.status = (Enumeration) value; // Enumeration<RequestStatus> 5822 return value; 5823 case -1183762788: // intent 5824 value = new RequestIntentEnumFactory().fromType(castToCode(value)); 5825 this.intent = (Enumeration) value; // Enumeration<RequestIntent> 5826 return value; 5827 case -1165461084: // priority 5828 value = new RequestPriorityEnumFactory().fromType(castToCode(value)); 5829 this.priority = (Enumeration) value; // Enumeration<RequestPriority> 5830 return value; 5831 case 3059181: // code 5832 this.code = castToCodeableConcept(value); // CodeableConcept 5833 return value; 5834 case -1867885268: // subject 5835 this.subject = castToReference(value); // Reference 5836 return value; 5837 case 1524132147: // encounter 5838 this.encounter = castToReference(value); // Reference 5839 return value; 5840 case -1500852503: // authoredOn 5841 this.authoredOn = castToDateTime(value); // DateTimeType 5842 return value; 5843 case -1406328437: // author 5844 this.author = castToReference(value); // Reference 5845 return value; 5846 case 722137681: // reasonCode 5847 this.getReasonCode().add(castToCodeableConcept(value)); // CodeableConcept 5848 return value; 5849 case -1146218137: // reasonReference 5850 this.getReasonReference().add(castToReference(value)); // Reference 5851 return value; 5852 case 3387378: // note 5853 this.getNote().add(castToAnnotation(value)); // Annotation 5854 return value; 5855 case -1422950858: // action 5856 this.getAction().add((RequestGroupActionComponent) value); // RequestGroupActionComponent 5857 return value; 5858 default: 5859 return super.setProperty(hash, name, value); 5860 } 5861 5862 } 5863 5864 @Override 5865 public Base setProperty(String name, Base value) throws FHIRException { 5866 if (name.equals("identifier")) { 5867 this.getIdentifier().add(castToIdentifier(value)); 5868 } else if (name.equals("instantiatesCanonical")) { 5869 this.getInstantiatesCanonical().add(castToCanonical(value)); 5870 } else if (name.equals("instantiatesUri")) { 5871 this.getInstantiatesUri().add(castToUri(value)); 5872 } else if (name.equals("basedOn")) { 5873 this.getBasedOn().add(castToReference(value)); 5874 } else if (name.equals("replaces")) { 5875 this.getReplaces().add(castToReference(value)); 5876 } else if (name.equals("groupIdentifier")) { 5877 this.groupIdentifier = castToIdentifier(value); // Identifier 5878 } else if (name.equals("status")) { 5879 value = new RequestStatusEnumFactory().fromType(castToCode(value)); 5880 this.status = (Enumeration) value; // Enumeration<RequestStatus> 5881 } else if (name.equals("intent")) { 5882 value = new RequestIntentEnumFactory().fromType(castToCode(value)); 5883 this.intent = (Enumeration) value; // Enumeration<RequestIntent> 5884 } else if (name.equals("priority")) { 5885 value = new RequestPriorityEnumFactory().fromType(castToCode(value)); 5886 this.priority = (Enumeration) value; // Enumeration<RequestPriority> 5887 } else if (name.equals("code")) { 5888 this.code = castToCodeableConcept(value); // CodeableConcept 5889 } else if (name.equals("subject")) { 5890 this.subject = castToReference(value); // Reference 5891 } else if (name.equals("encounter")) { 5892 this.encounter = castToReference(value); // Reference 5893 } else if (name.equals("authoredOn")) { 5894 this.authoredOn = castToDateTime(value); // DateTimeType 5895 } else if (name.equals("author")) { 5896 this.author = castToReference(value); // Reference 5897 } else if (name.equals("reasonCode")) { 5898 this.getReasonCode().add(castToCodeableConcept(value)); 5899 } else if (name.equals("reasonReference")) { 5900 this.getReasonReference().add(castToReference(value)); 5901 } else if (name.equals("note")) { 5902 this.getNote().add(castToAnnotation(value)); 5903 } else if (name.equals("action")) { 5904 this.getAction().add((RequestGroupActionComponent) value); 5905 } else 5906 return super.setProperty(name, value); 5907 return value; 5908 } 5909 5910 @Override 5911 public void removeChild(String name, Base value) throws FHIRException { 5912 if (name.equals("identifier")) { 5913 this.getIdentifier().remove(castToIdentifier(value)); 5914 } else if (name.equals("instantiatesCanonical")) { 5915 this.getInstantiatesCanonical().remove(castToCanonical(value)); 5916 } else if (name.equals("instantiatesUri")) { 5917 this.getInstantiatesUri().remove(castToUri(value)); 5918 } else if (name.equals("basedOn")) { 5919 this.getBasedOn().remove(castToReference(value)); 5920 } else if (name.equals("replaces")) { 5921 this.getReplaces().remove(castToReference(value)); 5922 } else if (name.equals("groupIdentifier")) { 5923 this.groupIdentifier = null; 5924 } else if (name.equals("status")) { 5925 this.status = null; 5926 } else if (name.equals("intent")) { 5927 this.intent = null; 5928 } else if (name.equals("priority")) { 5929 this.priority = null; 5930 } else if (name.equals("code")) { 5931 this.code = null; 5932 } else if (name.equals("subject")) { 5933 this.subject = null; 5934 } else if (name.equals("encounter")) { 5935 this.encounter = null; 5936 } else if (name.equals("authoredOn")) { 5937 this.authoredOn = null; 5938 } else if (name.equals("author")) { 5939 this.author = null; 5940 } else if (name.equals("reasonCode")) { 5941 this.getReasonCode().remove(castToCodeableConcept(value)); 5942 } else if (name.equals("reasonReference")) { 5943 this.getReasonReference().remove(castToReference(value)); 5944 } else if (name.equals("note")) { 5945 this.getNote().remove(castToAnnotation(value)); 5946 } else if (name.equals("action")) { 5947 this.getAction().remove((RequestGroupActionComponent) value); 5948 } else 5949 super.removeChild(name, value); 5950 5951 } 5952 5953 @Override 5954 public Base makeProperty(int hash, String name) throws FHIRException { 5955 switch (hash) { 5956 case -1618432855: 5957 return addIdentifier(); 5958 case 8911915: 5959 return addInstantiatesCanonicalElement(); 5960 case -1926393373: 5961 return addInstantiatesUriElement(); 5962 case -332612366: 5963 return addBasedOn(); 5964 case -430332865: 5965 return addReplaces(); 5966 case -445338488: 5967 return getGroupIdentifier(); 5968 case -892481550: 5969 return getStatusElement(); 5970 case -1183762788: 5971 return getIntentElement(); 5972 case -1165461084: 5973 return getPriorityElement(); 5974 case 3059181: 5975 return getCode(); 5976 case -1867885268: 5977 return getSubject(); 5978 case 1524132147: 5979 return getEncounter(); 5980 case -1500852503: 5981 return getAuthoredOnElement(); 5982 case -1406328437: 5983 return getAuthor(); 5984 case 722137681: 5985 return addReasonCode(); 5986 case -1146218137: 5987 return addReasonReference(); 5988 case 3387378: 5989 return addNote(); 5990 case -1422950858: 5991 return addAction(); 5992 default: 5993 return super.makeProperty(hash, name); 5994 } 5995 5996 } 5997 5998 @Override 5999 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6000 switch (hash) { 6001 case -1618432855: 6002 /* identifier */ return new String[] { "Identifier" }; 6003 case 8911915: 6004 /* instantiatesCanonical */ return new String[] { "canonical" }; 6005 case -1926393373: 6006 /* instantiatesUri */ return new String[] { "uri" }; 6007 case -332612366: 6008 /* basedOn */ return new String[] { "Reference" }; 6009 case -430332865: 6010 /* replaces */ return new String[] { "Reference" }; 6011 case -445338488: 6012 /* groupIdentifier */ return new String[] { "Identifier" }; 6013 case -892481550: 6014 /* status */ return new String[] { "code" }; 6015 case -1183762788: 6016 /* intent */ return new String[] { "code" }; 6017 case -1165461084: 6018 /* priority */ return new String[] { "code" }; 6019 case 3059181: 6020 /* code */ return new String[] { "CodeableConcept" }; 6021 case -1867885268: 6022 /* subject */ return new String[] { "Reference" }; 6023 case 1524132147: 6024 /* encounter */ return new String[] { "Reference" }; 6025 case -1500852503: 6026 /* authoredOn */ return new String[] { "dateTime" }; 6027 case -1406328437: 6028 /* author */ return new String[] { "Reference" }; 6029 case 722137681: 6030 /* reasonCode */ return new String[] { "CodeableConcept" }; 6031 case -1146218137: 6032 /* reasonReference */ return new String[] { "Reference" }; 6033 case 3387378: 6034 /* note */ return new String[] { "Annotation" }; 6035 case -1422950858: 6036 /* action */ return new String[] {}; 6037 default: 6038 return super.getTypesForProperty(hash, name); 6039 } 6040 6041 } 6042 6043 @Override 6044 public Base addChild(String name) throws FHIRException { 6045 if (name.equals("identifier")) { 6046 return addIdentifier(); 6047 } else if (name.equals("instantiatesCanonical")) { 6048 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.instantiatesCanonical"); 6049 } else if (name.equals("instantiatesUri")) { 6050 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.instantiatesUri"); 6051 } else if (name.equals("basedOn")) { 6052 return addBasedOn(); 6053 } else if (name.equals("replaces")) { 6054 return addReplaces(); 6055 } else if (name.equals("groupIdentifier")) { 6056 this.groupIdentifier = new Identifier(); 6057 return this.groupIdentifier; 6058 } else if (name.equals("status")) { 6059 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.status"); 6060 } else if (name.equals("intent")) { 6061 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.intent"); 6062 } else if (name.equals("priority")) { 6063 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.priority"); 6064 } else if (name.equals("code")) { 6065 this.code = new CodeableConcept(); 6066 return this.code; 6067 } else if (name.equals("subject")) { 6068 this.subject = new Reference(); 6069 return this.subject; 6070 } else if (name.equals("encounter")) { 6071 this.encounter = new Reference(); 6072 return this.encounter; 6073 } else if (name.equals("authoredOn")) { 6074 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.authoredOn"); 6075 } else if (name.equals("author")) { 6076 this.author = new Reference(); 6077 return this.author; 6078 } else if (name.equals("reasonCode")) { 6079 return addReasonCode(); 6080 } else if (name.equals("reasonReference")) { 6081 return addReasonReference(); 6082 } else if (name.equals("note")) { 6083 return addNote(); 6084 } else if (name.equals("action")) { 6085 return addAction(); 6086 } else 6087 return super.addChild(name); 6088 } 6089 6090 public String fhirType() { 6091 return "RequestGroup"; 6092 6093 } 6094 6095 public RequestGroup copy() { 6096 RequestGroup dst = new RequestGroup(); 6097 copyValues(dst); 6098 return dst; 6099 } 6100 6101 public void copyValues(RequestGroup dst) { 6102 super.copyValues(dst); 6103 if (identifier != null) { 6104 dst.identifier = new ArrayList<Identifier>(); 6105 for (Identifier i : identifier) 6106 dst.identifier.add(i.copy()); 6107 } 6108 ; 6109 if (instantiatesCanonical != null) { 6110 dst.instantiatesCanonical = new ArrayList<CanonicalType>(); 6111 for (CanonicalType i : instantiatesCanonical) 6112 dst.instantiatesCanonical.add(i.copy()); 6113 } 6114 ; 6115 if (instantiatesUri != null) { 6116 dst.instantiatesUri = new ArrayList<UriType>(); 6117 for (UriType i : instantiatesUri) 6118 dst.instantiatesUri.add(i.copy()); 6119 } 6120 ; 6121 if (basedOn != null) { 6122 dst.basedOn = new ArrayList<Reference>(); 6123 for (Reference i : basedOn) 6124 dst.basedOn.add(i.copy()); 6125 } 6126 ; 6127 if (replaces != null) { 6128 dst.replaces = new ArrayList<Reference>(); 6129 for (Reference i : replaces) 6130 dst.replaces.add(i.copy()); 6131 } 6132 ; 6133 dst.groupIdentifier = groupIdentifier == null ? null : groupIdentifier.copy(); 6134 dst.status = status == null ? null : status.copy(); 6135 dst.intent = intent == null ? null : intent.copy(); 6136 dst.priority = priority == null ? null : priority.copy(); 6137 dst.code = code == null ? null : code.copy(); 6138 dst.subject = subject == null ? null : subject.copy(); 6139 dst.encounter = encounter == null ? null : encounter.copy(); 6140 dst.authoredOn = authoredOn == null ? null : authoredOn.copy(); 6141 dst.author = author == null ? null : author.copy(); 6142 if (reasonCode != null) { 6143 dst.reasonCode = new ArrayList<CodeableConcept>(); 6144 for (CodeableConcept i : reasonCode) 6145 dst.reasonCode.add(i.copy()); 6146 } 6147 ; 6148 if (reasonReference != null) { 6149 dst.reasonReference = new ArrayList<Reference>(); 6150 for (Reference i : reasonReference) 6151 dst.reasonReference.add(i.copy()); 6152 } 6153 ; 6154 if (note != null) { 6155 dst.note = new ArrayList<Annotation>(); 6156 for (Annotation i : note) 6157 dst.note.add(i.copy()); 6158 } 6159 ; 6160 if (action != null) { 6161 dst.action = new ArrayList<RequestGroupActionComponent>(); 6162 for (RequestGroupActionComponent i : action) 6163 dst.action.add(i.copy()); 6164 } 6165 ; 6166 } 6167 6168 protected RequestGroup typedCopy() { 6169 return copy(); 6170 } 6171 6172 @Override 6173 public boolean equalsDeep(Base other_) { 6174 if (!super.equalsDeep(other_)) 6175 return false; 6176 if (!(other_ instanceof RequestGroup)) 6177 return false; 6178 RequestGroup o = (RequestGroup) other_; 6179 return compareDeep(identifier, o.identifier, true) 6180 && compareDeep(instantiatesCanonical, o.instantiatesCanonical, true) 6181 && compareDeep(instantiatesUri, o.instantiatesUri, true) && compareDeep(basedOn, o.basedOn, true) 6182 && compareDeep(replaces, o.replaces, true) && compareDeep(groupIdentifier, o.groupIdentifier, true) 6183 && compareDeep(status, o.status, true) && compareDeep(intent, o.intent, true) 6184 && compareDeep(priority, o.priority, true) && compareDeep(code, o.code, true) 6185 && compareDeep(subject, o.subject, true) && compareDeep(encounter, o.encounter, true) 6186 && compareDeep(authoredOn, o.authoredOn, true) && compareDeep(author, o.author, true) 6187 && compareDeep(reasonCode, o.reasonCode, true) && compareDeep(reasonReference, o.reasonReference, true) 6188 && compareDeep(note, o.note, true) && compareDeep(action, o.action, true); 6189 } 6190 6191 @Override 6192 public boolean equalsShallow(Base other_) { 6193 if (!super.equalsShallow(other_)) 6194 return false; 6195 if (!(other_ instanceof RequestGroup)) 6196 return false; 6197 RequestGroup o = (RequestGroup) other_; 6198 return compareValues(instantiatesCanonical, o.instantiatesCanonical, true) 6199 && compareValues(instantiatesUri, o.instantiatesUri, true) && compareValues(status, o.status, true) 6200 && compareValues(intent, o.intent, true) && compareValues(priority, o.priority, true) 6201 && compareValues(authoredOn, o.authoredOn, true); 6202 } 6203 6204 public boolean isEmpty() { 6205 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, instantiatesCanonical, instantiatesUri, 6206 basedOn, replaces, groupIdentifier, status, intent, priority, code, subject, encounter, authoredOn, author, 6207 reasonCode, reasonReference, note, action); 6208 } 6209 6210 @Override 6211 public ResourceType getResourceType() { 6212 return ResourceType.RequestGroup; 6213 } 6214 6215 /** 6216 * Search parameter: <b>authored</b> 6217 * <p> 6218 * Description: <b>The date the request group was authored</b><br> 6219 * Type: <b>date</b><br> 6220 * Path: <b>RequestGroup.authoredOn</b><br> 6221 * </p> 6222 */ 6223 @SearchParamDefinition(name = "authored", path = "RequestGroup.authoredOn", description = "The date the request group was authored", type = "date") 6224 public static final String SP_AUTHORED = "authored"; 6225 /** 6226 * <b>Fluent Client</b> search parameter constant for <b>authored</b> 6227 * <p> 6228 * Description: <b>The date the request group was authored</b><br> 6229 * Type: <b>date</b><br> 6230 * Path: <b>RequestGroup.authoredOn</b><br> 6231 * </p> 6232 */ 6233 public static final ca.uhn.fhir.rest.gclient.DateClientParam AUTHORED = new ca.uhn.fhir.rest.gclient.DateClientParam( 6234 SP_AUTHORED); 6235 6236 /** 6237 * Search parameter: <b>identifier</b> 6238 * <p> 6239 * Description: <b>External identifiers for the request group</b><br> 6240 * Type: <b>token</b><br> 6241 * Path: <b>RequestGroup.identifier</b><br> 6242 * </p> 6243 */ 6244 @SearchParamDefinition(name = "identifier", path = "RequestGroup.identifier", description = "External identifiers for the request group", type = "token") 6245 public static final String SP_IDENTIFIER = "identifier"; 6246 /** 6247 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 6248 * <p> 6249 * Description: <b>External identifiers for the request group</b><br> 6250 * Type: <b>token</b><br> 6251 * Path: <b>RequestGroup.identifier</b><br> 6252 * </p> 6253 */ 6254 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam( 6255 SP_IDENTIFIER); 6256 6257 /** 6258 * Search parameter: <b>code</b> 6259 * <p> 6260 * Description: <b>The code of the request group</b><br> 6261 * Type: <b>token</b><br> 6262 * Path: <b>RequestGroup.code</b><br> 6263 * </p> 6264 */ 6265 @SearchParamDefinition(name = "code", path = "RequestGroup.code", description = "The code of the request group", type = "token") 6266 public static final String SP_CODE = "code"; 6267 /** 6268 * <b>Fluent Client</b> search parameter constant for <b>code</b> 6269 * <p> 6270 * Description: <b>The code of the request group</b><br> 6271 * Type: <b>token</b><br> 6272 * Path: <b>RequestGroup.code</b><br> 6273 * </p> 6274 */ 6275 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam( 6276 SP_CODE); 6277 6278 /** 6279 * Search parameter: <b>subject</b> 6280 * <p> 6281 * Description: <b>The subject that the request group is about</b><br> 6282 * Type: <b>reference</b><br> 6283 * Path: <b>RequestGroup.subject</b><br> 6284 * </p> 6285 */ 6286 @SearchParamDefinition(name = "subject", path = "RequestGroup.subject", description = "The subject that the request group is about", type = "reference", providesMembershipIn = { 6287 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Patient") }, target = { Group.class, Patient.class }) 6288 public static final String SP_SUBJECT = "subject"; 6289 /** 6290 * <b>Fluent Client</b> search parameter constant for <b>subject</b> 6291 * <p> 6292 * Description: <b>The subject that the request group is about</b><br> 6293 * Type: <b>reference</b><br> 6294 * Path: <b>RequestGroup.subject</b><br> 6295 * </p> 6296 */ 6297 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 6298 SP_SUBJECT); 6299 6300 /** 6301 * Constant for fluent queries to be used to add include statements. Specifies 6302 * the path value of "<b>RequestGroup:subject</b>". 6303 */ 6304 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT = new ca.uhn.fhir.model.api.Include( 6305 "RequestGroup:subject").toLocked(); 6306 6307 /** 6308 * Search parameter: <b>author</b> 6309 * <p> 6310 * Description: <b>The author of the request group</b><br> 6311 * Type: <b>reference</b><br> 6312 * Path: <b>RequestGroup.author</b><br> 6313 * </p> 6314 */ 6315 @SearchParamDefinition(name = "author", path = "RequestGroup.author", description = "The author of the request group", type = "reference", providesMembershipIn = { 6316 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Device"), 6317 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Practitioner") }, target = { Device.class, 6318 Practitioner.class, PractitionerRole.class }) 6319 public static final String SP_AUTHOR = "author"; 6320 /** 6321 * <b>Fluent Client</b> search parameter constant for <b>author</b> 6322 * <p> 6323 * Description: <b>The author of the request group</b><br> 6324 * Type: <b>reference</b><br> 6325 * Path: <b>RequestGroup.author</b><br> 6326 * </p> 6327 */ 6328 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam AUTHOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 6329 SP_AUTHOR); 6330 6331 /** 6332 * Constant for fluent queries to be used to add include statements. Specifies 6333 * the path value of "<b>RequestGroup:author</b>". 6334 */ 6335 public static final ca.uhn.fhir.model.api.Include INCLUDE_AUTHOR = new ca.uhn.fhir.model.api.Include( 6336 "RequestGroup:author").toLocked(); 6337 6338 /** 6339 * Search parameter: <b>instantiates-canonical</b> 6340 * <p> 6341 * Description: <b>The FHIR-based definition from which the request group is 6342 * realized</b><br> 6343 * Type: <b>reference</b><br> 6344 * Path: <b>RequestGroup.instantiatesCanonical</b><br> 6345 * </p> 6346 */ 6347 @SearchParamDefinition(name = "instantiates-canonical", path = "RequestGroup.instantiatesCanonical", description = "The FHIR-based definition from which the request group is realized", type = "reference") 6348 public static final String SP_INSTANTIATES_CANONICAL = "instantiates-canonical"; 6349 /** 6350 * <b>Fluent Client</b> search parameter constant for 6351 * <b>instantiates-canonical</b> 6352 * <p> 6353 * Description: <b>The FHIR-based definition from which the request group is 6354 * realized</b><br> 6355 * Type: <b>reference</b><br> 6356 * Path: <b>RequestGroup.instantiatesCanonical</b><br> 6357 * </p> 6358 */ 6359 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam INSTANTIATES_CANONICAL = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 6360 SP_INSTANTIATES_CANONICAL); 6361 6362 /** 6363 * Constant for fluent queries to be used to add include statements. Specifies 6364 * the path value of "<b>RequestGroup:instantiates-canonical</b>". 6365 */ 6366 public static final ca.uhn.fhir.model.api.Include INCLUDE_INSTANTIATES_CANONICAL = new ca.uhn.fhir.model.api.Include( 6367 "RequestGroup:instantiates-canonical").toLocked(); 6368 6369 /** 6370 * Search parameter: <b>encounter</b> 6371 * <p> 6372 * Description: <b>The encounter the request group applies to</b><br> 6373 * Type: <b>reference</b><br> 6374 * Path: <b>RequestGroup.encounter</b><br> 6375 * </p> 6376 */ 6377 @SearchParamDefinition(name = "encounter", path = "RequestGroup.encounter", description = "The encounter the request group applies to", type = "reference", providesMembershipIn = { 6378 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Encounter") }, target = { Encounter.class }) 6379 public static final String SP_ENCOUNTER = "encounter"; 6380 /** 6381 * <b>Fluent Client</b> search parameter constant for <b>encounter</b> 6382 * <p> 6383 * Description: <b>The encounter the request group applies to</b><br> 6384 * Type: <b>reference</b><br> 6385 * Path: <b>RequestGroup.encounter</b><br> 6386 * </p> 6387 */ 6388 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ENCOUNTER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 6389 SP_ENCOUNTER); 6390 6391 /** 6392 * Constant for fluent queries to be used to add include statements. Specifies 6393 * the path value of "<b>RequestGroup:encounter</b>". 6394 */ 6395 public static final ca.uhn.fhir.model.api.Include INCLUDE_ENCOUNTER = new ca.uhn.fhir.model.api.Include( 6396 "RequestGroup:encounter").toLocked(); 6397 6398 /** 6399 * Search parameter: <b>priority</b> 6400 * <p> 6401 * Description: <b>The priority of the request group</b><br> 6402 * Type: <b>token</b><br> 6403 * Path: <b>RequestGroup.priority</b><br> 6404 * </p> 6405 */ 6406 @SearchParamDefinition(name = "priority", path = "RequestGroup.priority", description = "The priority of the request group", type = "token") 6407 public static final String SP_PRIORITY = "priority"; 6408 /** 6409 * <b>Fluent Client</b> search parameter constant for <b>priority</b> 6410 * <p> 6411 * Description: <b>The priority of the request group</b><br> 6412 * Type: <b>token</b><br> 6413 * Path: <b>RequestGroup.priority</b><br> 6414 * </p> 6415 */ 6416 public static final ca.uhn.fhir.rest.gclient.TokenClientParam PRIORITY = new ca.uhn.fhir.rest.gclient.TokenClientParam( 6417 SP_PRIORITY); 6418 6419 /** 6420 * Search parameter: <b>intent</b> 6421 * <p> 6422 * Description: <b>The intent of the request group</b><br> 6423 * Type: <b>token</b><br> 6424 * Path: <b>RequestGroup.intent</b><br> 6425 * </p> 6426 */ 6427 @SearchParamDefinition(name = "intent", path = "RequestGroup.intent", description = "The intent of the request group", type = "token") 6428 public static final String SP_INTENT = "intent"; 6429 /** 6430 * <b>Fluent Client</b> search parameter constant for <b>intent</b> 6431 * <p> 6432 * Description: <b>The intent of the request group</b><br> 6433 * Type: <b>token</b><br> 6434 * Path: <b>RequestGroup.intent</b><br> 6435 * </p> 6436 */ 6437 public static final ca.uhn.fhir.rest.gclient.TokenClientParam INTENT = new ca.uhn.fhir.rest.gclient.TokenClientParam( 6438 SP_INTENT); 6439 6440 /** 6441 * Search parameter: <b>participant</b> 6442 * <p> 6443 * Description: <b>The participant in the requests in the group</b><br> 6444 * Type: <b>reference</b><br> 6445 * Path: <b>RequestGroup.action.participant</b><br> 6446 * </p> 6447 */ 6448 @SearchParamDefinition(name = "participant", path = "RequestGroup.action.participant", description = "The participant in the requests in the group", type = "reference", providesMembershipIn = { 6449 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Patient"), 6450 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Practitioner"), 6451 @ca.uhn.fhir.model.api.annotation.Compartment(name = "RelatedPerson") }, target = { Device.class, Patient.class, 6452 Practitioner.class, PractitionerRole.class, RelatedPerson.class }) 6453 public static final String SP_PARTICIPANT = "participant"; 6454 /** 6455 * <b>Fluent Client</b> search parameter constant for <b>participant</b> 6456 * <p> 6457 * Description: <b>The participant in the requests in the group</b><br> 6458 * Type: <b>reference</b><br> 6459 * Path: <b>RequestGroup.action.participant</b><br> 6460 * </p> 6461 */ 6462 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PARTICIPANT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 6463 SP_PARTICIPANT); 6464 6465 /** 6466 * Constant for fluent queries to be used to add include statements. Specifies 6467 * the path value of "<b>RequestGroup:participant</b>". 6468 */ 6469 public static final ca.uhn.fhir.model.api.Include INCLUDE_PARTICIPANT = new ca.uhn.fhir.model.api.Include( 6470 "RequestGroup:participant").toLocked(); 6471 6472 /** 6473 * Search parameter: <b>group-identifier</b> 6474 * <p> 6475 * Description: <b>The group identifier for the request group</b><br> 6476 * Type: <b>token</b><br> 6477 * Path: <b>RequestGroup.groupIdentifier</b><br> 6478 * </p> 6479 */ 6480 @SearchParamDefinition(name = "group-identifier", path = "RequestGroup.groupIdentifier", description = "The group identifier for the request group", type = "token") 6481 public static final String SP_GROUP_IDENTIFIER = "group-identifier"; 6482 /** 6483 * <b>Fluent Client</b> search parameter constant for <b>group-identifier</b> 6484 * <p> 6485 * Description: <b>The group identifier for the request group</b><br> 6486 * Type: <b>token</b><br> 6487 * Path: <b>RequestGroup.groupIdentifier</b><br> 6488 * </p> 6489 */ 6490 public static final ca.uhn.fhir.rest.gclient.TokenClientParam GROUP_IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam( 6491 SP_GROUP_IDENTIFIER); 6492 6493 /** 6494 * Search parameter: <b>patient</b> 6495 * <p> 6496 * Description: <b>The identity of a patient to search for request 6497 * groups</b><br> 6498 * Type: <b>reference</b><br> 6499 * Path: <b>RequestGroup.subject</b><br> 6500 * </p> 6501 */ 6502 @SearchParamDefinition(name = "patient", path = "RequestGroup.subject.where(resolve() is Patient)", description = "The identity of a patient to search for request groups", type = "reference", target = { 6503 Patient.class }) 6504 public static final String SP_PATIENT = "patient"; 6505 /** 6506 * <b>Fluent Client</b> search parameter constant for <b>patient</b> 6507 * <p> 6508 * Description: <b>The identity of a patient to search for request 6509 * groups</b><br> 6510 * Type: <b>reference</b><br> 6511 * Path: <b>RequestGroup.subject</b><br> 6512 * </p> 6513 */ 6514 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 6515 SP_PATIENT); 6516 6517 /** 6518 * Constant for fluent queries to be used to add include statements. Specifies 6519 * the path value of "<b>RequestGroup:patient</b>". 6520 */ 6521 public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include( 6522 "RequestGroup:patient").toLocked(); 6523 6524 /** 6525 * Search parameter: <b>instantiates-uri</b> 6526 * <p> 6527 * Description: <b>The external definition from which the request group is 6528 * realized</b><br> 6529 * Type: <b>uri</b><br> 6530 * Path: <b>RequestGroup.instantiatesUri</b><br> 6531 * </p> 6532 */ 6533 @SearchParamDefinition(name = "instantiates-uri", path = "RequestGroup.instantiatesUri", description = "The external definition from which the request group is realized", type = "uri") 6534 public static final String SP_INSTANTIATES_URI = "instantiates-uri"; 6535 /** 6536 * <b>Fluent Client</b> search parameter constant for <b>instantiates-uri</b> 6537 * <p> 6538 * Description: <b>The external definition from which the request group is 6539 * realized</b><br> 6540 * Type: <b>uri</b><br> 6541 * Path: <b>RequestGroup.instantiatesUri</b><br> 6542 * </p> 6543 */ 6544 public static final ca.uhn.fhir.rest.gclient.UriClientParam INSTANTIATES_URI = new ca.uhn.fhir.rest.gclient.UriClientParam( 6545 SP_INSTANTIATES_URI); 6546 6547 /** 6548 * Search parameter: <b>status</b> 6549 * <p> 6550 * Description: <b>The status of the request group</b><br> 6551 * Type: <b>token</b><br> 6552 * Path: <b>RequestGroup.status</b><br> 6553 * </p> 6554 */ 6555 @SearchParamDefinition(name = "status", path = "RequestGroup.status", description = "The status of the request group", type = "token") 6556 public static final String SP_STATUS = "status"; 6557 /** 6558 * <b>Fluent Client</b> search parameter constant for <b>status</b> 6559 * <p> 6560 * Description: <b>The status of the request group</b><br> 6561 * Type: <b>token</b><br> 6562 * Path: <b>RequestGroup.status</b><br> 6563 * </p> 6564 */ 6565 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam( 6566 SP_STATUS); 6567 6568}