001package org.hl7.fhir.dstu3.model; 002 003 004 005 006/* 007 Copyright (c) 2011+, HL7, Inc. 008 All rights reserved. 009 010 Redistribution and use in source and binary forms, with or without modification, 011 are permitted provided that the following conditions are met: 012 013 * Redistributions of source code must retain the above copyright notice, this 014 list of conditions and the following disclaimer. 015 * Redistributions in binary form must reproduce the above copyright notice, 016 this list of conditions and the following disclaimer in the documentation 017 and/or other materials provided with the distribution. 018 * Neither the name of HL7 nor the names of its contributors may be used to 019 endorse or promote products derived from this software without specific 020 prior written permission. 021 022 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 023 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 024 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 025 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 026 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 027 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 028 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 029 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 030 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 031 POSSIBILITY OF SUCH DAMAGE. 032 033*/ 034 035// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x 036import java.util.ArrayList; 037import java.util.Date; 038import java.util.List; 039 040import org.hl7.fhir.exceptions.FHIRException; 041import org.hl7.fhir.exceptions.FHIRFormatError; 042import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 043import org.hl7.fhir.utilities.Utilities; 044 045import ca.uhn.fhir.model.api.annotation.Block; 046import ca.uhn.fhir.model.api.annotation.Child; 047import ca.uhn.fhir.model.api.annotation.Description; 048import ca.uhn.fhir.model.api.annotation.ResourceDef; 049import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 050/** 051 * A group of related requests that can be used to capture intended activities that have inter-dependencies such as "give this medication after that one". 052 */ 053@ResourceDef(name="RequestGroup", profile="http://hl7.org/fhir/Profile/RequestGroup") 054public class RequestGroup extends DomainResource { 055 056 public enum RequestStatus { 057 /** 058 * The request has been created but is not yet complete or ready for action 059 */ 060 DRAFT, 061 /** 062 * The request is ready to be acted upon 063 */ 064 ACTIVE, 065 /** 066 * The authorization/request to act has been temporarily withdrawn but is expected to resume in the future 067 */ 068 SUSPENDED, 069 /** 070 * The authorization/request to act has been terminated prior to the full completion of the intended actions. No further activity should occur. 071 */ 072 CANCELLED, 073 /** 074 * Activity against the request has been sufficiently completed to the satisfaction of the requester 075 */ 076 COMPLETED, 077 /** 078 * This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be "cancelled" rather than "entered-in-error".) 079 */ 080 ENTEREDINERROR, 081 /** 082 * The authoring 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 system creating the request doesn't know. 083 */ 084 UNKNOWN, 085 /** 086 * added to help the parsers with the generic types 087 */ 088 NULL; 089 public static RequestStatus fromCode(String codeString) throws FHIRException { 090 if (codeString == null || "".equals(codeString)) 091 return null; 092 if ("draft".equals(codeString)) 093 return DRAFT; 094 if ("active".equals(codeString)) 095 return ACTIVE; 096 if ("suspended".equals(codeString)) 097 return SUSPENDED; 098 if ("cancelled".equals(codeString)) 099 return CANCELLED; 100 if ("completed".equals(codeString)) 101 return COMPLETED; 102 if ("entered-in-error".equals(codeString)) 103 return ENTEREDINERROR; 104 if ("unknown".equals(codeString)) 105 return UNKNOWN; 106 if (Configuration.isAcceptInvalidEnums()) 107 return null; 108 else 109 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 110 } 111 public String toCode() { 112 switch (this) { 113 case DRAFT: return "draft"; 114 case ACTIVE: return "active"; 115 case SUSPENDED: return "suspended"; 116 case CANCELLED: return "cancelled"; 117 case COMPLETED: return "completed"; 118 case ENTEREDINERROR: return "entered-in-error"; 119 case UNKNOWN: return "unknown"; 120 case NULL: return null; 121 default: return "?"; 122 } 123 } 124 public String getSystem() { 125 switch (this) { 126 case DRAFT: return "http://hl7.org/fhir/request-status"; 127 case ACTIVE: return "http://hl7.org/fhir/request-status"; 128 case SUSPENDED: return "http://hl7.org/fhir/request-status"; 129 case CANCELLED: return "http://hl7.org/fhir/request-status"; 130 case COMPLETED: return "http://hl7.org/fhir/request-status"; 131 case ENTEREDINERROR: return "http://hl7.org/fhir/request-status"; 132 case UNKNOWN: return "http://hl7.org/fhir/request-status"; 133 case NULL: return null; 134 default: return "?"; 135 } 136 } 137 public String getDefinition() { 138 switch (this) { 139 case DRAFT: return "The request has been created but is not yet complete or ready for action"; 140 case ACTIVE: return "The request is ready to be acted upon"; 141 case SUSPENDED: return "The authorization/request to act has been temporarily withdrawn but is expected to resume in the future"; 142 case CANCELLED: return "The authorization/request to act has been terminated prior to the full completion of the intended actions. No further activity should occur."; 143 case COMPLETED: return "Activity against the request has been sufficiently completed to the satisfaction of the requester"; 144 case ENTEREDINERROR: return "This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be \"cancelled\" rather than \"entered-in-error\".)"; 145 case UNKNOWN: return "The authoring 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 system creating the request doesn't know."; 146 case NULL: return null; 147 default: return "?"; 148 } 149 } 150 public String getDisplay() { 151 switch (this) { 152 case DRAFT: return "Draft"; 153 case ACTIVE: return "Active"; 154 case SUSPENDED: return "Suspended"; 155 case CANCELLED: return "Cancelled"; 156 case COMPLETED: return "Completed"; 157 case ENTEREDINERROR: return "Entered in Error"; 158 case UNKNOWN: return "Unknown"; 159 case NULL: return null; 160 default: return "?"; 161 } 162 } 163 } 164 165 public static class RequestStatusEnumFactory implements EnumFactory<RequestStatus> { 166 public RequestStatus fromCode(String codeString) throws IllegalArgumentException { 167 if (codeString == null || "".equals(codeString)) 168 if (codeString == null || "".equals(codeString)) 169 return null; 170 if ("draft".equals(codeString)) 171 return RequestStatus.DRAFT; 172 if ("active".equals(codeString)) 173 return RequestStatus.ACTIVE; 174 if ("suspended".equals(codeString)) 175 return RequestStatus.SUSPENDED; 176 if ("cancelled".equals(codeString)) 177 return RequestStatus.CANCELLED; 178 if ("completed".equals(codeString)) 179 return RequestStatus.COMPLETED; 180 if ("entered-in-error".equals(codeString)) 181 return RequestStatus.ENTEREDINERROR; 182 if ("unknown".equals(codeString)) 183 return RequestStatus.UNKNOWN; 184 throw new IllegalArgumentException("Unknown RequestStatus code '"+codeString+"'"); 185 } 186 public Enumeration<RequestStatus> fromType(PrimitiveType<?> code) throws FHIRException { 187 if (code == null) 188 return null; 189 if (code.isEmpty()) 190 return new Enumeration<RequestStatus>(this); 191 String codeString = code.asStringValue(); 192 if (codeString == null || "".equals(codeString)) 193 return null; 194 if ("draft".equals(codeString)) 195 return new Enumeration<RequestStatus>(this, RequestStatus.DRAFT); 196 if ("active".equals(codeString)) 197 return new Enumeration<RequestStatus>(this, RequestStatus.ACTIVE); 198 if ("suspended".equals(codeString)) 199 return new Enumeration<RequestStatus>(this, RequestStatus.SUSPENDED); 200 if ("cancelled".equals(codeString)) 201 return new Enumeration<RequestStatus>(this, RequestStatus.CANCELLED); 202 if ("completed".equals(codeString)) 203 return new Enumeration<RequestStatus>(this, RequestStatus.COMPLETED); 204 if ("entered-in-error".equals(codeString)) 205 return new Enumeration<RequestStatus>(this, RequestStatus.ENTEREDINERROR); 206 if ("unknown".equals(codeString)) 207 return new Enumeration<RequestStatus>(this, RequestStatus.UNKNOWN); 208 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 209 } 210 public String toCode(RequestStatus code) { 211 if (code == RequestStatus.DRAFT) 212 return "draft"; 213 if (code == RequestStatus.ACTIVE) 214 return "active"; 215 if (code == RequestStatus.SUSPENDED) 216 return "suspended"; 217 if (code == RequestStatus.CANCELLED) 218 return "cancelled"; 219 if (code == RequestStatus.COMPLETED) 220 return "completed"; 221 if (code == RequestStatus.ENTEREDINERROR) 222 return "entered-in-error"; 223 if (code == RequestStatus.UNKNOWN) 224 return "unknown"; 225 return "?"; 226 } 227 public String toSystem(RequestStatus code) { 228 return code.getSystem(); 229 } 230 } 231 232 public enum RequestIntent { 233 /** 234 * The request is a suggestion made by someone/something that doesn't have an intention to ensure it occurs and without providing an authorization to act 235 */ 236 PROPOSAL, 237 /** 238 * The request represents an intension to ensure something occurs without providing an authorization for others to act 239 */ 240 PLAN, 241 /** 242 * The request represents a request/demand and authorization for action 243 */ 244 ORDER, 245 /** 246 * The request represents an original authorization for action 247 */ 248 ORIGINALORDER, 249 /** 250 * 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 251 */ 252 REFLEXORDER, 253 /** 254 * 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 255 */ 256 FILLERORDER, 257 /** 258 * 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. 259 */ 260 INSTANCEORDER, 261 /** 262 * The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests. 263 264Refer to [[[RequestGroup]]] for additional information on how this status is used 265 */ 266 OPTION, 267 /** 268 * added to help the parsers with the generic types 269 */ 270 NULL; 271 public static RequestIntent fromCode(String codeString) throws FHIRException { 272 if (codeString == null || "".equals(codeString)) 273 return null; 274 if ("proposal".equals(codeString)) 275 return PROPOSAL; 276 if ("plan".equals(codeString)) 277 return PLAN; 278 if ("order".equals(codeString)) 279 return ORDER; 280 if ("original-order".equals(codeString)) 281 return ORIGINALORDER; 282 if ("reflex-order".equals(codeString)) 283 return REFLEXORDER; 284 if ("filler-order".equals(codeString)) 285 return FILLERORDER; 286 if ("instance-order".equals(codeString)) 287 return INSTANCEORDER; 288 if ("option".equals(codeString)) 289 return OPTION; 290 if (Configuration.isAcceptInvalidEnums()) 291 return null; 292 else 293 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 294 } 295 public String toCode() { 296 switch (this) { 297 case PROPOSAL: return "proposal"; 298 case PLAN: return "plan"; 299 case ORDER: return "order"; 300 case ORIGINALORDER: return "original-order"; 301 case REFLEXORDER: return "reflex-order"; 302 case FILLERORDER: return "filler-order"; 303 case INSTANCEORDER: return "instance-order"; 304 case OPTION: return "option"; 305 case NULL: return null; 306 default: return "?"; 307 } 308 } 309 public String getSystem() { 310 switch (this) { 311 case PROPOSAL: return "http://hl7.org/fhir/request-intent"; 312 case PLAN: return "http://hl7.org/fhir/request-intent"; 313 case ORDER: return "http://hl7.org/fhir/request-intent"; 314 case ORIGINALORDER: return "http://hl7.org/fhir/request-intent"; 315 case REFLEXORDER: return "http://hl7.org/fhir/request-intent"; 316 case FILLERORDER: return "http://hl7.org/fhir/request-intent"; 317 case INSTANCEORDER: return "http://hl7.org/fhir/request-intent"; 318 case OPTION: return "http://hl7.org/fhir/request-intent"; 319 case NULL: return null; 320 default: return "?"; 321 } 322 } 323 public String getDefinition() { 324 switch (this) { 325 case PROPOSAL: return "The request is a suggestion made by someone/something that doesn't have an intention to ensure it occurs and without providing an authorization to act"; 326 case PLAN: return "The request represents an intension to ensure something occurs without providing an authorization for others to act"; 327 case ORDER: return "The request represents a request/demand and authorization for action"; 328 case ORIGINALORDER: return "The request represents an original authorization for action"; 329 case REFLEXORDER: 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"; 330 case FILLERORDER: 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"; 331 case INSTANCEORDER: 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."; 332 case OPTION: return "The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests.\n\nRefer to [[[RequestGroup]]] for additional information on how this status is used"; 333 case NULL: return null; 334 default: return "?"; 335 } 336 } 337 public String getDisplay() { 338 switch (this) { 339 case PROPOSAL: return "Proposal"; 340 case PLAN: return "Plan"; 341 case ORDER: return "Order"; 342 case ORIGINALORDER: return "Original Order"; 343 case REFLEXORDER: return "Reflex Order"; 344 case FILLERORDER: return "Filler Order"; 345 case INSTANCEORDER: return "Instance Order"; 346 case OPTION: return "Option"; 347 case NULL: return null; 348 default: return "?"; 349 } 350 } 351 } 352 353 public static class RequestIntentEnumFactory implements EnumFactory<RequestIntent> { 354 public RequestIntent fromCode(String codeString) throws IllegalArgumentException { 355 if (codeString == null || "".equals(codeString)) 356 if (codeString == null || "".equals(codeString)) 357 return null; 358 if ("proposal".equals(codeString)) 359 return RequestIntent.PROPOSAL; 360 if ("plan".equals(codeString)) 361 return RequestIntent.PLAN; 362 if ("order".equals(codeString)) 363 return RequestIntent.ORDER; 364 if ("original-order".equals(codeString)) 365 return RequestIntent.ORIGINALORDER; 366 if ("reflex-order".equals(codeString)) 367 return RequestIntent.REFLEXORDER; 368 if ("filler-order".equals(codeString)) 369 return RequestIntent.FILLERORDER; 370 if ("instance-order".equals(codeString)) 371 return RequestIntent.INSTANCEORDER; 372 if ("option".equals(codeString)) 373 return RequestIntent.OPTION; 374 throw new IllegalArgumentException("Unknown RequestIntent code '"+codeString+"'"); 375 } 376 public Enumeration<RequestIntent> fromType(PrimitiveType<?> code) throws FHIRException { 377 if (code == null) 378 return null; 379 if (code.isEmpty()) 380 return new Enumeration<RequestIntent>(this); 381 String codeString = code.asStringValue(); 382 if (codeString == null || "".equals(codeString)) 383 return null; 384 if ("proposal".equals(codeString)) 385 return new Enumeration<RequestIntent>(this, RequestIntent.PROPOSAL); 386 if ("plan".equals(codeString)) 387 return new Enumeration<RequestIntent>(this, RequestIntent.PLAN); 388 if ("order".equals(codeString)) 389 return new Enumeration<RequestIntent>(this, RequestIntent.ORDER); 390 if ("original-order".equals(codeString)) 391 return new Enumeration<RequestIntent>(this, RequestIntent.ORIGINALORDER); 392 if ("reflex-order".equals(codeString)) 393 return new Enumeration<RequestIntent>(this, RequestIntent.REFLEXORDER); 394 if ("filler-order".equals(codeString)) 395 return new Enumeration<RequestIntent>(this, RequestIntent.FILLERORDER); 396 if ("instance-order".equals(codeString)) 397 return new Enumeration<RequestIntent>(this, RequestIntent.INSTANCEORDER); 398 if ("option".equals(codeString)) 399 return new Enumeration<RequestIntent>(this, RequestIntent.OPTION); 400 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 401 } 402 public String toCode(RequestIntent code) { 403 if (code == RequestIntent.PROPOSAL) 404 return "proposal"; 405 if (code == RequestIntent.PLAN) 406 return "plan"; 407 if (code == RequestIntent.ORDER) 408 return "order"; 409 if (code == RequestIntent.ORIGINALORDER) 410 return "original-order"; 411 if (code == RequestIntent.REFLEXORDER) 412 return "reflex-order"; 413 if (code == RequestIntent.FILLERORDER) 414 return "filler-order"; 415 if (code == RequestIntent.INSTANCEORDER) 416 return "instance-order"; 417 if (code == RequestIntent.OPTION) 418 return "option"; 419 return "?"; 420 } 421 public String toSystem(RequestIntent code) { 422 return code.getSystem(); 423 } 424 } 425 426 public enum RequestPriority { 427 /** 428 * The request has normal priority 429 */ 430 ROUTINE, 431 /** 432 * The request should be actioned promptly - higher priority than routine 433 */ 434 URGENT, 435 /** 436 * The request should be actioned as soon as possible - higher priority than urgent 437 */ 438 ASAP, 439 /** 440 * The request should be actioned immediately - highest possible priority. E.g. an emergency 441 */ 442 STAT, 443 /** 444 * added to help the parsers with the generic types 445 */ 446 NULL; 447 public static RequestPriority fromCode(String codeString) throws FHIRException { 448 if (codeString == null || "".equals(codeString)) 449 return null; 450 if ("routine".equals(codeString)) 451 return ROUTINE; 452 if ("urgent".equals(codeString)) 453 return URGENT; 454 if ("asap".equals(codeString)) 455 return ASAP; 456 if ("stat".equals(codeString)) 457 return STAT; 458 if (Configuration.isAcceptInvalidEnums()) 459 return null; 460 else 461 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 462 } 463 public String toCode() { 464 switch (this) { 465 case ROUTINE: return "routine"; 466 case URGENT: return "urgent"; 467 case ASAP: return "asap"; 468 case STAT: return "stat"; 469 case NULL: return null; 470 default: return "?"; 471 } 472 } 473 public String getSystem() { 474 switch (this) { 475 case ROUTINE: return "http://hl7.org/fhir/request-priority"; 476 case URGENT: return "http://hl7.org/fhir/request-priority"; 477 case ASAP: return "http://hl7.org/fhir/request-priority"; 478 case STAT: return "http://hl7.org/fhir/request-priority"; 479 case NULL: return null; 480 default: return "?"; 481 } 482 } 483 public String getDefinition() { 484 switch (this) { 485 case ROUTINE: return "The request has normal priority"; 486 case URGENT: return "The request should be actioned promptly - higher priority than routine"; 487 case ASAP: return "The request should be actioned as soon as possible - higher priority than urgent"; 488 case STAT: return "The request should be actioned immediately - highest possible priority. E.g. an emergency"; 489 case NULL: return null; 490 default: return "?"; 491 } 492 } 493 public String getDisplay() { 494 switch (this) { 495 case ROUTINE: return "Routine"; 496 case URGENT: return "Urgent"; 497 case ASAP: return "ASAP"; 498 case STAT: return "STAT"; 499 case NULL: return null; 500 default: return "?"; 501 } 502 } 503 } 504 505 public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> { 506 public RequestPriority fromCode(String codeString) throws IllegalArgumentException { 507 if (codeString == null || "".equals(codeString)) 508 if (codeString == null || "".equals(codeString)) 509 return null; 510 if ("routine".equals(codeString)) 511 return RequestPriority.ROUTINE; 512 if ("urgent".equals(codeString)) 513 return RequestPriority.URGENT; 514 if ("asap".equals(codeString)) 515 return RequestPriority.ASAP; 516 if ("stat".equals(codeString)) 517 return RequestPriority.STAT; 518 throw new IllegalArgumentException("Unknown RequestPriority code '"+codeString+"'"); 519 } 520 public Enumeration<RequestPriority> fromType(PrimitiveType<?> code) throws FHIRException { 521 if (code == null) 522 return null; 523 if (code.isEmpty()) 524 return new Enumeration<RequestPriority>(this); 525 String codeString = code.asStringValue(); 526 if (codeString == null || "".equals(codeString)) 527 return null; 528 if ("routine".equals(codeString)) 529 return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE); 530 if ("urgent".equals(codeString)) 531 return new Enumeration<RequestPriority>(this, RequestPriority.URGENT); 532 if ("asap".equals(codeString)) 533 return new Enumeration<RequestPriority>(this, RequestPriority.ASAP); 534 if ("stat".equals(codeString)) 535 return new Enumeration<RequestPriority>(this, RequestPriority.STAT); 536 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 537 } 538 public String toCode(RequestPriority code) { 539 if (code == RequestPriority.ROUTINE) 540 return "routine"; 541 if (code == RequestPriority.URGENT) 542 return "urgent"; 543 if (code == RequestPriority.ASAP) 544 return "asap"; 545 if (code == RequestPriority.STAT) 546 return "stat"; 547 return "?"; 548 } 549 public String toSystem(RequestPriority code) { 550 return code.getSystem(); 551 } 552 } 553 554 public enum ActionConditionKind { 555 /** 556 * The condition describes whether or not a given action is applicable 557 */ 558 APPLICABILITY, 559 /** 560 * The condition is a starting condition for the action 561 */ 562 START, 563 /** 564 * The condition is a stop, or exit condition for the action 565 */ 566 STOP, 567 /** 568 * added to help the parsers with the generic types 569 */ 570 NULL; 571 public static ActionConditionKind fromCode(String codeString) throws FHIRException { 572 if (codeString == null || "".equals(codeString)) 573 return null; 574 if ("applicability".equals(codeString)) 575 return APPLICABILITY; 576 if ("start".equals(codeString)) 577 return START; 578 if ("stop".equals(codeString)) 579 return STOP; 580 if (Configuration.isAcceptInvalidEnums()) 581 return null; 582 else 583 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 584 } 585 public String toCode() { 586 switch (this) { 587 case APPLICABILITY: return "applicability"; 588 case START: return "start"; 589 case STOP: return "stop"; 590 case NULL: return null; 591 default: return "?"; 592 } 593 } 594 public String getSystem() { 595 switch (this) { 596 case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind"; 597 case START: return "http://hl7.org/fhir/action-condition-kind"; 598 case STOP: return "http://hl7.org/fhir/action-condition-kind"; 599 case NULL: return null; 600 default: return "?"; 601 } 602 } 603 public String getDefinition() { 604 switch (this) { 605 case APPLICABILITY: return "The condition describes whether or not a given action is applicable"; 606 case START: return "The condition is a starting condition for the action"; 607 case STOP: return "The condition is a stop, or exit condition for the action"; 608 case NULL: return null; 609 default: return "?"; 610 } 611 } 612 public String getDisplay() { 613 switch (this) { 614 case APPLICABILITY: return "Applicability"; 615 case START: return "Start"; 616 case STOP: return "Stop"; 617 case NULL: return null; 618 default: return "?"; 619 } 620 } 621 } 622 623 public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> { 624 public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException { 625 if (codeString == null || "".equals(codeString)) 626 if (codeString == null || "".equals(codeString)) 627 return null; 628 if ("applicability".equals(codeString)) 629 return ActionConditionKind.APPLICABILITY; 630 if ("start".equals(codeString)) 631 return ActionConditionKind.START; 632 if ("stop".equals(codeString)) 633 return ActionConditionKind.STOP; 634 throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'"); 635 } 636 public Enumeration<ActionConditionKind> fromType(PrimitiveType<?> code) throws FHIRException { 637 if (code == null) 638 return null; 639 if (code.isEmpty()) 640 return new Enumeration<ActionConditionKind>(this); 641 String codeString = code.asStringValue(); 642 if (codeString == null || "".equals(codeString)) 643 return null; 644 if ("applicability".equals(codeString)) 645 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY); 646 if ("start".equals(codeString)) 647 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START); 648 if ("stop".equals(codeString)) 649 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP); 650 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 651 } 652 public String toCode(ActionConditionKind code) { 653 if (code == ActionConditionKind.APPLICABILITY) 654 return "applicability"; 655 if (code == ActionConditionKind.START) 656 return "start"; 657 if (code == ActionConditionKind.STOP) 658 return "stop"; 659 return "?"; 660 } 661 public String toSystem(ActionConditionKind code) { 662 return code.getSystem(); 663 } 664 } 665 666 public enum ActionRelationshipType { 667 /** 668 * The action must be performed before the start of the related action 669 */ 670 BEFORESTART, 671 /** 672 * The action must be performed before the related action 673 */ 674 BEFORE, 675 /** 676 * The action must be performed before the end of the related action 677 */ 678 BEFOREEND, 679 /** 680 * The action must be performed concurrent with the start of the related action 681 */ 682 CONCURRENTWITHSTART, 683 /** 684 * The action must be performed concurrent with the related action 685 */ 686 CONCURRENT, 687 /** 688 * The action must be performed concurrent with the end of the related action 689 */ 690 CONCURRENTWITHEND, 691 /** 692 * The action must be performed after the start of the related action 693 */ 694 AFTERSTART, 695 /** 696 * The action must be performed after the related action 697 */ 698 AFTER, 699 /** 700 * The action must be performed after the end of the related action 701 */ 702 AFTEREND, 703 /** 704 * added to help the parsers with the generic types 705 */ 706 NULL; 707 public static ActionRelationshipType fromCode(String codeString) throws FHIRException { 708 if (codeString == null || "".equals(codeString)) 709 return null; 710 if ("before-start".equals(codeString)) 711 return BEFORESTART; 712 if ("before".equals(codeString)) 713 return BEFORE; 714 if ("before-end".equals(codeString)) 715 return BEFOREEND; 716 if ("concurrent-with-start".equals(codeString)) 717 return CONCURRENTWITHSTART; 718 if ("concurrent".equals(codeString)) 719 return CONCURRENT; 720 if ("concurrent-with-end".equals(codeString)) 721 return CONCURRENTWITHEND; 722 if ("after-start".equals(codeString)) 723 return AFTERSTART; 724 if ("after".equals(codeString)) 725 return AFTER; 726 if ("after-end".equals(codeString)) 727 return AFTEREND; 728 if (Configuration.isAcceptInvalidEnums()) 729 return null; 730 else 731 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 732 } 733 public String toCode() { 734 switch (this) { 735 case BEFORESTART: return "before-start"; 736 case BEFORE: return "before"; 737 case BEFOREEND: return "before-end"; 738 case CONCURRENTWITHSTART: return "concurrent-with-start"; 739 case CONCURRENT: return "concurrent"; 740 case CONCURRENTWITHEND: return "concurrent-with-end"; 741 case AFTERSTART: return "after-start"; 742 case AFTER: return "after"; 743 case AFTEREND: return "after-end"; 744 case NULL: return null; 745 default: return "?"; 746 } 747 } 748 public String getSystem() { 749 switch (this) { 750 case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type"; 751 case BEFORE: return "http://hl7.org/fhir/action-relationship-type"; 752 case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type"; 753 case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type"; 754 case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type"; 755 case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type"; 756 case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type"; 757 case AFTER: return "http://hl7.org/fhir/action-relationship-type"; 758 case AFTEREND: return "http://hl7.org/fhir/action-relationship-type"; 759 case NULL: return null; 760 default: return "?"; 761 } 762 } 763 public String getDefinition() { 764 switch (this) { 765 case BEFORESTART: return "The action must be performed before the start of the related action"; 766 case BEFORE: return "The action must be performed before the related action"; 767 case BEFOREEND: return "The action must be performed before the end of the related action"; 768 case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action"; 769 case CONCURRENT: return "The action must be performed concurrent with the related action"; 770 case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action"; 771 case AFTERSTART: return "The action must be performed after the start of the related action"; 772 case AFTER: return "The action must be performed after the related action"; 773 case AFTEREND: return "The action must be performed after the end of the related action"; 774 case NULL: return null; 775 default: return "?"; 776 } 777 } 778 public String getDisplay() { 779 switch (this) { 780 case BEFORESTART: return "Before Start"; 781 case BEFORE: return "Before"; 782 case BEFOREEND: return "Before End"; 783 case CONCURRENTWITHSTART: return "Concurrent With Start"; 784 case CONCURRENT: return "Concurrent"; 785 case CONCURRENTWITHEND: return "Concurrent With End"; 786 case AFTERSTART: return "After Start"; 787 case AFTER: return "After"; 788 case AFTEREND: return "After End"; 789 case NULL: return null; 790 default: return "?"; 791 } 792 } 793 } 794 795 public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> { 796 public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException { 797 if (codeString == null || "".equals(codeString)) 798 if (codeString == null || "".equals(codeString)) 799 return null; 800 if ("before-start".equals(codeString)) 801 return ActionRelationshipType.BEFORESTART; 802 if ("before".equals(codeString)) 803 return ActionRelationshipType.BEFORE; 804 if ("before-end".equals(codeString)) 805 return ActionRelationshipType.BEFOREEND; 806 if ("concurrent-with-start".equals(codeString)) 807 return ActionRelationshipType.CONCURRENTWITHSTART; 808 if ("concurrent".equals(codeString)) 809 return ActionRelationshipType.CONCURRENT; 810 if ("concurrent-with-end".equals(codeString)) 811 return ActionRelationshipType.CONCURRENTWITHEND; 812 if ("after-start".equals(codeString)) 813 return ActionRelationshipType.AFTERSTART; 814 if ("after".equals(codeString)) 815 return ActionRelationshipType.AFTER; 816 if ("after-end".equals(codeString)) 817 return ActionRelationshipType.AFTEREND; 818 throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'"); 819 } 820 public Enumeration<ActionRelationshipType> fromType(PrimitiveType<?> code) throws FHIRException { 821 if (code == null) 822 return null; 823 if (code.isEmpty()) 824 return new Enumeration<ActionRelationshipType>(this); 825 String codeString = code.asStringValue(); 826 if (codeString == null || "".equals(codeString)) 827 return null; 828 if ("before-start".equals(codeString)) 829 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART); 830 if ("before".equals(codeString)) 831 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE); 832 if ("before-end".equals(codeString)) 833 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND); 834 if ("concurrent-with-start".equals(codeString)) 835 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART); 836 if ("concurrent".equals(codeString)) 837 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT); 838 if ("concurrent-with-end".equals(codeString)) 839 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND); 840 if ("after-start".equals(codeString)) 841 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART); 842 if ("after".equals(codeString)) 843 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER); 844 if ("after-end".equals(codeString)) 845 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND); 846 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 847 } 848 public String toCode(ActionRelationshipType code) { 849 if (code == ActionRelationshipType.BEFORESTART) 850 return "before-start"; 851 if (code == ActionRelationshipType.BEFORE) 852 return "before"; 853 if (code == ActionRelationshipType.BEFOREEND) 854 return "before-end"; 855 if (code == ActionRelationshipType.CONCURRENTWITHSTART) 856 return "concurrent-with-start"; 857 if (code == ActionRelationshipType.CONCURRENT) 858 return "concurrent"; 859 if (code == ActionRelationshipType.CONCURRENTWITHEND) 860 return "concurrent-with-end"; 861 if (code == ActionRelationshipType.AFTERSTART) 862 return "after-start"; 863 if (code == ActionRelationshipType.AFTER) 864 return "after"; 865 if (code == ActionRelationshipType.AFTEREND) 866 return "after-end"; 867 return "?"; 868 } 869 public String toSystem(ActionRelationshipType code) { 870 return code.getSystem(); 871 } 872 } 873 874 public enum ActionGroupingBehavior { 875 /** 876 * Any group marked with this behavior should be displayed as a visual group to the end user 877 */ 878 VISUALGROUP, 879 /** 880 * 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 881 */ 882 LOGICALGROUP, 883 /** 884 * 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" 885 */ 886 SENTENCEGROUP, 887 /** 888 * added to help the parsers with the generic types 889 */ 890 NULL; 891 public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException { 892 if (codeString == null || "".equals(codeString)) 893 return null; 894 if ("visual-group".equals(codeString)) 895 return VISUALGROUP; 896 if ("logical-group".equals(codeString)) 897 return LOGICALGROUP; 898 if ("sentence-group".equals(codeString)) 899 return SENTENCEGROUP; 900 if (Configuration.isAcceptInvalidEnums()) 901 return null; 902 else 903 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 904 } 905 public String toCode() { 906 switch (this) { 907 case VISUALGROUP: return "visual-group"; 908 case LOGICALGROUP: return "logical-group"; 909 case SENTENCEGROUP: return "sentence-group"; 910 case NULL: return null; 911 default: return "?"; 912 } 913 } 914 public String getSystem() { 915 switch (this) { 916 case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 917 case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 918 case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 919 case NULL: return null; 920 default: return "?"; 921 } 922 } 923 public String getDefinition() { 924 switch (this) { 925 case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user"; 926 case LOGICALGROUP: 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"; 927 case SENTENCEGROUP: 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\""; 928 case NULL: return null; 929 default: return "?"; 930 } 931 } 932 public String getDisplay() { 933 switch (this) { 934 case VISUALGROUP: return "Visual Group"; 935 case LOGICALGROUP: return "Logical Group"; 936 case SENTENCEGROUP: return "Sentence Group"; 937 case NULL: return null; 938 default: return "?"; 939 } 940 } 941 } 942 943 public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> { 944 public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException { 945 if (codeString == null || "".equals(codeString)) 946 if (codeString == null || "".equals(codeString)) 947 return null; 948 if ("visual-group".equals(codeString)) 949 return ActionGroupingBehavior.VISUALGROUP; 950 if ("logical-group".equals(codeString)) 951 return ActionGroupingBehavior.LOGICALGROUP; 952 if ("sentence-group".equals(codeString)) 953 return ActionGroupingBehavior.SENTENCEGROUP; 954 throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 955 } 956 public Enumeration<ActionGroupingBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 957 if (code == null) 958 return null; 959 if (code.isEmpty()) 960 return new Enumeration<ActionGroupingBehavior>(this); 961 String codeString = code.asStringValue(); 962 if (codeString == null || "".equals(codeString)) 963 return null; 964 if ("visual-group".equals(codeString)) 965 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP); 966 if ("logical-group".equals(codeString)) 967 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP); 968 if ("sentence-group".equals(codeString)) 969 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP); 970 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 971 } 972 public String toCode(ActionGroupingBehavior code) { 973 if (code == ActionGroupingBehavior.VISUALGROUP) 974 return "visual-group"; 975 if (code == ActionGroupingBehavior.LOGICALGROUP) 976 return "logical-group"; 977 if (code == ActionGroupingBehavior.SENTENCEGROUP) 978 return "sentence-group"; 979 return "?"; 980 } 981 public String toSystem(ActionGroupingBehavior code) { 982 return code.getSystem(); 983 } 984 } 985 986 public enum ActionSelectionBehavior { 987 /** 988 * Any number of the actions in the group may be chosen, from zero to all 989 */ 990 ANY, 991 /** 992 * All the actions in the group must be selected as a single unit 993 */ 994 ALL, 995 /** 996 * 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 997 */ 998 ALLORNONE, 999 /** 1000 * The end user must choose one and only one of the selectable actions in the group. The user may not choose none of the actions in the group 1001 */ 1002 EXACTLYONE, 1003 /** 1004 * The end user may choose zero or at most one of the actions in the group 1005 */ 1006 ATMOSTONE, 1007 /** 1008 * The end user must choose a minimum of one, and as many additional as desired 1009 */ 1010 ONEORMORE, 1011 /** 1012 * added to help the parsers with the generic types 1013 */ 1014 NULL; 1015 public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException { 1016 if (codeString == null || "".equals(codeString)) 1017 return null; 1018 if ("any".equals(codeString)) 1019 return ANY; 1020 if ("all".equals(codeString)) 1021 return ALL; 1022 if ("all-or-none".equals(codeString)) 1023 return ALLORNONE; 1024 if ("exactly-one".equals(codeString)) 1025 return EXACTLYONE; 1026 if ("at-most-one".equals(codeString)) 1027 return ATMOSTONE; 1028 if ("one-or-more".equals(codeString)) 1029 return ONEORMORE; 1030 if (Configuration.isAcceptInvalidEnums()) 1031 return null; 1032 else 1033 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1034 } 1035 public String toCode() { 1036 switch (this) { 1037 case ANY: return "any"; 1038 case ALL: return "all"; 1039 case ALLORNONE: return "all-or-none"; 1040 case EXACTLYONE: return "exactly-one"; 1041 case ATMOSTONE: return "at-most-one"; 1042 case ONEORMORE: return "one-or-more"; 1043 case NULL: return null; 1044 default: return "?"; 1045 } 1046 } 1047 public String getSystem() { 1048 switch (this) { 1049 case ANY: return "http://hl7.org/fhir/action-selection-behavior"; 1050 case ALL: return "http://hl7.org/fhir/action-selection-behavior"; 1051 case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior"; 1052 case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior"; 1053 case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior"; 1054 case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior"; 1055 case NULL: return null; 1056 default: return "?"; 1057 } 1058 } 1059 public String getDefinition() { 1060 switch (this) { 1061 case ANY: return "Any number of the actions in the group may be chosen, from zero to all"; 1062 case ALL: return "All the actions in the group must be selected as a single unit"; 1063 case ALLORNONE: 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"; 1064 case EXACTLYONE: return "The end user must choose one and only one of the selectable actions in the group. The user may not choose none of the actions in the group"; 1065 case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group"; 1066 case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired"; 1067 case NULL: return null; 1068 default: return "?"; 1069 } 1070 } 1071 public String getDisplay() { 1072 switch (this) { 1073 case ANY: return "Any"; 1074 case ALL: return "All"; 1075 case ALLORNONE: return "All Or None"; 1076 case EXACTLYONE: return "Exactly One"; 1077 case ATMOSTONE: return "At Most One"; 1078 case ONEORMORE: return "One Or More"; 1079 case NULL: return null; 1080 default: return "?"; 1081 } 1082 } 1083 } 1084 1085 public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> { 1086 public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException { 1087 if (codeString == null || "".equals(codeString)) 1088 if (codeString == null || "".equals(codeString)) 1089 return null; 1090 if ("any".equals(codeString)) 1091 return ActionSelectionBehavior.ANY; 1092 if ("all".equals(codeString)) 1093 return ActionSelectionBehavior.ALL; 1094 if ("all-or-none".equals(codeString)) 1095 return ActionSelectionBehavior.ALLORNONE; 1096 if ("exactly-one".equals(codeString)) 1097 return ActionSelectionBehavior.EXACTLYONE; 1098 if ("at-most-one".equals(codeString)) 1099 return ActionSelectionBehavior.ATMOSTONE; 1100 if ("one-or-more".equals(codeString)) 1101 return ActionSelectionBehavior.ONEORMORE; 1102 throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1103 } 1104 public Enumeration<ActionSelectionBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1105 if (code == null) 1106 return null; 1107 if (code.isEmpty()) 1108 return new Enumeration<ActionSelectionBehavior>(this); 1109 String codeString = code.asStringValue(); 1110 if (codeString == null || "".equals(codeString)) 1111 return null; 1112 if ("any".equals(codeString)) 1113 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY); 1114 if ("all".equals(codeString)) 1115 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL); 1116 if ("all-or-none".equals(codeString)) 1117 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE); 1118 if ("exactly-one".equals(codeString)) 1119 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE); 1120 if ("at-most-one".equals(codeString)) 1121 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE); 1122 if ("one-or-more".equals(codeString)) 1123 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE); 1124 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1125 } 1126 public String toCode(ActionSelectionBehavior code) { 1127 if (code == ActionSelectionBehavior.ANY) 1128 return "any"; 1129 if (code == ActionSelectionBehavior.ALL) 1130 return "all"; 1131 if (code == ActionSelectionBehavior.ALLORNONE) 1132 return "all-or-none"; 1133 if (code == ActionSelectionBehavior.EXACTLYONE) 1134 return "exactly-one"; 1135 if (code == ActionSelectionBehavior.ATMOSTONE) 1136 return "at-most-one"; 1137 if (code == ActionSelectionBehavior.ONEORMORE) 1138 return "one-or-more"; 1139 return "?"; 1140 } 1141 public String toSystem(ActionSelectionBehavior code) { 1142 return code.getSystem(); 1143 } 1144 } 1145 1146 public enum ActionRequiredBehavior { 1147 /** 1148 * An action with this behavior must be included in the actions processed by the end user; the end user may not choose not to include this action 1149 */ 1150 MUST, 1151 /** 1152 * An action with this behavior may be included in the set of actions processed by the end user 1153 */ 1154 COULD, 1155 /** 1156 * 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 1157 */ 1158 MUSTUNLESSDOCUMENTED, 1159 /** 1160 * added to help the parsers with the generic types 1161 */ 1162 NULL; 1163 public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException { 1164 if (codeString == null || "".equals(codeString)) 1165 return null; 1166 if ("must".equals(codeString)) 1167 return MUST; 1168 if ("could".equals(codeString)) 1169 return COULD; 1170 if ("must-unless-documented".equals(codeString)) 1171 return MUSTUNLESSDOCUMENTED; 1172 if (Configuration.isAcceptInvalidEnums()) 1173 return null; 1174 else 1175 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1176 } 1177 public String toCode() { 1178 switch (this) { 1179 case MUST: return "must"; 1180 case COULD: return "could"; 1181 case MUSTUNLESSDOCUMENTED: return "must-unless-documented"; 1182 case NULL: return null; 1183 default: return "?"; 1184 } 1185 } 1186 public String getSystem() { 1187 switch (this) { 1188 case MUST: return "http://hl7.org/fhir/action-required-behavior"; 1189 case COULD: return "http://hl7.org/fhir/action-required-behavior"; 1190 case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior"; 1191 case NULL: return null; 1192 default: return "?"; 1193 } 1194 } 1195 public String getDefinition() { 1196 switch (this) { 1197 case MUST: return "An action with this behavior must be included in the actions processed by the end user; the end user may not choose not to include this action"; 1198 case COULD: return "An action with this behavior may be included in the set of actions processed by the end user"; 1199 case MUSTUNLESSDOCUMENTED: 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"; 1200 case NULL: return null; 1201 default: return "?"; 1202 } 1203 } 1204 public String getDisplay() { 1205 switch (this) { 1206 case MUST: return "Must"; 1207 case COULD: return "Could"; 1208 case MUSTUNLESSDOCUMENTED: return "Must Unless Documented"; 1209 case NULL: return null; 1210 default: return "?"; 1211 } 1212 } 1213 } 1214 1215 public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> { 1216 public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException { 1217 if (codeString == null || "".equals(codeString)) 1218 if (codeString == null || "".equals(codeString)) 1219 return null; 1220 if ("must".equals(codeString)) 1221 return ActionRequiredBehavior.MUST; 1222 if ("could".equals(codeString)) 1223 return ActionRequiredBehavior.COULD; 1224 if ("must-unless-documented".equals(codeString)) 1225 return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED; 1226 throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1227 } 1228 public Enumeration<ActionRequiredBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1229 if (code == null) 1230 return null; 1231 if (code.isEmpty()) 1232 return new Enumeration<ActionRequiredBehavior>(this); 1233 String codeString = code.asStringValue(); 1234 if (codeString == null || "".equals(codeString)) 1235 return null; 1236 if ("must".equals(codeString)) 1237 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST); 1238 if ("could".equals(codeString)) 1239 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD); 1240 if ("must-unless-documented".equals(codeString)) 1241 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED); 1242 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1243 } 1244 public String toCode(ActionRequiredBehavior code) { 1245 if (code == ActionRequiredBehavior.MUST) 1246 return "must"; 1247 if (code == ActionRequiredBehavior.COULD) 1248 return "could"; 1249 if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED) 1250 return "must-unless-documented"; 1251 return "?"; 1252 } 1253 public String toSystem(ActionRequiredBehavior code) { 1254 return code.getSystem(); 1255 } 1256 } 1257 1258 public enum ActionPrecheckBehavior { 1259 /** 1260 * 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 1261 */ 1262 YES, 1263 /** 1264 * 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 1265 */ 1266 NO, 1267 /** 1268 * added to help the parsers with the generic types 1269 */ 1270 NULL; 1271 public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException { 1272 if (codeString == null || "".equals(codeString)) 1273 return null; 1274 if ("yes".equals(codeString)) 1275 return YES; 1276 if ("no".equals(codeString)) 1277 return NO; 1278 if (Configuration.isAcceptInvalidEnums()) 1279 return null; 1280 else 1281 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 1282 } 1283 public String toCode() { 1284 switch (this) { 1285 case YES: return "yes"; 1286 case NO: return "no"; 1287 case NULL: return null; 1288 default: return "?"; 1289 } 1290 } 1291 public String getSystem() { 1292 switch (this) { 1293 case YES: return "http://hl7.org/fhir/action-precheck-behavior"; 1294 case NO: return "http://hl7.org/fhir/action-precheck-behavior"; 1295 case NULL: return null; 1296 default: return "?"; 1297 } 1298 } 1299 public String getDefinition() { 1300 switch (this) { 1301 case YES: 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"; 1302 case NO: 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"; 1303 case NULL: return null; 1304 default: return "?"; 1305 } 1306 } 1307 public String getDisplay() { 1308 switch (this) { 1309 case YES: return "Yes"; 1310 case NO: return "No"; 1311 case NULL: return null; 1312 default: return "?"; 1313 } 1314 } 1315 } 1316 1317 public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> { 1318 public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException { 1319 if (codeString == null || "".equals(codeString)) 1320 if (codeString == null || "".equals(codeString)) 1321 return null; 1322 if ("yes".equals(codeString)) 1323 return ActionPrecheckBehavior.YES; 1324 if ("no".equals(codeString)) 1325 return ActionPrecheckBehavior.NO; 1326 throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 1327 } 1328 public Enumeration<ActionPrecheckBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1329 if (code == null) 1330 return null; 1331 if (code.isEmpty()) 1332 return new Enumeration<ActionPrecheckBehavior>(this); 1333 String codeString = code.asStringValue(); 1334 if (codeString == null || "".equals(codeString)) 1335 return null; 1336 if ("yes".equals(codeString)) 1337 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES); 1338 if ("no".equals(codeString)) 1339 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO); 1340 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 1341 } 1342 public String toCode(ActionPrecheckBehavior code) { 1343 if (code == ActionPrecheckBehavior.YES) 1344 return "yes"; 1345 if (code == ActionPrecheckBehavior.NO) 1346 return "no"; 1347 return "?"; 1348 } 1349 public String toSystem(ActionPrecheckBehavior code) { 1350 return code.getSystem(); 1351 } 1352 } 1353 1354 public enum ActionCardinalityBehavior { 1355 /** 1356 * The action may only be selected one time 1357 */ 1358 SINGLE, 1359 /** 1360 * The action may be selected multiple times 1361 */ 1362 MULTIPLE, 1363 /** 1364 * added to help the parsers with the generic types 1365 */ 1366 NULL; 1367 public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException { 1368 if (codeString == null || "".equals(codeString)) 1369 return null; 1370 if ("single".equals(codeString)) 1371 return SINGLE; 1372 if ("multiple".equals(codeString)) 1373 return MULTIPLE; 1374 if (Configuration.isAcceptInvalidEnums()) 1375 return null; 1376 else 1377 throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 1378 } 1379 public String toCode() { 1380 switch (this) { 1381 case SINGLE: return "single"; 1382 case MULTIPLE: return "multiple"; 1383 case NULL: return null; 1384 default: return "?"; 1385 } 1386 } 1387 public String getSystem() { 1388 switch (this) { 1389 case SINGLE: return "http://hl7.org/fhir/action-cardinality-behavior"; 1390 case MULTIPLE: return "http://hl7.org/fhir/action-cardinality-behavior"; 1391 case NULL: return null; 1392 default: return "?"; 1393 } 1394 } 1395 public String getDefinition() { 1396 switch (this) { 1397 case SINGLE: return "The action may only be selected one time"; 1398 case MULTIPLE: return "The action may be selected multiple times"; 1399 case NULL: return null; 1400 default: return "?"; 1401 } 1402 } 1403 public String getDisplay() { 1404 switch (this) { 1405 case SINGLE: return "Single"; 1406 case MULTIPLE: return "Multiple"; 1407 case NULL: return null; 1408 default: return "?"; 1409 } 1410 } 1411 } 1412 1413 public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> { 1414 public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException { 1415 if (codeString == null || "".equals(codeString)) 1416 if (codeString == null || "".equals(codeString)) 1417 return null; 1418 if ("single".equals(codeString)) 1419 return ActionCardinalityBehavior.SINGLE; 1420 if ("multiple".equals(codeString)) 1421 return ActionCardinalityBehavior.MULTIPLE; 1422 throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 1423 } 1424 public Enumeration<ActionCardinalityBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1425 if (code == null) 1426 return null; 1427 if (code.isEmpty()) 1428 return new Enumeration<ActionCardinalityBehavior>(this); 1429 String codeString = code.asStringValue(); 1430 if (codeString == null || "".equals(codeString)) 1431 return null; 1432 if ("single".equals(codeString)) 1433 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE); 1434 if ("multiple".equals(codeString)) 1435 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE); 1436 throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 1437 } 1438 public String toCode(ActionCardinalityBehavior code) { 1439 if (code == ActionCardinalityBehavior.SINGLE) 1440 return "single"; 1441 if (code == ActionCardinalityBehavior.MULTIPLE) 1442 return "multiple"; 1443 return "?"; 1444 } 1445 public String toSystem(ActionCardinalityBehavior code) { 1446 return code.getSystem(); 1447 } 1448 } 1449 1450 @Block() 1451 public static class RequestGroupActionComponent extends BackboneElement implements IBaseBackboneElement { 1452 /** 1453 * A user-visible label for the action. 1454 */ 1455 @Child(name = "label", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=false) 1456 @Description(shortDefinition="User-visible label for the action (e.g. 1. or A.)", formalDefinition="A user-visible label for the action." ) 1457 protected StringType label; 1458 1459 /** 1460 * The title of the action displayed to a user. 1461 */ 1462 @Child(name = "title", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false) 1463 @Description(shortDefinition="User-visible title", formalDefinition="The title of the action displayed to a user." ) 1464 protected StringType title; 1465 1466 /** 1467 * A short description of the action used to provide a summary to display to the user. 1468 */ 1469 @Child(name = "description", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true) 1470 @Description(shortDefinition="Short description of the action", formalDefinition="A short description of the action used to provide a summary to display to the user." ) 1471 protected StringType description; 1472 1473 /** 1474 * 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 may not be capable of interpreting it dynamically. 1475 */ 1476 @Child(name = "textEquivalent", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true) 1477 @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 may not be capable of interpreting it dynamically." ) 1478 protected StringType textEquivalent; 1479 1480 /** 1481 * A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template. 1482 */ 1483 @Child(name = "code", type = {CodeableConcept.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1484 @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 the section of a documentation template." ) 1485 protected List<CodeableConcept> code; 1486 1487 /** 1488 * 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. 1489 */ 1490 @Child(name = "documentation", type = {RelatedArtifact.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1491 @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." ) 1492 protected List<RelatedArtifact> documentation; 1493 1494 /** 1495 * An expression that describes applicability criteria, or start/stop conditions for the action. 1496 */ 1497 @Child(name = "condition", type = {}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1498 @Description(shortDefinition="Whether or not the action is applicable", formalDefinition="An expression that describes applicability criteria, or start/stop conditions for the action." ) 1499 protected List<RequestGroupActionConditionComponent> condition; 1500 1501 /** 1502 * A relationship to another action such as "before" or "30-60 minutes after start of". 1503 */ 1504 @Child(name = "relatedAction", type = {}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1505 @Description(shortDefinition="Relationship to another action", formalDefinition="A relationship to another action such as \"before\" or \"30-60 minutes after start of\"." ) 1506 protected List<RequestGroupActionRelatedActionComponent> relatedAction; 1507 1508 /** 1509 * An optional value describing when the action should be performed. 1510 */ 1511 @Child(name = "timing", type = {DateTimeType.class, Period.class, Duration.class, Range.class, Timing.class}, order=9, min=0, max=1, modifier=false, summary=false) 1512 @Description(shortDefinition="When the action should take place", formalDefinition="An optional value describing when the action should be performed." ) 1513 protected Type timing; 1514 1515 /** 1516 * The participant that should perform or be responsible for this action. 1517 */ 1518 @Child(name = "participant", type = {Patient.class, Person.class, Practitioner.class, RelatedPerson.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1519 @Description(shortDefinition="Who should perform the action", formalDefinition="The participant that should perform or be responsible for this action." ) 1520 protected List<Reference> participant; 1521 /** 1522 * The actual objects that are the target of the reference (The participant that should perform or be responsible for this action.) 1523 */ 1524 protected List<Resource> participantTarget; 1525 1526 1527 /** 1528 * The type of action to perform (create, update, remove). 1529 */ 1530 @Child(name = "type", type = {Coding.class}, order=11, min=0, max=1, modifier=false, summary=false) 1531 @Description(shortDefinition="create | update | remove | fire-event", formalDefinition="The type of action to perform (create, update, remove)." ) 1532 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-type") 1533 protected Coding type; 1534 1535 /** 1536 * Defines the grouping behavior for the action and its children. 1537 */ 1538 @Child(name = "groupingBehavior", type = {CodeType.class}, order=12, min=0, max=1, modifier=false, summary=false) 1539 @Description(shortDefinition="visual-group | logical-group | sentence-group", formalDefinition="Defines the grouping behavior for the action and its children." ) 1540 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-grouping-behavior") 1541 protected Enumeration<ActionGroupingBehavior> groupingBehavior; 1542 1543 /** 1544 * Defines the selection behavior for the action and its children. 1545 */ 1546 @Child(name = "selectionBehavior", type = {CodeType.class}, order=13, min=0, max=1, modifier=false, summary=false) 1547 @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." ) 1548 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-selection-behavior") 1549 protected Enumeration<ActionSelectionBehavior> selectionBehavior; 1550 1551 /** 1552 * Defines the requiredness behavior for the action. 1553 */ 1554 @Child(name = "requiredBehavior", type = {CodeType.class}, order=14, min=0, max=1, modifier=false, summary=false) 1555 @Description(shortDefinition="must | could | must-unless-documented", formalDefinition="Defines the requiredness behavior for the action." ) 1556 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-required-behavior") 1557 protected Enumeration<ActionRequiredBehavior> requiredBehavior; 1558 1559 /** 1560 * Defines whether the action should usually be preselected. 1561 */ 1562 @Child(name = "precheckBehavior", type = {CodeType.class}, order=15, min=0, max=1, modifier=false, summary=false) 1563 @Description(shortDefinition="yes | no", formalDefinition="Defines whether the action should usually be preselected." ) 1564 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-precheck-behavior") 1565 protected Enumeration<ActionPrecheckBehavior> precheckBehavior; 1566 1567 /** 1568 * Defines whether the action can be selected multiple times. 1569 */ 1570 @Child(name = "cardinalityBehavior", type = {CodeType.class}, order=16, min=0, max=1, modifier=false, summary=false) 1571 @Description(shortDefinition="single | multiple", formalDefinition="Defines whether the action can be selected multiple times." ) 1572 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-cardinality-behavior") 1573 protected Enumeration<ActionCardinalityBehavior> cardinalityBehavior; 1574 1575 /** 1576 * The resource that is the target of the action (e.g. CommunicationRequest). 1577 */ 1578 @Child(name = "resource", type = {Reference.class}, order=17, min=0, max=1, modifier=false, summary=false) 1579 @Description(shortDefinition="The target of the action", formalDefinition="The resource that is the target of the action (e.g. CommunicationRequest)." ) 1580 protected Reference resource; 1581 1582 /** 1583 * The actual object that is the target of the reference (The resource that is the target of the action (e.g. CommunicationRequest).) 1584 */ 1585 protected Resource resourceTarget; 1586 1587 /** 1588 * Sub actions. 1589 */ 1590 @Child(name = "action", type = {RequestGroupActionComponent.class}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1591 @Description(shortDefinition="Sub action", formalDefinition="Sub actions." ) 1592 protected List<RequestGroupActionComponent> action; 1593 1594 private static final long serialVersionUID = 362859874L; 1595 1596 /** 1597 * Constructor 1598 */ 1599 public RequestGroupActionComponent() { 1600 super(); 1601 } 1602 1603 /** 1604 * @return {@link #label} (A user-visible label for the action.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value 1605 */ 1606 public StringType getLabelElement() { 1607 if (this.label == null) 1608 if (Configuration.errorOnAutoCreate()) 1609 throw new Error("Attempt to auto-create RequestGroupActionComponent.label"); 1610 else if (Configuration.doAutoCreate()) 1611 this.label = new StringType(); // bb 1612 return this.label; 1613 } 1614 1615 public boolean hasLabelElement() { 1616 return this.label != null && !this.label.isEmpty(); 1617 } 1618 1619 public boolean hasLabel() { 1620 return this.label != null && !this.label.isEmpty(); 1621 } 1622 1623 /** 1624 * @param value {@link #label} (A user-visible label for the action.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value 1625 */ 1626 public RequestGroupActionComponent setLabelElement(StringType value) { 1627 this.label = value; 1628 return this; 1629 } 1630 1631 /** 1632 * @return A user-visible label for the action. 1633 */ 1634 public String getLabel() { 1635 return this.label == null ? null : this.label.getValue(); 1636 } 1637 1638 /** 1639 * @param value A user-visible label for the action. 1640 */ 1641 public RequestGroupActionComponent setLabel(String value) { 1642 if (Utilities.noString(value)) 1643 this.label = null; 1644 else { 1645 if (this.label == null) 1646 this.label = new StringType(); 1647 this.label.setValue(value); 1648 } 1649 return this; 1650 } 1651 1652 /** 1653 * @return {@link #title} (The title of the action displayed to a user.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 1654 */ 1655 public StringType getTitleElement() { 1656 if (this.title == null) 1657 if (Configuration.errorOnAutoCreate()) 1658 throw new Error("Attempt to auto-create RequestGroupActionComponent.title"); 1659 else if (Configuration.doAutoCreate()) 1660 this.title = new StringType(); // bb 1661 return this.title; 1662 } 1663 1664 public boolean hasTitleElement() { 1665 return this.title != null && !this.title.isEmpty(); 1666 } 1667 1668 public boolean hasTitle() { 1669 return this.title != null && !this.title.isEmpty(); 1670 } 1671 1672 /** 1673 * @param value {@link #title} (The title of the action displayed to a user.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 1674 */ 1675 public RequestGroupActionComponent setTitleElement(StringType value) { 1676 this.title = value; 1677 return this; 1678 } 1679 1680 /** 1681 * @return The title of the action displayed to a user. 1682 */ 1683 public String getTitle() { 1684 return this.title == null ? null : this.title.getValue(); 1685 } 1686 1687 /** 1688 * @param value The title of the action displayed to a user. 1689 */ 1690 public RequestGroupActionComponent setTitle(String value) { 1691 if (Utilities.noString(value)) 1692 this.title = null; 1693 else { 1694 if (this.title == null) 1695 this.title = new StringType(); 1696 this.title.setValue(value); 1697 } 1698 return this; 1699 } 1700 1701 /** 1702 * @return {@link #description} (A short description of the action used to provide a summary to display to the user.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1703 */ 1704 public StringType getDescriptionElement() { 1705 if (this.description == null) 1706 if (Configuration.errorOnAutoCreate()) 1707 throw new Error("Attempt to auto-create RequestGroupActionComponent.description"); 1708 else if (Configuration.doAutoCreate()) 1709 this.description = new StringType(); // bb 1710 return this.description; 1711 } 1712 1713 public boolean hasDescriptionElement() { 1714 return this.description != null && !this.description.isEmpty(); 1715 } 1716 1717 public boolean hasDescription() { 1718 return this.description != null && !this.description.isEmpty(); 1719 } 1720 1721 /** 1722 * @param value {@link #description} (A short description of the action used to provide a summary to display to the user.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1723 */ 1724 public RequestGroupActionComponent setDescriptionElement(StringType value) { 1725 this.description = value; 1726 return this; 1727 } 1728 1729 /** 1730 * @return A short description of the action used to provide a summary to display to the user. 1731 */ 1732 public String getDescription() { 1733 return this.description == null ? null : this.description.getValue(); 1734 } 1735 1736 /** 1737 * @param value A short description of the action used to provide a summary to display to the user. 1738 */ 1739 public RequestGroupActionComponent setDescription(String value) { 1740 if (Utilities.noString(value)) 1741 this.description = null; 1742 else { 1743 if (this.description == null) 1744 this.description = new StringType(); 1745 this.description.setValue(value); 1746 } 1747 return this; 1748 } 1749 1750 /** 1751 * @return {@link #textEquivalent} (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 may not be capable of interpreting it dynamically.). This is the underlying object with id, value and extensions. The accessor "getTextEquivalent" gives direct access to the value 1752 */ 1753 public StringType getTextEquivalentElement() { 1754 if (this.textEquivalent == null) 1755 if (Configuration.errorOnAutoCreate()) 1756 throw new Error("Attempt to auto-create RequestGroupActionComponent.textEquivalent"); 1757 else if (Configuration.doAutoCreate()) 1758 this.textEquivalent = new StringType(); // bb 1759 return this.textEquivalent; 1760 } 1761 1762 public boolean hasTextEquivalentElement() { 1763 return this.textEquivalent != null && !this.textEquivalent.isEmpty(); 1764 } 1765 1766 public boolean hasTextEquivalent() { 1767 return this.textEquivalent != null && !this.textEquivalent.isEmpty(); 1768 } 1769 1770 /** 1771 * @param value {@link #textEquivalent} (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 may not be capable of interpreting it dynamically.). This is the underlying object with id, value and extensions. The accessor "getTextEquivalent" gives direct access to the value 1772 */ 1773 public RequestGroupActionComponent setTextEquivalentElement(StringType value) { 1774 this.textEquivalent = value; 1775 return this; 1776 } 1777 1778 /** 1779 * @return 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 may not be capable of interpreting it dynamically. 1780 */ 1781 public String getTextEquivalent() { 1782 return this.textEquivalent == null ? null : this.textEquivalent.getValue(); 1783 } 1784 1785 /** 1786 * @param value 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 may not be capable of interpreting it dynamically. 1787 */ 1788 public RequestGroupActionComponent setTextEquivalent(String value) { 1789 if (Utilities.noString(value)) 1790 this.textEquivalent = null; 1791 else { 1792 if (this.textEquivalent == null) 1793 this.textEquivalent = new StringType(); 1794 this.textEquivalent.setValue(value); 1795 } 1796 return this; 1797 } 1798 1799 /** 1800 * @return {@link #code} (A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.) 1801 */ 1802 public List<CodeableConcept> getCode() { 1803 if (this.code == null) 1804 this.code = new ArrayList<CodeableConcept>(); 1805 return this.code; 1806 } 1807 1808 /** 1809 * @return Returns a reference to <code>this</code> for easy method chaining 1810 */ 1811 public RequestGroupActionComponent setCode(List<CodeableConcept> theCode) { 1812 this.code = theCode; 1813 return this; 1814 } 1815 1816 public boolean hasCode() { 1817 if (this.code == null) 1818 return false; 1819 for (CodeableConcept item : this.code) 1820 if (!item.isEmpty()) 1821 return true; 1822 return false; 1823 } 1824 1825 public CodeableConcept addCode() { //3 1826 CodeableConcept t = new CodeableConcept(); 1827 if (this.code == null) 1828 this.code = new ArrayList<CodeableConcept>(); 1829 this.code.add(t); 1830 return t; 1831 } 1832 1833 public RequestGroupActionComponent addCode(CodeableConcept t) { //3 1834 if (t == null) 1835 return this; 1836 if (this.code == null) 1837 this.code = new ArrayList<CodeableConcept>(); 1838 this.code.add(t); 1839 return this; 1840 } 1841 1842 /** 1843 * @return The first repetition of repeating field {@link #code}, creating it if it does not already exist 1844 */ 1845 public CodeableConcept getCodeFirstRep() { 1846 if (getCode().isEmpty()) { 1847 addCode(); 1848 } 1849 return getCode().get(0); 1850 } 1851 1852 /** 1853 * @return {@link #documentation} (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.) 1854 */ 1855 public List<RelatedArtifact> getDocumentation() { 1856 if (this.documentation == null) 1857 this.documentation = new ArrayList<RelatedArtifact>(); 1858 return this.documentation; 1859 } 1860 1861 /** 1862 * @return Returns a reference to <code>this</code> for easy method chaining 1863 */ 1864 public RequestGroupActionComponent setDocumentation(List<RelatedArtifact> theDocumentation) { 1865 this.documentation = theDocumentation; 1866 return this; 1867 } 1868 1869 public boolean hasDocumentation() { 1870 if (this.documentation == null) 1871 return false; 1872 for (RelatedArtifact item : this.documentation) 1873 if (!item.isEmpty()) 1874 return true; 1875 return false; 1876 } 1877 1878 public RelatedArtifact addDocumentation() { //3 1879 RelatedArtifact t = new RelatedArtifact(); 1880 if (this.documentation == null) 1881 this.documentation = new ArrayList<RelatedArtifact>(); 1882 this.documentation.add(t); 1883 return t; 1884 } 1885 1886 public RequestGroupActionComponent addDocumentation(RelatedArtifact t) { //3 1887 if (t == null) 1888 return this; 1889 if (this.documentation == null) 1890 this.documentation = new ArrayList<RelatedArtifact>(); 1891 this.documentation.add(t); 1892 return this; 1893 } 1894 1895 /** 1896 * @return The first repetition of repeating field {@link #documentation}, creating it if it does not already exist 1897 */ 1898 public RelatedArtifact getDocumentationFirstRep() { 1899 if (getDocumentation().isEmpty()) { 1900 addDocumentation(); 1901 } 1902 return getDocumentation().get(0); 1903 } 1904 1905 /** 1906 * @return {@link #condition} (An expression that describes applicability criteria, or start/stop conditions for the action.) 1907 */ 1908 public List<RequestGroupActionConditionComponent> getCondition() { 1909 if (this.condition == null) 1910 this.condition = new ArrayList<RequestGroupActionConditionComponent>(); 1911 return this.condition; 1912 } 1913 1914 /** 1915 * @return Returns a reference to <code>this</code> for easy method chaining 1916 */ 1917 public RequestGroupActionComponent setCondition(List<RequestGroupActionConditionComponent> theCondition) { 1918 this.condition = theCondition; 1919 return this; 1920 } 1921 1922 public boolean hasCondition() { 1923 if (this.condition == null) 1924 return false; 1925 for (RequestGroupActionConditionComponent item : this.condition) 1926 if (!item.isEmpty()) 1927 return true; 1928 return false; 1929 } 1930 1931 public RequestGroupActionConditionComponent addCondition() { //3 1932 RequestGroupActionConditionComponent t = new RequestGroupActionConditionComponent(); 1933 if (this.condition == null) 1934 this.condition = new ArrayList<RequestGroupActionConditionComponent>(); 1935 this.condition.add(t); 1936 return t; 1937 } 1938 1939 public RequestGroupActionComponent addCondition(RequestGroupActionConditionComponent t) { //3 1940 if (t == null) 1941 return this; 1942 if (this.condition == null) 1943 this.condition = new ArrayList<RequestGroupActionConditionComponent>(); 1944 this.condition.add(t); 1945 return this; 1946 } 1947 1948 /** 1949 * @return The first repetition of repeating field {@link #condition}, creating it if it does not already exist 1950 */ 1951 public RequestGroupActionConditionComponent getConditionFirstRep() { 1952 if (getCondition().isEmpty()) { 1953 addCondition(); 1954 } 1955 return getCondition().get(0); 1956 } 1957 1958 /** 1959 * @return {@link #relatedAction} (A relationship to another action such as "before" or "30-60 minutes after start of".) 1960 */ 1961 public List<RequestGroupActionRelatedActionComponent> getRelatedAction() { 1962 if (this.relatedAction == null) 1963 this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>(); 1964 return this.relatedAction; 1965 } 1966 1967 /** 1968 * @return Returns a reference to <code>this</code> for easy method chaining 1969 */ 1970 public RequestGroupActionComponent setRelatedAction(List<RequestGroupActionRelatedActionComponent> theRelatedAction) { 1971 this.relatedAction = theRelatedAction; 1972 return this; 1973 } 1974 1975 public boolean hasRelatedAction() { 1976 if (this.relatedAction == null) 1977 return false; 1978 for (RequestGroupActionRelatedActionComponent item : this.relatedAction) 1979 if (!item.isEmpty()) 1980 return true; 1981 return false; 1982 } 1983 1984 public RequestGroupActionRelatedActionComponent addRelatedAction() { //3 1985 RequestGroupActionRelatedActionComponent t = new RequestGroupActionRelatedActionComponent(); 1986 if (this.relatedAction == null) 1987 this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>(); 1988 this.relatedAction.add(t); 1989 return t; 1990 } 1991 1992 public RequestGroupActionComponent addRelatedAction(RequestGroupActionRelatedActionComponent t) { //3 1993 if (t == null) 1994 return this; 1995 if (this.relatedAction == null) 1996 this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>(); 1997 this.relatedAction.add(t); 1998 return this; 1999 } 2000 2001 /** 2002 * @return The first repetition of repeating field {@link #relatedAction}, creating it if it does not already exist 2003 */ 2004 public RequestGroupActionRelatedActionComponent getRelatedActionFirstRep() { 2005 if (getRelatedAction().isEmpty()) { 2006 addRelatedAction(); 2007 } 2008 return getRelatedAction().get(0); 2009 } 2010 2011 /** 2012 * @return {@link #timing} (An optional value describing when the action should be performed.) 2013 */ 2014 public Type getTiming() { 2015 return this.timing; 2016 } 2017 2018 /** 2019 * @return {@link #timing} (An optional value describing when the action should be performed.) 2020 */ 2021 public DateTimeType getTimingDateTimeType() throws FHIRException { 2022 if (this.timing == null) 2023 return null; 2024 if (!(this.timing instanceof DateTimeType)) 2025 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.timing.getClass().getName()+" was encountered"); 2026 return (DateTimeType) this.timing; 2027 } 2028 2029 public boolean hasTimingDateTimeType() { 2030 return this != null && this.timing instanceof DateTimeType; 2031 } 2032 2033 /** 2034 * @return {@link #timing} (An optional value describing when the action should be performed.) 2035 */ 2036 public Period getTimingPeriod() throws FHIRException { 2037 if (this.timing == null) 2038 return null; 2039 if (!(this.timing instanceof Period)) 2040 throw new FHIRException("Type mismatch: the type Period was expected, but "+this.timing.getClass().getName()+" was encountered"); 2041 return (Period) this.timing; 2042 } 2043 2044 public boolean hasTimingPeriod() { 2045 return this != null && this.timing instanceof Period; 2046 } 2047 2048 /** 2049 * @return {@link #timing} (An optional value describing when the action should be performed.) 2050 */ 2051 public Duration getTimingDuration() throws FHIRException { 2052 if (this.timing == null) 2053 return null; 2054 if (!(this.timing instanceof Duration)) 2055 throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.timing.getClass().getName()+" was encountered"); 2056 return (Duration) this.timing; 2057 } 2058 2059 public boolean hasTimingDuration() { 2060 return this != null && this.timing instanceof Duration; 2061 } 2062 2063 /** 2064 * @return {@link #timing} (An optional value describing when the action should be performed.) 2065 */ 2066 public Range getTimingRange() throws FHIRException { 2067 if (this.timing == null) 2068 return null; 2069 if (!(this.timing instanceof Range)) 2070 throw new FHIRException("Type mismatch: the type Range was expected, but "+this.timing.getClass().getName()+" was encountered"); 2071 return (Range) this.timing; 2072 } 2073 2074 public boolean hasTimingRange() { 2075 return this != null && this.timing instanceof Range; 2076 } 2077 2078 /** 2079 * @return {@link #timing} (An optional value describing when the action should be performed.) 2080 */ 2081 public Timing getTimingTiming() throws FHIRException { 2082 if (this.timing == null) 2083 return null; 2084 if (!(this.timing instanceof Timing)) 2085 throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.timing.getClass().getName()+" was encountered"); 2086 return (Timing) this.timing; 2087 } 2088 2089 public boolean hasTimingTiming() { 2090 return this != null && this.timing instanceof Timing; 2091 } 2092 2093 public boolean hasTiming() { 2094 return this.timing != null && !this.timing.isEmpty(); 2095 } 2096 2097 /** 2098 * @param value {@link #timing} (An optional value describing when the action should be performed.) 2099 */ 2100 public RequestGroupActionComponent setTiming(Type value) throws FHIRFormatError { 2101 if (value != null && !(value instanceof DateTimeType || value instanceof Period || value instanceof Duration || value instanceof Range || value instanceof Timing)) 2102 throw new FHIRFormatError("Not the right type for RequestGroup.action.timing[x]: "+value.fhirType()); 2103 this.timing = value; 2104 return this; 2105 } 2106 2107 /** 2108 * @return {@link #participant} (The participant that should perform or be responsible for this action.) 2109 */ 2110 public List<Reference> getParticipant() { 2111 if (this.participant == null) 2112 this.participant = new ArrayList<Reference>(); 2113 return this.participant; 2114 } 2115 2116 /** 2117 * @return Returns a reference to <code>this</code> for easy method chaining 2118 */ 2119 public RequestGroupActionComponent setParticipant(List<Reference> theParticipant) { 2120 this.participant = theParticipant; 2121 return this; 2122 } 2123 2124 public boolean hasParticipant() { 2125 if (this.participant == null) 2126 return false; 2127 for (Reference item : this.participant) 2128 if (!item.isEmpty()) 2129 return true; 2130 return false; 2131 } 2132 2133 public Reference addParticipant() { //3 2134 Reference t = new Reference(); 2135 if (this.participant == null) 2136 this.participant = new ArrayList<Reference>(); 2137 this.participant.add(t); 2138 return t; 2139 } 2140 2141 public RequestGroupActionComponent addParticipant(Reference t) { //3 2142 if (t == null) 2143 return this; 2144 if (this.participant == null) 2145 this.participant = new ArrayList<Reference>(); 2146 this.participant.add(t); 2147 return this; 2148 } 2149 2150 /** 2151 * @return The first repetition of repeating field {@link #participant}, creating it if it does not already exist 2152 */ 2153 public Reference getParticipantFirstRep() { 2154 if (getParticipant().isEmpty()) { 2155 addParticipant(); 2156 } 2157 return getParticipant().get(0); 2158 } 2159 2160 /** 2161 * @deprecated Use Reference#setResource(IBaseResource) instead 2162 */ 2163 @Deprecated 2164 public List<Resource> getParticipantTarget() { 2165 if (this.participantTarget == null) 2166 this.participantTarget = new ArrayList<Resource>(); 2167 return this.participantTarget; 2168 } 2169 2170 /** 2171 * @return {@link #type} (The type of action to perform (create, update, remove).) 2172 */ 2173 public Coding getType() { 2174 if (this.type == null) 2175 if (Configuration.errorOnAutoCreate()) 2176 throw new Error("Attempt to auto-create RequestGroupActionComponent.type"); 2177 else if (Configuration.doAutoCreate()) 2178 this.type = new Coding(); // cc 2179 return this.type; 2180 } 2181 2182 public boolean hasType() { 2183 return this.type != null && !this.type.isEmpty(); 2184 } 2185 2186 /** 2187 * @param value {@link #type} (The type of action to perform (create, update, remove).) 2188 */ 2189 public RequestGroupActionComponent setType(Coding value) { 2190 this.type = value; 2191 return this; 2192 } 2193 2194 /** 2195 * @return {@link #groupingBehavior} (Defines the grouping behavior for the action and its children.). This is the underlying object with id, value and extensions. The accessor "getGroupingBehavior" gives direct access to the value 2196 */ 2197 public Enumeration<ActionGroupingBehavior> getGroupingBehaviorElement() { 2198 if (this.groupingBehavior == null) 2199 if (Configuration.errorOnAutoCreate()) 2200 throw new Error("Attempt to auto-create RequestGroupActionComponent.groupingBehavior"); 2201 else if (Configuration.doAutoCreate()) 2202 this.groupingBehavior = new Enumeration<ActionGroupingBehavior>(new ActionGroupingBehaviorEnumFactory()); // bb 2203 return this.groupingBehavior; 2204 } 2205 2206 public boolean hasGroupingBehaviorElement() { 2207 return this.groupingBehavior != null && !this.groupingBehavior.isEmpty(); 2208 } 2209 2210 public boolean hasGroupingBehavior() { 2211 return this.groupingBehavior != null && !this.groupingBehavior.isEmpty(); 2212 } 2213 2214 /** 2215 * @param value {@link #groupingBehavior} (Defines the grouping behavior for the action and its children.). This is the underlying object with id, value and extensions. The accessor "getGroupingBehavior" gives direct access to the value 2216 */ 2217 public RequestGroupActionComponent setGroupingBehaviorElement(Enumeration<ActionGroupingBehavior> value) { 2218 this.groupingBehavior = value; 2219 return this; 2220 } 2221 2222 /** 2223 * @return Defines the grouping behavior for the action and its children. 2224 */ 2225 public ActionGroupingBehavior getGroupingBehavior() { 2226 return this.groupingBehavior == null ? null : this.groupingBehavior.getValue(); 2227 } 2228 2229 /** 2230 * @param value Defines the grouping behavior for the action and its children. 2231 */ 2232 public RequestGroupActionComponent setGroupingBehavior(ActionGroupingBehavior value) { 2233 if (value == null) 2234 this.groupingBehavior = null; 2235 else { 2236 if (this.groupingBehavior == null) 2237 this.groupingBehavior = new Enumeration<ActionGroupingBehavior>(new ActionGroupingBehaviorEnumFactory()); 2238 this.groupingBehavior.setValue(value); 2239 } 2240 return this; 2241 } 2242 2243 /** 2244 * @return {@link #selectionBehavior} (Defines the selection behavior for the action and its children.). This is the underlying object with id, value and extensions. The accessor "getSelectionBehavior" gives direct access to the value 2245 */ 2246 public Enumeration<ActionSelectionBehavior> getSelectionBehaviorElement() { 2247 if (this.selectionBehavior == null) 2248 if (Configuration.errorOnAutoCreate()) 2249 throw new Error("Attempt to auto-create RequestGroupActionComponent.selectionBehavior"); 2250 else if (Configuration.doAutoCreate()) 2251 this.selectionBehavior = new Enumeration<ActionSelectionBehavior>(new ActionSelectionBehaviorEnumFactory()); // bb 2252 return this.selectionBehavior; 2253 } 2254 2255 public boolean hasSelectionBehaviorElement() { 2256 return this.selectionBehavior != null && !this.selectionBehavior.isEmpty(); 2257 } 2258 2259 public boolean hasSelectionBehavior() { 2260 return this.selectionBehavior != null && !this.selectionBehavior.isEmpty(); 2261 } 2262 2263 /** 2264 * @param value {@link #selectionBehavior} (Defines the selection behavior for the action and its children.). This is the underlying object with id, value and extensions. The accessor "getSelectionBehavior" gives direct access to the value 2265 */ 2266 public RequestGroupActionComponent setSelectionBehaviorElement(Enumeration<ActionSelectionBehavior> value) { 2267 this.selectionBehavior = value; 2268 return this; 2269 } 2270 2271 /** 2272 * @return Defines the selection behavior for the action and its children. 2273 */ 2274 public ActionSelectionBehavior getSelectionBehavior() { 2275 return this.selectionBehavior == null ? null : this.selectionBehavior.getValue(); 2276 } 2277 2278 /** 2279 * @param value Defines the selection behavior for the action and its children. 2280 */ 2281 public RequestGroupActionComponent setSelectionBehavior(ActionSelectionBehavior value) { 2282 if (value == null) 2283 this.selectionBehavior = null; 2284 else { 2285 if (this.selectionBehavior == null) 2286 this.selectionBehavior = new Enumeration<ActionSelectionBehavior>(new ActionSelectionBehaviorEnumFactory()); 2287 this.selectionBehavior.setValue(value); 2288 } 2289 return this; 2290 } 2291 2292 /** 2293 * @return {@link #requiredBehavior} (Defines the requiredness behavior for the action.). This is the underlying object with id, value and extensions. The accessor "getRequiredBehavior" gives direct access to the value 2294 */ 2295 public Enumeration<ActionRequiredBehavior> getRequiredBehaviorElement() { 2296 if (this.requiredBehavior == null) 2297 if (Configuration.errorOnAutoCreate()) 2298 throw new Error("Attempt to auto-create RequestGroupActionComponent.requiredBehavior"); 2299 else if (Configuration.doAutoCreate()) 2300 this.requiredBehavior = new Enumeration<ActionRequiredBehavior>(new ActionRequiredBehaviorEnumFactory()); // bb 2301 return this.requiredBehavior; 2302 } 2303 2304 public boolean hasRequiredBehaviorElement() { 2305 return this.requiredBehavior != null && !this.requiredBehavior.isEmpty(); 2306 } 2307 2308 public boolean hasRequiredBehavior() { 2309 return this.requiredBehavior != null && !this.requiredBehavior.isEmpty(); 2310 } 2311 2312 /** 2313 * @param value {@link #requiredBehavior} (Defines the requiredness behavior for the action.). This is the underlying object with id, value and extensions. The accessor "getRequiredBehavior" gives direct access to the value 2314 */ 2315 public RequestGroupActionComponent setRequiredBehaviorElement(Enumeration<ActionRequiredBehavior> value) { 2316 this.requiredBehavior = value; 2317 return this; 2318 } 2319 2320 /** 2321 * @return Defines the requiredness behavior for the action. 2322 */ 2323 public ActionRequiredBehavior getRequiredBehavior() { 2324 return this.requiredBehavior == null ? null : this.requiredBehavior.getValue(); 2325 } 2326 2327 /** 2328 * @param value Defines the requiredness behavior for the action. 2329 */ 2330 public RequestGroupActionComponent setRequiredBehavior(ActionRequiredBehavior value) { 2331 if (value == null) 2332 this.requiredBehavior = null; 2333 else { 2334 if (this.requiredBehavior == null) 2335 this.requiredBehavior = new Enumeration<ActionRequiredBehavior>(new ActionRequiredBehaviorEnumFactory()); 2336 this.requiredBehavior.setValue(value); 2337 } 2338 return this; 2339 } 2340 2341 /** 2342 * @return {@link #precheckBehavior} (Defines whether the action should usually be preselected.). This is the underlying object with id, value and extensions. The accessor "getPrecheckBehavior" gives direct access to the value 2343 */ 2344 public Enumeration<ActionPrecheckBehavior> getPrecheckBehaviorElement() { 2345 if (this.precheckBehavior == null) 2346 if (Configuration.errorOnAutoCreate()) 2347 throw new Error("Attempt to auto-create RequestGroupActionComponent.precheckBehavior"); 2348 else if (Configuration.doAutoCreate()) 2349 this.precheckBehavior = new Enumeration<ActionPrecheckBehavior>(new ActionPrecheckBehaviorEnumFactory()); // bb 2350 return this.precheckBehavior; 2351 } 2352 2353 public boolean hasPrecheckBehaviorElement() { 2354 return this.precheckBehavior != null && !this.precheckBehavior.isEmpty(); 2355 } 2356 2357 public boolean hasPrecheckBehavior() { 2358 return this.precheckBehavior != null && !this.precheckBehavior.isEmpty(); 2359 } 2360 2361 /** 2362 * @param value {@link #precheckBehavior} (Defines whether the action should usually be preselected.). This is the underlying object with id, value and extensions. The accessor "getPrecheckBehavior" gives direct access to the value 2363 */ 2364 public RequestGroupActionComponent setPrecheckBehaviorElement(Enumeration<ActionPrecheckBehavior> value) { 2365 this.precheckBehavior = value; 2366 return this; 2367 } 2368 2369 /** 2370 * @return Defines whether the action should usually be preselected. 2371 */ 2372 public ActionPrecheckBehavior getPrecheckBehavior() { 2373 return this.precheckBehavior == null ? null : this.precheckBehavior.getValue(); 2374 } 2375 2376 /** 2377 * @param value Defines whether the action should usually be preselected. 2378 */ 2379 public RequestGroupActionComponent setPrecheckBehavior(ActionPrecheckBehavior value) { 2380 if (value == null) 2381 this.precheckBehavior = null; 2382 else { 2383 if (this.precheckBehavior == null) 2384 this.precheckBehavior = new Enumeration<ActionPrecheckBehavior>(new ActionPrecheckBehaviorEnumFactory()); 2385 this.precheckBehavior.setValue(value); 2386 } 2387 return this; 2388 } 2389 2390 /** 2391 * @return {@link #cardinalityBehavior} (Defines whether the action can be selected multiple times.). This is the underlying object with id, value and extensions. The accessor "getCardinalityBehavior" gives direct access to the value 2392 */ 2393 public Enumeration<ActionCardinalityBehavior> getCardinalityBehaviorElement() { 2394 if (this.cardinalityBehavior == null) 2395 if (Configuration.errorOnAutoCreate()) 2396 throw new Error("Attempt to auto-create RequestGroupActionComponent.cardinalityBehavior"); 2397 else if (Configuration.doAutoCreate()) 2398 this.cardinalityBehavior = new Enumeration<ActionCardinalityBehavior>(new ActionCardinalityBehaviorEnumFactory()); // bb 2399 return this.cardinalityBehavior; 2400 } 2401 2402 public boolean hasCardinalityBehaviorElement() { 2403 return this.cardinalityBehavior != null && !this.cardinalityBehavior.isEmpty(); 2404 } 2405 2406 public boolean hasCardinalityBehavior() { 2407 return this.cardinalityBehavior != null && !this.cardinalityBehavior.isEmpty(); 2408 } 2409 2410 /** 2411 * @param value {@link #cardinalityBehavior} (Defines whether the action can be selected multiple times.). This is the underlying object with id, value and extensions. The accessor "getCardinalityBehavior" gives direct access to the value 2412 */ 2413 public RequestGroupActionComponent setCardinalityBehaviorElement(Enumeration<ActionCardinalityBehavior> value) { 2414 this.cardinalityBehavior = value; 2415 return this; 2416 } 2417 2418 /** 2419 * @return Defines whether the action can be selected multiple times. 2420 */ 2421 public ActionCardinalityBehavior getCardinalityBehavior() { 2422 return this.cardinalityBehavior == null ? null : this.cardinalityBehavior.getValue(); 2423 } 2424 2425 /** 2426 * @param value Defines whether the action can be selected multiple times. 2427 */ 2428 public RequestGroupActionComponent setCardinalityBehavior(ActionCardinalityBehavior value) { 2429 if (value == null) 2430 this.cardinalityBehavior = null; 2431 else { 2432 if (this.cardinalityBehavior == null) 2433 this.cardinalityBehavior = new Enumeration<ActionCardinalityBehavior>(new ActionCardinalityBehaviorEnumFactory()); 2434 this.cardinalityBehavior.setValue(value); 2435 } 2436 return this; 2437 } 2438 2439 /** 2440 * @return {@link #resource} (The resource that is the target of the action (e.g. CommunicationRequest).) 2441 */ 2442 public Reference getResource() { 2443 if (this.resource == null) 2444 if (Configuration.errorOnAutoCreate()) 2445 throw new Error("Attempt to auto-create RequestGroupActionComponent.resource"); 2446 else if (Configuration.doAutoCreate()) 2447 this.resource = new Reference(); // cc 2448 return this.resource; 2449 } 2450 2451 public boolean hasResource() { 2452 return this.resource != null && !this.resource.isEmpty(); 2453 } 2454 2455 /** 2456 * @param value {@link #resource} (The resource that is the target of the action (e.g. CommunicationRequest).) 2457 */ 2458 public RequestGroupActionComponent setResource(Reference value) { 2459 this.resource = value; 2460 return this; 2461 } 2462 2463 /** 2464 * @return {@link #resource} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The resource that is the target of the action (e.g. CommunicationRequest).) 2465 */ 2466 public Resource getResourceTarget() { 2467 return this.resourceTarget; 2468 } 2469 2470 /** 2471 * @param value {@link #resource} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The resource that is the target of the action (e.g. CommunicationRequest).) 2472 */ 2473 public RequestGroupActionComponent setResourceTarget(Resource value) { 2474 this.resourceTarget = value; 2475 return this; 2476 } 2477 2478 /** 2479 * @return {@link #action} (Sub actions.) 2480 */ 2481 public List<RequestGroupActionComponent> getAction() { 2482 if (this.action == null) 2483 this.action = new ArrayList<RequestGroupActionComponent>(); 2484 return this.action; 2485 } 2486 2487 /** 2488 * @return Returns a reference to <code>this</code> for easy method chaining 2489 */ 2490 public RequestGroupActionComponent setAction(List<RequestGroupActionComponent> theAction) { 2491 this.action = theAction; 2492 return this; 2493 } 2494 2495 public boolean hasAction() { 2496 if (this.action == null) 2497 return false; 2498 for (RequestGroupActionComponent item : this.action) 2499 if (!item.isEmpty()) 2500 return true; 2501 return false; 2502 } 2503 2504 public RequestGroupActionComponent addAction() { //3 2505 RequestGroupActionComponent t = new RequestGroupActionComponent(); 2506 if (this.action == null) 2507 this.action = new ArrayList<RequestGroupActionComponent>(); 2508 this.action.add(t); 2509 return t; 2510 } 2511 2512 public RequestGroupActionComponent addAction(RequestGroupActionComponent t) { //3 2513 if (t == null) 2514 return this; 2515 if (this.action == null) 2516 this.action = new ArrayList<RequestGroupActionComponent>(); 2517 this.action.add(t); 2518 return this; 2519 } 2520 2521 /** 2522 * @return The first repetition of repeating field {@link #action}, creating it if it does not already exist 2523 */ 2524 public RequestGroupActionComponent getActionFirstRep() { 2525 if (getAction().isEmpty()) { 2526 addAction(); 2527 } 2528 return getAction().get(0); 2529 } 2530 2531 protected void listChildren(List<Property> children) { 2532 super.listChildren(children); 2533 children.add(new Property("label", "string", "A user-visible label for the action.", 0, 1, label)); 2534 children.add(new Property("title", "string", "The title of the action displayed to a user.", 0, 1, title)); 2535 children.add(new Property("description", "string", "A short description of the action used to provide a summary to display to the user.", 0, 1, description)); 2536 children.add(new Property("textEquivalent", "string", "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 may not be capable of interpreting it dynamically.", 0, 1, textEquivalent)); 2537 children.add(new Property("code", "CodeableConcept", "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.", 0, java.lang.Integer.MAX_VALUE, code)); 2538 children.add(new Property("documentation", "RelatedArtifact", "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.", 0, java.lang.Integer.MAX_VALUE, documentation)); 2539 children.add(new Property("condition", "", "An expression that describes applicability criteria, or start/stop conditions for the action.", 0, java.lang.Integer.MAX_VALUE, condition)); 2540 children.add(new Property("relatedAction", "", "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".", 0, java.lang.Integer.MAX_VALUE, relatedAction)); 2541 children.add(new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing)); 2542 children.add(new Property("participant", "Reference(Patient|Person|Practitioner|RelatedPerson)", "The participant that should perform or be responsible for this action.", 0, java.lang.Integer.MAX_VALUE, participant)); 2543 children.add(new Property("type", "Coding", "The type of action to perform (create, update, remove).", 0, 1, type)); 2544 children.add(new Property("groupingBehavior", "code", "Defines the grouping behavior for the action and its children.", 0, 1, groupingBehavior)); 2545 children.add(new Property("selectionBehavior", "code", "Defines the selection behavior for the action and its children.", 0, 1, selectionBehavior)); 2546 children.add(new Property("requiredBehavior", "code", "Defines the requiredness behavior for the action.", 0, 1, requiredBehavior)); 2547 children.add(new Property("precheckBehavior", "code", "Defines whether the action should usually be preselected.", 0, 1, precheckBehavior)); 2548 children.add(new Property("cardinalityBehavior", "code", "Defines whether the action can be selected multiple times.", 0, 1, cardinalityBehavior)); 2549 children.add(new Property("resource", "Reference(Any)", "The resource that is the target of the action (e.g. CommunicationRequest).", 0, 1, resource)); 2550 children.add(new Property("action", "@RequestGroup.action", "Sub actions.", 0, java.lang.Integer.MAX_VALUE, action)); 2551 } 2552 2553 @Override 2554 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2555 switch (_hash) { 2556 case 102727412: /*label*/ return new Property("label", "string", "A user-visible label for the action.", 0, 1, label); 2557 case 110371416: /*title*/ return new Property("title", "string", "The title of the action displayed to a user.", 0, 1, title); 2558 case -1724546052: /*description*/ return new Property("description", "string", "A short description of the action used to provide a summary to display to the user.", 0, 1, description); 2559 case -900391049: /*textEquivalent*/ return new Property("textEquivalent", "string", "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 may not be capable of interpreting it dynamically.", 0, 1, textEquivalent); 2560 case 3059181: /*code*/ return new Property("code", "CodeableConcept", "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.", 0, java.lang.Integer.MAX_VALUE, code); 2561 case 1587405498: /*documentation*/ return new Property("documentation", "RelatedArtifact", "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.", 0, java.lang.Integer.MAX_VALUE, documentation); 2562 case -861311717: /*condition*/ return new Property("condition", "", "An expression that describes applicability criteria, or start/stop conditions for the action.", 0, java.lang.Integer.MAX_VALUE, condition); 2563 case -384107967: /*relatedAction*/ return new Property("relatedAction", "", "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".", 0, java.lang.Integer.MAX_VALUE, relatedAction); 2564 case 164632566: /*timing[x]*/ return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing); 2565 case -873664438: /*timing*/ return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing); 2566 case -1837458939: /*timingDateTime*/ return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing); 2567 case -615615829: /*timingPeriod*/ return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing); 2568 case -1327253506: /*timingDuration*/ return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing); 2569 case -710871277: /*timingRange*/ return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing); 2570 case -497554124: /*timingTiming*/ return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing); 2571 case 767422259: /*participant*/ return new Property("participant", "Reference(Patient|Person|Practitioner|RelatedPerson)", "The participant that should perform or be responsible for this action.", 0, java.lang.Integer.MAX_VALUE, participant); 2572 case 3575610: /*type*/ return new Property("type", "Coding", "The type of action to perform (create, update, remove).", 0, 1, type); 2573 case 586678389: /*groupingBehavior*/ return new Property("groupingBehavior", "code", "Defines the grouping behavior for the action and its children.", 0, 1, groupingBehavior); 2574 case 168639486: /*selectionBehavior*/ return new Property("selectionBehavior", "code", "Defines the selection behavior for the action and its children.", 0, 1, selectionBehavior); 2575 case -1163906287: /*requiredBehavior*/ return new Property("requiredBehavior", "code", "Defines the requiredness behavior for the action.", 0, 1, requiredBehavior); 2576 case -1174249033: /*precheckBehavior*/ return new Property("precheckBehavior", "code", "Defines whether the action should usually be preselected.", 0, 1, precheckBehavior); 2577 case -922577408: /*cardinalityBehavior*/ return new Property("cardinalityBehavior", "code", "Defines whether the action can be selected multiple times.", 0, 1, cardinalityBehavior); 2578 case -341064690: /*resource*/ return new Property("resource", "Reference(Any)", "The resource that is the target of the action (e.g. CommunicationRequest).", 0, 1, resource); 2579 case -1422950858: /*action*/ return new Property("action", "@RequestGroup.action", "Sub actions.", 0, java.lang.Integer.MAX_VALUE, action); 2580 default: return super.getNamedProperty(_hash, _name, _checkValid); 2581 } 2582 2583 } 2584 2585 @Override 2586 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2587 switch (hash) { 2588 case 102727412: /*label*/ return this.label == null ? new Base[0] : new Base[] {this.label}; // StringType 2589 case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType 2590 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 2591 case -900391049: /*textEquivalent*/ return this.textEquivalent == null ? new Base[0] : new Base[] {this.textEquivalent}; // StringType 2592 case 3059181: /*code*/ return this.code == null ? new Base[0] : this.code.toArray(new Base[this.code.size()]); // CodeableConcept 2593 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : this.documentation.toArray(new Base[this.documentation.size()]); // RelatedArtifact 2594 case -861311717: /*condition*/ return this.condition == null ? new Base[0] : this.condition.toArray(new Base[this.condition.size()]); // RequestGroupActionConditionComponent 2595 case -384107967: /*relatedAction*/ return this.relatedAction == null ? new Base[0] : this.relatedAction.toArray(new Base[this.relatedAction.size()]); // RequestGroupActionRelatedActionComponent 2596 case -873664438: /*timing*/ return this.timing == null ? new Base[0] : new Base[] {this.timing}; // Type 2597 case 767422259: /*participant*/ return this.participant == null ? new Base[0] : this.participant.toArray(new Base[this.participant.size()]); // Reference 2598 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Coding 2599 case 586678389: /*groupingBehavior*/ return this.groupingBehavior == null ? new Base[0] : new Base[] {this.groupingBehavior}; // Enumeration<ActionGroupingBehavior> 2600 case 168639486: /*selectionBehavior*/ return this.selectionBehavior == null ? new Base[0] : new Base[] {this.selectionBehavior}; // Enumeration<ActionSelectionBehavior> 2601 case -1163906287: /*requiredBehavior*/ return this.requiredBehavior == null ? new Base[0] : new Base[] {this.requiredBehavior}; // Enumeration<ActionRequiredBehavior> 2602 case -1174249033: /*precheckBehavior*/ return this.precheckBehavior == null ? new Base[0] : new Base[] {this.precheckBehavior}; // Enumeration<ActionPrecheckBehavior> 2603 case -922577408: /*cardinalityBehavior*/ return this.cardinalityBehavior == null ? new Base[0] : new Base[] {this.cardinalityBehavior}; // Enumeration<ActionCardinalityBehavior> 2604 case -341064690: /*resource*/ return this.resource == null ? new Base[0] : new Base[] {this.resource}; // Reference 2605 case -1422950858: /*action*/ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // RequestGroupActionComponent 2606 default: return super.getProperty(hash, name, checkValid); 2607 } 2608 2609 } 2610 2611 @Override 2612 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2613 switch (hash) { 2614 case 102727412: // label 2615 this.label = castToString(value); // StringType 2616 return value; 2617 case 110371416: // title 2618 this.title = castToString(value); // StringType 2619 return value; 2620 case -1724546052: // description 2621 this.description = castToString(value); // StringType 2622 return value; 2623 case -900391049: // textEquivalent 2624 this.textEquivalent = castToString(value); // StringType 2625 return value; 2626 case 3059181: // code 2627 this.getCode().add(castToCodeableConcept(value)); // CodeableConcept 2628 return value; 2629 case 1587405498: // documentation 2630 this.getDocumentation().add(castToRelatedArtifact(value)); // RelatedArtifact 2631 return value; 2632 case -861311717: // condition 2633 this.getCondition().add((RequestGroupActionConditionComponent) value); // RequestGroupActionConditionComponent 2634 return value; 2635 case -384107967: // relatedAction 2636 this.getRelatedAction().add((RequestGroupActionRelatedActionComponent) value); // RequestGroupActionRelatedActionComponent 2637 return value; 2638 case -873664438: // timing 2639 this.timing = castToType(value); // Type 2640 return value; 2641 case 767422259: // participant 2642 this.getParticipant().add(castToReference(value)); // Reference 2643 return value; 2644 case 3575610: // type 2645 this.type = castToCoding(value); // Coding 2646 return value; 2647 case 586678389: // groupingBehavior 2648 value = new ActionGroupingBehaviorEnumFactory().fromType(castToCode(value)); 2649 this.groupingBehavior = (Enumeration) value; // Enumeration<ActionGroupingBehavior> 2650 return value; 2651 case 168639486: // selectionBehavior 2652 value = new ActionSelectionBehaviorEnumFactory().fromType(castToCode(value)); 2653 this.selectionBehavior = (Enumeration) value; // Enumeration<ActionSelectionBehavior> 2654 return value; 2655 case -1163906287: // requiredBehavior 2656 value = new ActionRequiredBehaviorEnumFactory().fromType(castToCode(value)); 2657 this.requiredBehavior = (Enumeration) value; // Enumeration<ActionRequiredBehavior> 2658 return value; 2659 case -1174249033: // precheckBehavior 2660 value = new ActionPrecheckBehaviorEnumFactory().fromType(castToCode(value)); 2661 this.precheckBehavior = (Enumeration) value; // Enumeration<ActionPrecheckBehavior> 2662 return value; 2663 case -922577408: // cardinalityBehavior 2664 value = new ActionCardinalityBehaviorEnumFactory().fromType(castToCode(value)); 2665 this.cardinalityBehavior = (Enumeration) value; // Enumeration<ActionCardinalityBehavior> 2666 return value; 2667 case -341064690: // resource 2668 this.resource = castToReference(value); // Reference 2669 return value; 2670 case -1422950858: // action 2671 this.getAction().add((RequestGroupActionComponent) value); // RequestGroupActionComponent 2672 return value; 2673 default: return super.setProperty(hash, name, value); 2674 } 2675 2676 } 2677 2678 @Override 2679 public Base setProperty(String name, Base value) throws FHIRException { 2680 if (name.equals("label")) { 2681 this.label = castToString(value); // StringType 2682 } else if (name.equals("title")) { 2683 this.title = castToString(value); // StringType 2684 } else if (name.equals("description")) { 2685 this.description = castToString(value); // StringType 2686 } else if (name.equals("textEquivalent")) { 2687 this.textEquivalent = castToString(value); // StringType 2688 } else if (name.equals("code")) { 2689 this.getCode().add(castToCodeableConcept(value)); 2690 } else if (name.equals("documentation")) { 2691 this.getDocumentation().add(castToRelatedArtifact(value)); 2692 } else if (name.equals("condition")) { 2693 this.getCondition().add((RequestGroupActionConditionComponent) value); 2694 } else if (name.equals("relatedAction")) { 2695 this.getRelatedAction().add((RequestGroupActionRelatedActionComponent) value); 2696 } else if (name.equals("timing[x]")) { 2697 this.timing = castToType(value); // Type 2698 } else if (name.equals("participant")) { 2699 this.getParticipant().add(castToReference(value)); 2700 } else if (name.equals("type")) { 2701 this.type = castToCoding(value); // Coding 2702 } else if (name.equals("groupingBehavior")) { 2703 value = new ActionGroupingBehaviorEnumFactory().fromType(castToCode(value)); 2704 this.groupingBehavior = (Enumeration) value; // Enumeration<ActionGroupingBehavior> 2705 } else if (name.equals("selectionBehavior")) { 2706 value = new ActionSelectionBehaviorEnumFactory().fromType(castToCode(value)); 2707 this.selectionBehavior = (Enumeration) value; // Enumeration<ActionSelectionBehavior> 2708 } else if (name.equals("requiredBehavior")) { 2709 value = new ActionRequiredBehaviorEnumFactory().fromType(castToCode(value)); 2710 this.requiredBehavior = (Enumeration) value; // Enumeration<ActionRequiredBehavior> 2711 } else if (name.equals("precheckBehavior")) { 2712 value = new ActionPrecheckBehaviorEnumFactory().fromType(castToCode(value)); 2713 this.precheckBehavior = (Enumeration) value; // Enumeration<ActionPrecheckBehavior> 2714 } else if (name.equals("cardinalityBehavior")) { 2715 value = new ActionCardinalityBehaviorEnumFactory().fromType(castToCode(value)); 2716 this.cardinalityBehavior = (Enumeration) value; // Enumeration<ActionCardinalityBehavior> 2717 } else if (name.equals("resource")) { 2718 this.resource = castToReference(value); // Reference 2719 } else if (name.equals("action")) { 2720 this.getAction().add((RequestGroupActionComponent) value); 2721 } else 2722 return super.setProperty(name, value); 2723 return value; 2724 } 2725 2726 @Override 2727 public Base makeProperty(int hash, String name) throws FHIRException { 2728 switch (hash) { 2729 case 102727412: return getLabelElement(); 2730 case 110371416: return getTitleElement(); 2731 case -1724546052: return getDescriptionElement(); 2732 case -900391049: return getTextEquivalentElement(); 2733 case 3059181: return addCode(); 2734 case 1587405498: return addDocumentation(); 2735 case -861311717: return addCondition(); 2736 case -384107967: return addRelatedAction(); 2737 case 164632566: return getTiming(); 2738 case -873664438: return getTiming(); 2739 case 767422259: return addParticipant(); 2740 case 3575610: return getType(); 2741 case 586678389: return getGroupingBehaviorElement(); 2742 case 168639486: return getSelectionBehaviorElement(); 2743 case -1163906287: return getRequiredBehaviorElement(); 2744 case -1174249033: return getPrecheckBehaviorElement(); 2745 case -922577408: return getCardinalityBehaviorElement(); 2746 case -341064690: return getResource(); 2747 case -1422950858: return addAction(); 2748 default: return super.makeProperty(hash, name); 2749 } 2750 2751 } 2752 2753 @Override 2754 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2755 switch (hash) { 2756 case 102727412: /*label*/ return new String[] {"string"}; 2757 case 110371416: /*title*/ return new String[] {"string"}; 2758 case -1724546052: /*description*/ return new String[] {"string"}; 2759 case -900391049: /*textEquivalent*/ return new String[] {"string"}; 2760 case 3059181: /*code*/ return new String[] {"CodeableConcept"}; 2761 case 1587405498: /*documentation*/ return new String[] {"RelatedArtifact"}; 2762 case -861311717: /*condition*/ return new String[] {}; 2763 case -384107967: /*relatedAction*/ return new String[] {}; 2764 case -873664438: /*timing*/ return new String[] {"dateTime", "Period", "Duration", "Range", "Timing"}; 2765 case 767422259: /*participant*/ return new String[] {"Reference"}; 2766 case 3575610: /*type*/ return new String[] {"Coding"}; 2767 case 586678389: /*groupingBehavior*/ return new String[] {"code"}; 2768 case 168639486: /*selectionBehavior*/ return new String[] {"code"}; 2769 case -1163906287: /*requiredBehavior*/ return new String[] {"code"}; 2770 case -1174249033: /*precheckBehavior*/ return new String[] {"code"}; 2771 case -922577408: /*cardinalityBehavior*/ return new String[] {"code"}; 2772 case -341064690: /*resource*/ return new String[] {"Reference"}; 2773 case -1422950858: /*action*/ return new String[] {"@RequestGroup.action"}; 2774 default: return super.getTypesForProperty(hash, name); 2775 } 2776 2777 } 2778 2779 @Override 2780 public Base addChild(String name) throws FHIRException { 2781 if (name.equals("label")) { 2782 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.label"); 2783 } 2784 else if (name.equals("title")) { 2785 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.title"); 2786 } 2787 else if (name.equals("description")) { 2788 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.description"); 2789 } 2790 else if (name.equals("textEquivalent")) { 2791 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.textEquivalent"); 2792 } 2793 else if (name.equals("code")) { 2794 return addCode(); 2795 } 2796 else if (name.equals("documentation")) { 2797 return addDocumentation(); 2798 } 2799 else if (name.equals("condition")) { 2800 return addCondition(); 2801 } 2802 else if (name.equals("relatedAction")) { 2803 return addRelatedAction(); 2804 } 2805 else if (name.equals("timingDateTime")) { 2806 this.timing = new DateTimeType(); 2807 return this.timing; 2808 } 2809 else if (name.equals("timingPeriod")) { 2810 this.timing = new Period(); 2811 return this.timing; 2812 } 2813 else if (name.equals("timingDuration")) { 2814 this.timing = new Duration(); 2815 return this.timing; 2816 } 2817 else if (name.equals("timingRange")) { 2818 this.timing = new Range(); 2819 return this.timing; 2820 } 2821 else if (name.equals("timingTiming")) { 2822 this.timing = new Timing(); 2823 return this.timing; 2824 } 2825 else if (name.equals("participant")) { 2826 return addParticipant(); 2827 } 2828 else if (name.equals("type")) { 2829 this.type = new Coding(); 2830 return this.type; 2831 } 2832 else if (name.equals("groupingBehavior")) { 2833 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.groupingBehavior"); 2834 } 2835 else if (name.equals("selectionBehavior")) { 2836 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.selectionBehavior"); 2837 } 2838 else if (name.equals("requiredBehavior")) { 2839 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.requiredBehavior"); 2840 } 2841 else if (name.equals("precheckBehavior")) { 2842 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.precheckBehavior"); 2843 } 2844 else if (name.equals("cardinalityBehavior")) { 2845 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.cardinalityBehavior"); 2846 } 2847 else if (name.equals("resource")) { 2848 this.resource = new Reference(); 2849 return this.resource; 2850 } 2851 else if (name.equals("action")) { 2852 return addAction(); 2853 } 2854 else 2855 return super.addChild(name); 2856 } 2857 2858 public RequestGroupActionComponent copy() { 2859 RequestGroupActionComponent dst = new RequestGroupActionComponent(); 2860 copyValues(dst); 2861 dst.label = label == null ? null : label.copy(); 2862 dst.title = title == null ? null : title.copy(); 2863 dst.description = description == null ? null : description.copy(); 2864 dst.textEquivalent = textEquivalent == null ? null : textEquivalent.copy(); 2865 if (code != null) { 2866 dst.code = new ArrayList<CodeableConcept>(); 2867 for (CodeableConcept i : code) 2868 dst.code.add(i.copy()); 2869 }; 2870 if (documentation != null) { 2871 dst.documentation = new ArrayList<RelatedArtifact>(); 2872 for (RelatedArtifact i : documentation) 2873 dst.documentation.add(i.copy()); 2874 }; 2875 if (condition != null) { 2876 dst.condition = new ArrayList<RequestGroupActionConditionComponent>(); 2877 for (RequestGroupActionConditionComponent i : condition) 2878 dst.condition.add(i.copy()); 2879 }; 2880 if (relatedAction != null) { 2881 dst.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>(); 2882 for (RequestGroupActionRelatedActionComponent i : relatedAction) 2883 dst.relatedAction.add(i.copy()); 2884 }; 2885 dst.timing = timing == null ? null : timing.copy(); 2886 if (participant != null) { 2887 dst.participant = new ArrayList<Reference>(); 2888 for (Reference i : participant) 2889 dst.participant.add(i.copy()); 2890 }; 2891 dst.type = type == null ? null : type.copy(); 2892 dst.groupingBehavior = groupingBehavior == null ? null : groupingBehavior.copy(); 2893 dst.selectionBehavior = selectionBehavior == null ? null : selectionBehavior.copy(); 2894 dst.requiredBehavior = requiredBehavior == null ? null : requiredBehavior.copy(); 2895 dst.precheckBehavior = precheckBehavior == null ? null : precheckBehavior.copy(); 2896 dst.cardinalityBehavior = cardinalityBehavior == null ? null : cardinalityBehavior.copy(); 2897 dst.resource = resource == null ? null : resource.copy(); 2898 if (action != null) { 2899 dst.action = new ArrayList<RequestGroupActionComponent>(); 2900 for (RequestGroupActionComponent i : action) 2901 dst.action.add(i.copy()); 2902 }; 2903 return dst; 2904 } 2905 2906 @Override 2907 public boolean equalsDeep(Base other_) { 2908 if (!super.equalsDeep(other_)) 2909 return false; 2910 if (!(other_ instanceof RequestGroupActionComponent)) 2911 return false; 2912 RequestGroupActionComponent o = (RequestGroupActionComponent) other_; 2913 return compareDeep(label, o.label, true) && compareDeep(title, o.title, true) && compareDeep(description, o.description, true) 2914 && compareDeep(textEquivalent, o.textEquivalent, true) && compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true) 2915 && compareDeep(condition, o.condition, true) && compareDeep(relatedAction, o.relatedAction, true) 2916 && compareDeep(timing, o.timing, true) && compareDeep(participant, o.participant, true) && compareDeep(type, o.type, true) 2917 && compareDeep(groupingBehavior, o.groupingBehavior, true) && compareDeep(selectionBehavior, o.selectionBehavior, true) 2918 && compareDeep(requiredBehavior, o.requiredBehavior, true) && compareDeep(precheckBehavior, o.precheckBehavior, true) 2919 && compareDeep(cardinalityBehavior, o.cardinalityBehavior, true) && compareDeep(resource, o.resource, true) 2920 && compareDeep(action, o.action, true); 2921 } 2922 2923 @Override 2924 public boolean equalsShallow(Base other_) { 2925 if (!super.equalsShallow(other_)) 2926 return false; 2927 if (!(other_ instanceof RequestGroupActionComponent)) 2928 return false; 2929 RequestGroupActionComponent o = (RequestGroupActionComponent) other_; 2930 return compareValues(label, o.label, true) && compareValues(title, o.title, true) && compareValues(description, o.description, true) 2931 && compareValues(textEquivalent, o.textEquivalent, true) && compareValues(groupingBehavior, o.groupingBehavior, true) 2932 && compareValues(selectionBehavior, o.selectionBehavior, true) && compareValues(requiredBehavior, o.requiredBehavior, true) 2933 && compareValues(precheckBehavior, o.precheckBehavior, true) && compareValues(cardinalityBehavior, o.cardinalityBehavior, true) 2934 ; 2935 } 2936 2937 public boolean isEmpty() { 2938 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(label, title, description 2939 , textEquivalent, code, documentation, condition, relatedAction, timing, participant 2940 , type, groupingBehavior, selectionBehavior, requiredBehavior, precheckBehavior, cardinalityBehavior 2941 , resource, action); 2942 } 2943 2944 public String fhirType() { 2945 return "RequestGroup.action"; 2946 2947 } 2948 2949 } 2950 2951 @Block() 2952 public static class RequestGroupActionConditionComponent extends BackboneElement implements IBaseBackboneElement { 2953 /** 2954 * The kind of condition. 2955 */ 2956 @Child(name = "kind", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 2957 @Description(shortDefinition="applicability | start | stop", formalDefinition="The kind of condition." ) 2958 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-condition-kind") 2959 protected Enumeration<ActionConditionKind> kind; 2960 2961 /** 2962 * A brief, natural language description of the condition that effectively communicates the intended semantics. 2963 */ 2964 @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false) 2965 @Description(shortDefinition="Natural language description of the condition", formalDefinition="A brief, natural language description of the condition that effectively communicates the intended semantics." ) 2966 protected StringType description; 2967 2968 /** 2969 * The media type of the language for the expression. 2970 */ 2971 @Child(name = "language", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false) 2972 @Description(shortDefinition="Language of the expression", formalDefinition="The media type of the language for the expression." ) 2973 protected StringType language; 2974 2975 /** 2976 * An expression that returns true or false, indicating whether or not the condition is satisfied. 2977 */ 2978 @Child(name = "expression", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false) 2979 @Description(shortDefinition="Boolean-valued expression", formalDefinition="An expression that returns true or false, indicating whether or not the condition is satisfied." ) 2980 protected StringType expression; 2981 2982 private static final long serialVersionUID = 944300105L; 2983 2984 /** 2985 * Constructor 2986 */ 2987 public RequestGroupActionConditionComponent() { 2988 super(); 2989 } 2990 2991 /** 2992 * Constructor 2993 */ 2994 public RequestGroupActionConditionComponent(Enumeration<ActionConditionKind> kind) { 2995 super(); 2996 this.kind = kind; 2997 } 2998 2999 /** 3000 * @return {@link #kind} (The kind of condition.). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value 3001 */ 3002 public Enumeration<ActionConditionKind> getKindElement() { 3003 if (this.kind == null) 3004 if (Configuration.errorOnAutoCreate()) 3005 throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.kind"); 3006 else if (Configuration.doAutoCreate()) 3007 this.kind = new Enumeration<ActionConditionKind>(new ActionConditionKindEnumFactory()); // bb 3008 return this.kind; 3009 } 3010 3011 public boolean hasKindElement() { 3012 return this.kind != null && !this.kind.isEmpty(); 3013 } 3014 3015 public boolean hasKind() { 3016 return this.kind != null && !this.kind.isEmpty(); 3017 } 3018 3019 /** 3020 * @param value {@link #kind} (The kind of condition.). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value 3021 */ 3022 public RequestGroupActionConditionComponent setKindElement(Enumeration<ActionConditionKind> value) { 3023 this.kind = value; 3024 return this; 3025 } 3026 3027 /** 3028 * @return The kind of condition. 3029 */ 3030 public ActionConditionKind getKind() { 3031 return this.kind == null ? null : this.kind.getValue(); 3032 } 3033 3034 /** 3035 * @param value The kind of condition. 3036 */ 3037 public RequestGroupActionConditionComponent setKind(ActionConditionKind value) { 3038 if (this.kind == null) 3039 this.kind = new Enumeration<ActionConditionKind>(new ActionConditionKindEnumFactory()); 3040 this.kind.setValue(value); 3041 return this; 3042 } 3043 3044 /** 3045 * @return {@link #description} (A brief, natural language description of the condition that effectively communicates the intended semantics.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 3046 */ 3047 public StringType getDescriptionElement() { 3048 if (this.description == null) 3049 if (Configuration.errorOnAutoCreate()) 3050 throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.description"); 3051 else if (Configuration.doAutoCreate()) 3052 this.description = new StringType(); // bb 3053 return this.description; 3054 } 3055 3056 public boolean hasDescriptionElement() { 3057 return this.description != null && !this.description.isEmpty(); 3058 } 3059 3060 public boolean hasDescription() { 3061 return this.description != null && !this.description.isEmpty(); 3062 } 3063 3064 /** 3065 * @param value {@link #description} (A brief, natural language description of the condition that effectively communicates the intended semantics.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 3066 */ 3067 public RequestGroupActionConditionComponent setDescriptionElement(StringType value) { 3068 this.description = value; 3069 return this; 3070 } 3071 3072 /** 3073 * @return A brief, natural language description of the condition that effectively communicates the intended semantics. 3074 */ 3075 public String getDescription() { 3076 return this.description == null ? null : this.description.getValue(); 3077 } 3078 3079 /** 3080 * @param value A brief, natural language description of the condition that effectively communicates the intended semantics. 3081 */ 3082 public RequestGroupActionConditionComponent setDescription(String value) { 3083 if (Utilities.noString(value)) 3084 this.description = null; 3085 else { 3086 if (this.description == null) 3087 this.description = new StringType(); 3088 this.description.setValue(value); 3089 } 3090 return this; 3091 } 3092 3093 /** 3094 * @return {@link #language} (The media type of the language for the expression.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value 3095 */ 3096 public StringType getLanguageElement() { 3097 if (this.language == null) 3098 if (Configuration.errorOnAutoCreate()) 3099 throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.language"); 3100 else if (Configuration.doAutoCreate()) 3101 this.language = new StringType(); // bb 3102 return this.language; 3103 } 3104 3105 public boolean hasLanguageElement() { 3106 return this.language != null && !this.language.isEmpty(); 3107 } 3108 3109 public boolean hasLanguage() { 3110 return this.language != null && !this.language.isEmpty(); 3111 } 3112 3113 /** 3114 * @param value {@link #language} (The media type of the language for the expression.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value 3115 */ 3116 public RequestGroupActionConditionComponent setLanguageElement(StringType value) { 3117 this.language = value; 3118 return this; 3119 } 3120 3121 /** 3122 * @return The media type of the language for the expression. 3123 */ 3124 public String getLanguage() { 3125 return this.language == null ? null : this.language.getValue(); 3126 } 3127 3128 /** 3129 * @param value The media type of the language for the expression. 3130 */ 3131 public RequestGroupActionConditionComponent setLanguage(String value) { 3132 if (Utilities.noString(value)) 3133 this.language = null; 3134 else { 3135 if (this.language == null) 3136 this.language = new StringType(); 3137 this.language.setValue(value); 3138 } 3139 return this; 3140 } 3141 3142 /** 3143 * @return {@link #expression} (An expression that returns true or false, indicating whether or not the condition is satisfied.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value 3144 */ 3145 public StringType getExpressionElement() { 3146 if (this.expression == null) 3147 if (Configuration.errorOnAutoCreate()) 3148 throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.expression"); 3149 else if (Configuration.doAutoCreate()) 3150 this.expression = new StringType(); // bb 3151 return this.expression; 3152 } 3153 3154 public boolean hasExpressionElement() { 3155 return this.expression != null && !this.expression.isEmpty(); 3156 } 3157 3158 public boolean hasExpression() { 3159 return this.expression != null && !this.expression.isEmpty(); 3160 } 3161 3162 /** 3163 * @param value {@link #expression} (An expression that returns true or false, indicating whether or not the condition is satisfied.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value 3164 */ 3165 public RequestGroupActionConditionComponent setExpressionElement(StringType value) { 3166 this.expression = value; 3167 return this; 3168 } 3169 3170 /** 3171 * @return An expression that returns true or false, indicating whether or not the condition is satisfied. 3172 */ 3173 public String getExpression() { 3174 return this.expression == null ? null : this.expression.getValue(); 3175 } 3176 3177 /** 3178 * @param value An expression that returns true or false, indicating whether or not the condition is satisfied. 3179 */ 3180 public RequestGroupActionConditionComponent setExpression(String value) { 3181 if (Utilities.noString(value)) 3182 this.expression = null; 3183 else { 3184 if (this.expression == null) 3185 this.expression = new StringType(); 3186 this.expression.setValue(value); 3187 } 3188 return this; 3189 } 3190 3191 protected void listChildren(List<Property> children) { 3192 super.listChildren(children); 3193 children.add(new Property("kind", "code", "The kind of condition.", 0, 1, kind)); 3194 children.add(new Property("description", "string", "A brief, natural language description of the condition that effectively communicates the intended semantics.", 0, 1, description)); 3195 children.add(new Property("language", "string", "The media type of the language for the expression.", 0, 1, language)); 3196 children.add(new Property("expression", "string", "An expression that returns true or false, indicating whether or not the condition is satisfied.", 0, 1, expression)); 3197 } 3198 3199 @Override 3200 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3201 switch (_hash) { 3202 case 3292052: /*kind*/ return new Property("kind", "code", "The kind of condition.", 0, 1, kind); 3203 case -1724546052: /*description*/ return new Property("description", "string", "A brief, natural language description of the condition that effectively communicates the intended semantics.", 0, 1, description); 3204 case -1613589672: /*language*/ return new Property("language", "string", "The media type of the language for the expression.", 0, 1, language); 3205 case -1795452264: /*expression*/ return new Property("expression", "string", "An expression that returns true or false, indicating whether or not the condition is satisfied.", 0, 1, expression); 3206 default: return super.getNamedProperty(_hash, _name, _checkValid); 3207 } 3208 3209 } 3210 3211 @Override 3212 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3213 switch (hash) { 3214 case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<ActionConditionKind> 3215 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 3216 case -1613589672: /*language*/ return this.language == null ? new Base[0] : new Base[] {this.language}; // StringType 3217 case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType 3218 default: return super.getProperty(hash, name, checkValid); 3219 } 3220 3221 } 3222 3223 @Override 3224 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3225 switch (hash) { 3226 case 3292052: // kind 3227 value = new ActionConditionKindEnumFactory().fromType(castToCode(value)); 3228 this.kind = (Enumeration) value; // Enumeration<ActionConditionKind> 3229 return value; 3230 case -1724546052: // description 3231 this.description = castToString(value); // StringType 3232 return value; 3233 case -1613589672: // language 3234 this.language = castToString(value); // StringType 3235 return value; 3236 case -1795452264: // expression 3237 this.expression = castToString(value); // StringType 3238 return value; 3239 default: return super.setProperty(hash, name, value); 3240 } 3241 3242 } 3243 3244 @Override 3245 public Base setProperty(String name, Base value) throws FHIRException { 3246 if (name.equals("kind")) { 3247 value = new ActionConditionKindEnumFactory().fromType(castToCode(value)); 3248 this.kind = (Enumeration) value; // Enumeration<ActionConditionKind> 3249 } else if (name.equals("description")) { 3250 this.description = castToString(value); // StringType 3251 } else if (name.equals("language")) { 3252 this.language = castToString(value); // StringType 3253 } else if (name.equals("expression")) { 3254 this.expression = castToString(value); // StringType 3255 } else 3256 return super.setProperty(name, value); 3257 return value; 3258 } 3259 3260 @Override 3261 public Base makeProperty(int hash, String name) throws FHIRException { 3262 switch (hash) { 3263 case 3292052: return getKindElement(); 3264 case -1724546052: return getDescriptionElement(); 3265 case -1613589672: return getLanguageElement(); 3266 case -1795452264: return getExpressionElement(); 3267 default: return super.makeProperty(hash, name); 3268 } 3269 3270 } 3271 3272 @Override 3273 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3274 switch (hash) { 3275 case 3292052: /*kind*/ return new String[] {"code"}; 3276 case -1724546052: /*description*/ return new String[] {"string"}; 3277 case -1613589672: /*language*/ return new String[] {"string"}; 3278 case -1795452264: /*expression*/ return new String[] {"string"}; 3279 default: return super.getTypesForProperty(hash, name); 3280 } 3281 3282 } 3283 3284 @Override 3285 public Base addChild(String name) throws FHIRException { 3286 if (name.equals("kind")) { 3287 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.kind"); 3288 } 3289 else if (name.equals("description")) { 3290 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.description"); 3291 } 3292 else if (name.equals("language")) { 3293 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.language"); 3294 } 3295 else if (name.equals("expression")) { 3296 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.expression"); 3297 } 3298 else 3299 return super.addChild(name); 3300 } 3301 3302 public RequestGroupActionConditionComponent copy() { 3303 RequestGroupActionConditionComponent dst = new RequestGroupActionConditionComponent(); 3304 copyValues(dst); 3305 dst.kind = kind == null ? null : kind.copy(); 3306 dst.description = description == null ? null : description.copy(); 3307 dst.language = language == null ? null : language.copy(); 3308 dst.expression = expression == null ? null : expression.copy(); 3309 return dst; 3310 } 3311 3312 @Override 3313 public boolean equalsDeep(Base other_) { 3314 if (!super.equalsDeep(other_)) 3315 return false; 3316 if (!(other_ instanceof RequestGroupActionConditionComponent)) 3317 return false; 3318 RequestGroupActionConditionComponent o = (RequestGroupActionConditionComponent) other_; 3319 return compareDeep(kind, o.kind, true) && compareDeep(description, o.description, true) && compareDeep(language, o.language, true) 3320 && compareDeep(expression, o.expression, true); 3321 } 3322 3323 @Override 3324 public boolean equalsShallow(Base other_) { 3325 if (!super.equalsShallow(other_)) 3326 return false; 3327 if (!(other_ instanceof RequestGroupActionConditionComponent)) 3328 return false; 3329 RequestGroupActionConditionComponent o = (RequestGroupActionConditionComponent) other_; 3330 return compareValues(kind, o.kind, true) && compareValues(description, o.description, true) && compareValues(language, o.language, true) 3331 && compareValues(expression, o.expression, true); 3332 } 3333 3334 public boolean isEmpty() { 3335 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(kind, description, language 3336 , expression); 3337 } 3338 3339 public String fhirType() { 3340 return "RequestGroup.action.condition"; 3341 3342 } 3343 3344 } 3345 3346 @Block() 3347 public static class RequestGroupActionRelatedActionComponent extends BackboneElement implements IBaseBackboneElement { 3348 /** 3349 * The element id of the action this is related to. 3350 */ 3351 @Child(name = "actionId", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=false) 3352 @Description(shortDefinition="What action this is related to", formalDefinition="The element id of the action this is related to." ) 3353 protected IdType actionId; 3354 3355 /** 3356 * The relationship of this action to the related action. 3357 */ 3358 @Child(name = "relationship", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=false) 3359 @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." ) 3360 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-relationship-type") 3361 protected Enumeration<ActionRelationshipType> relationship; 3362 3363 /** 3364 * A duration or range of durations to apply to the relationship. For example, 30-60 minutes before. 3365 */ 3366 @Child(name = "offset", type = {Duration.class, Range.class}, order=3, min=0, max=1, modifier=false, summary=false) 3367 @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." ) 3368 protected Type offset; 3369 3370 private static final long serialVersionUID = 1063306770L; 3371 3372 /** 3373 * Constructor 3374 */ 3375 public RequestGroupActionRelatedActionComponent() { 3376 super(); 3377 } 3378 3379 /** 3380 * Constructor 3381 */ 3382 public RequestGroupActionRelatedActionComponent(IdType actionId, Enumeration<ActionRelationshipType> relationship) { 3383 super(); 3384 this.actionId = actionId; 3385 this.relationship = relationship; 3386 } 3387 3388 /** 3389 * @return {@link #actionId} (The element id of the action this is related to.). This is the underlying object with id, value and extensions. The accessor "getActionId" gives direct access to the value 3390 */ 3391 public IdType getActionIdElement() { 3392 if (this.actionId == null) 3393 if (Configuration.errorOnAutoCreate()) 3394 throw new Error("Attempt to auto-create RequestGroupActionRelatedActionComponent.actionId"); 3395 else if (Configuration.doAutoCreate()) 3396 this.actionId = new IdType(); // bb 3397 return this.actionId; 3398 } 3399 3400 public boolean hasActionIdElement() { 3401 return this.actionId != null && !this.actionId.isEmpty(); 3402 } 3403 3404 public boolean hasActionId() { 3405 return this.actionId != null && !this.actionId.isEmpty(); 3406 } 3407 3408 /** 3409 * @param value {@link #actionId} (The element id of the action this is related to.). This is the underlying object with id, value and extensions. The accessor "getActionId" gives direct access to the value 3410 */ 3411 public RequestGroupActionRelatedActionComponent setActionIdElement(IdType value) { 3412 this.actionId = value; 3413 return this; 3414 } 3415 3416 /** 3417 * @return The element id of the action this is related to. 3418 */ 3419 public String getActionId() { 3420 return this.actionId == null ? null : this.actionId.getValue(); 3421 } 3422 3423 /** 3424 * @param value The element id of the action this is related to. 3425 */ 3426 public RequestGroupActionRelatedActionComponent setActionId(String value) { 3427 if (this.actionId == null) 3428 this.actionId = new IdType(); 3429 this.actionId.setValue(value); 3430 return this; 3431 } 3432 3433 /** 3434 * @return {@link #relationship} (The relationship of this action to the related action.). This is the underlying object with id, value and extensions. The accessor "getRelationship" gives direct access to the value 3435 */ 3436 public Enumeration<ActionRelationshipType> getRelationshipElement() { 3437 if (this.relationship == null) 3438 if (Configuration.errorOnAutoCreate()) 3439 throw new Error("Attempt to auto-create RequestGroupActionRelatedActionComponent.relationship"); 3440 else if (Configuration.doAutoCreate()) 3441 this.relationship = new Enumeration<ActionRelationshipType>(new ActionRelationshipTypeEnumFactory()); // bb 3442 return this.relationship; 3443 } 3444 3445 public boolean hasRelationshipElement() { 3446 return this.relationship != null && !this.relationship.isEmpty(); 3447 } 3448 3449 public boolean hasRelationship() { 3450 return this.relationship != null && !this.relationship.isEmpty(); 3451 } 3452 3453 /** 3454 * @param value {@link #relationship} (The relationship of this action to the related action.). This is the underlying object with id, value and extensions. The accessor "getRelationship" gives direct access to the value 3455 */ 3456 public RequestGroupActionRelatedActionComponent setRelationshipElement(Enumeration<ActionRelationshipType> value) { 3457 this.relationship = value; 3458 return this; 3459 } 3460 3461 /** 3462 * @return The relationship of this action to the related action. 3463 */ 3464 public ActionRelationshipType getRelationship() { 3465 return this.relationship == null ? null : this.relationship.getValue(); 3466 } 3467 3468 /** 3469 * @param value The relationship of this action to the related action. 3470 */ 3471 public RequestGroupActionRelatedActionComponent setRelationship(ActionRelationshipType value) { 3472 if (this.relationship == null) 3473 this.relationship = new Enumeration<ActionRelationshipType>(new ActionRelationshipTypeEnumFactory()); 3474 this.relationship.setValue(value); 3475 return this; 3476 } 3477 3478 /** 3479 * @return {@link #offset} (A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.) 3480 */ 3481 public Type getOffset() { 3482 return this.offset; 3483 } 3484 3485 /** 3486 * @return {@link #offset} (A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.) 3487 */ 3488 public Duration getOffsetDuration() throws FHIRException { 3489 if (this.offset == null) 3490 return null; 3491 if (!(this.offset instanceof Duration)) 3492 throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.offset.getClass().getName()+" was encountered"); 3493 return (Duration) this.offset; 3494 } 3495 3496 public boolean hasOffsetDuration() { 3497 return this != null && this.offset instanceof Duration; 3498 } 3499 3500 /** 3501 * @return {@link #offset} (A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.) 3502 */ 3503 public Range getOffsetRange() throws FHIRException { 3504 if (this.offset == null) 3505 return null; 3506 if (!(this.offset instanceof Range)) 3507 throw new FHIRException("Type mismatch: the type Range was expected, but "+this.offset.getClass().getName()+" was encountered"); 3508 return (Range) this.offset; 3509 } 3510 3511 public boolean hasOffsetRange() { 3512 return this != null && this.offset instanceof Range; 3513 } 3514 3515 public boolean hasOffset() { 3516 return this.offset != null && !this.offset.isEmpty(); 3517 } 3518 3519 /** 3520 * @param value {@link #offset} (A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.) 3521 */ 3522 public RequestGroupActionRelatedActionComponent setOffset(Type value) throws FHIRFormatError { 3523 if (value != null && !(value instanceof Duration || value instanceof Range)) 3524 throw new FHIRFormatError("Not the right type for RequestGroup.action.relatedAction.offset[x]: "+value.fhirType()); 3525 this.offset = value; 3526 return this; 3527 } 3528 3529 protected void listChildren(List<Property> children) { 3530 super.listChildren(children); 3531 children.add(new Property("actionId", "id", "The element id of the action this is related to.", 0, 1, actionId)); 3532 children.add(new Property("relationship", "code", "The relationship of this action to the related action.", 0, 1, relationship)); 3533 children.add(new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset)); 3534 } 3535 3536 @Override 3537 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3538 switch (_hash) { 3539 case -1656172047: /*actionId*/ return new Property("actionId", "id", "The element id of the action this is related to.", 0, 1, actionId); 3540 case -261851592: /*relationship*/ return new Property("relationship", "code", "The relationship of this action to the related action.", 0, 1, relationship); 3541 case -1960684787: /*offset[x]*/ return new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset); 3542 case -1019779949: /*offset*/ return new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset); 3543 case 134075207: /*offsetDuration*/ return new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset); 3544 case 1263585386: /*offsetRange*/ return new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset); 3545 default: return super.getNamedProperty(_hash, _name, _checkValid); 3546 } 3547 3548 } 3549 3550 @Override 3551 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3552 switch (hash) { 3553 case -1656172047: /*actionId*/ return this.actionId == null ? new Base[0] : new Base[] {this.actionId}; // IdType 3554 case -261851592: /*relationship*/ return this.relationship == null ? new Base[0] : new Base[] {this.relationship}; // Enumeration<ActionRelationshipType> 3555 case -1019779949: /*offset*/ return this.offset == null ? new Base[0] : new Base[] {this.offset}; // Type 3556 default: return super.getProperty(hash, name, checkValid); 3557 } 3558 3559 } 3560 3561 @Override 3562 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3563 switch (hash) { 3564 case -1656172047: // actionId 3565 this.actionId = castToId(value); // IdType 3566 return value; 3567 case -261851592: // relationship 3568 value = new ActionRelationshipTypeEnumFactory().fromType(castToCode(value)); 3569 this.relationship = (Enumeration) value; // Enumeration<ActionRelationshipType> 3570 return value; 3571 case -1019779949: // offset 3572 this.offset = castToType(value); // Type 3573 return value; 3574 default: return super.setProperty(hash, name, value); 3575 } 3576 3577 } 3578 3579 @Override 3580 public Base setProperty(String name, Base value) throws FHIRException { 3581 if (name.equals("actionId")) { 3582 this.actionId = castToId(value); // IdType 3583 } else if (name.equals("relationship")) { 3584 value = new ActionRelationshipTypeEnumFactory().fromType(castToCode(value)); 3585 this.relationship = (Enumeration) value; // Enumeration<ActionRelationshipType> 3586 } else if (name.equals("offset[x]")) { 3587 this.offset = castToType(value); // Type 3588 } else 3589 return super.setProperty(name, value); 3590 return value; 3591 } 3592 3593 @Override 3594 public Base makeProperty(int hash, String name) throws FHIRException { 3595 switch (hash) { 3596 case -1656172047: return getActionIdElement(); 3597 case -261851592: return getRelationshipElement(); 3598 case -1960684787: return getOffset(); 3599 case -1019779949: return getOffset(); 3600 default: return super.makeProperty(hash, name); 3601 } 3602 3603 } 3604 3605 @Override 3606 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3607 switch (hash) { 3608 case -1656172047: /*actionId*/ return new String[] {"id"}; 3609 case -261851592: /*relationship*/ return new String[] {"code"}; 3610 case -1019779949: /*offset*/ return new String[] {"Duration", "Range"}; 3611 default: return super.getTypesForProperty(hash, name); 3612 } 3613 3614 } 3615 3616 @Override 3617 public Base addChild(String name) throws FHIRException { 3618 if (name.equals("actionId")) { 3619 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.actionId"); 3620 } 3621 else if (name.equals("relationship")) { 3622 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.relationship"); 3623 } 3624 else if (name.equals("offsetDuration")) { 3625 this.offset = new Duration(); 3626 return this.offset; 3627 } 3628 else if (name.equals("offsetRange")) { 3629 this.offset = new Range(); 3630 return this.offset; 3631 } 3632 else 3633 return super.addChild(name); 3634 } 3635 3636 public RequestGroupActionRelatedActionComponent copy() { 3637 RequestGroupActionRelatedActionComponent dst = new RequestGroupActionRelatedActionComponent(); 3638 copyValues(dst); 3639 dst.actionId = actionId == null ? null : actionId.copy(); 3640 dst.relationship = relationship == null ? null : relationship.copy(); 3641 dst.offset = offset == null ? null : offset.copy(); 3642 return dst; 3643 } 3644 3645 @Override 3646 public boolean equalsDeep(Base other_) { 3647 if (!super.equalsDeep(other_)) 3648 return false; 3649 if (!(other_ instanceof RequestGroupActionRelatedActionComponent)) 3650 return false; 3651 RequestGroupActionRelatedActionComponent o = (RequestGroupActionRelatedActionComponent) other_; 3652 return compareDeep(actionId, o.actionId, true) && compareDeep(relationship, o.relationship, true) 3653 && compareDeep(offset, o.offset, true); 3654 } 3655 3656 @Override 3657 public boolean equalsShallow(Base other_) { 3658 if (!super.equalsShallow(other_)) 3659 return false; 3660 if (!(other_ instanceof RequestGroupActionRelatedActionComponent)) 3661 return false; 3662 RequestGroupActionRelatedActionComponent o = (RequestGroupActionRelatedActionComponent) other_; 3663 return compareValues(actionId, o.actionId, true) && compareValues(relationship, o.relationship, true) 3664 ; 3665 } 3666 3667 public boolean isEmpty() { 3668 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(actionId, relationship, offset 3669 ); 3670 } 3671 3672 public String fhirType() { 3673 return "RequestGroup.action.relatedAction"; 3674 3675 } 3676 3677 } 3678 3679 /** 3680 * Allows a service to provide a unique, business identifier for the request. 3681 */ 3682 @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 3683 @Description(shortDefinition="Business identifier", formalDefinition="Allows a service to provide a unique, business identifier for the request." ) 3684 protected List<Identifier> identifier; 3685 3686 /** 3687 * A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request. 3688 */ 3689 @Child(name = "definition", type = {Reference.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3690 @Description(shortDefinition="Instantiates protocol or definition", formalDefinition="A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request." ) 3691 protected List<Reference> definition; 3692 /** 3693 * The actual objects that are the target of the reference (A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.) 3694 */ 3695 protected List<Resource> definitionTarget; 3696 3697 3698 /** 3699 * A plan, proposal or order that is fulfilled in whole or in part by this request. 3700 */ 3701 @Child(name = "basedOn", type = {Reference.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3702 @Description(shortDefinition="Fulfills plan, proposal, or order", formalDefinition="A plan, proposal or order that is fulfilled in whole or in part by this request." ) 3703 protected List<Reference> basedOn; 3704 /** 3705 * The actual objects that are the target of the reference (A plan, proposal or order that is fulfilled in whole or in part by this request.) 3706 */ 3707 protected List<Resource> basedOnTarget; 3708 3709 3710 /** 3711 * Completed or terminated request(s) whose function is taken by this new request. 3712 */ 3713 @Child(name = "replaces", type = {Reference.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3714 @Description(shortDefinition="Request(s) replaced by this request", formalDefinition="Completed or terminated request(s) whose function is taken by this new request." ) 3715 protected List<Reference> replaces; 3716 /** 3717 * The actual objects that are the target of the reference (Completed or terminated request(s) whose function is taken by this new request.) 3718 */ 3719 protected List<Resource> replacesTarget; 3720 3721 3722 /** 3723 * 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. 3724 */ 3725 @Child(name = "groupIdentifier", type = {Identifier.class}, order=4, min=0, max=1, modifier=false, summary=true) 3726 @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." ) 3727 protected Identifier groupIdentifier; 3728 3729 /** 3730 * The current state of the request. For request groups, the status reflects the status of all the requests in the group. 3731 */ 3732 @Child(name = "status", type = {CodeType.class}, order=5, min=1, max=1, modifier=true, summary=true) 3733 @Description(shortDefinition="draft | active | suspended | cancelled | 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." ) 3734 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/request-status") 3735 protected Enumeration<RequestStatus> status; 3736 3737 /** 3738 * Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain. 3739 */ 3740 @Child(name = "intent", type = {CodeType.class}, order=6, min=1, max=1, modifier=true, summary=true) 3741 @Description(shortDefinition="proposal | plan | order", formalDefinition="Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain." ) 3742 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/request-intent") 3743 protected Enumeration<RequestIntent> intent; 3744 3745 /** 3746 * Indicates how quickly the request should be addressed with respect to other requests. 3747 */ 3748 @Child(name = "priority", type = {CodeType.class}, order=7, min=0, max=1, modifier=false, summary=true) 3749 @Description(shortDefinition="routine | urgent | asap | stat", formalDefinition="Indicates how quickly the request should be addressed with respect to other requests." ) 3750 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/request-priority") 3751 protected Enumeration<RequestPriority> priority; 3752 3753 /** 3754 * The subject for which the request group was created. 3755 */ 3756 @Child(name = "subject", type = {Patient.class, Group.class}, order=8, min=0, max=1, modifier=false, summary=false) 3757 @Description(shortDefinition="Who the request group is about", formalDefinition="The subject for which the request group was created." ) 3758 protected Reference subject; 3759 3760 /** 3761 * The actual object that is the target of the reference (The subject for which the request group was created.) 3762 */ 3763 protected Resource subjectTarget; 3764 3765 /** 3766 * Describes the context of the request group, if any. 3767 */ 3768 @Child(name = "context", type = {Encounter.class, EpisodeOfCare.class}, order=9, min=0, max=1, modifier=false, summary=false) 3769 @Description(shortDefinition="Encounter or Episode for the request group", formalDefinition="Describes the context of the request group, if any." ) 3770 protected Reference context; 3771 3772 /** 3773 * The actual object that is the target of the reference (Describes the context of the request group, if any.) 3774 */ 3775 protected Resource contextTarget; 3776 3777 /** 3778 * Indicates when the request group was created. 3779 */ 3780 @Child(name = "authoredOn", type = {DateTimeType.class}, order=10, min=0, max=1, modifier=false, summary=false) 3781 @Description(shortDefinition="When the request group was authored", formalDefinition="Indicates when the request group was created." ) 3782 protected DateTimeType authoredOn; 3783 3784 /** 3785 * Provides a reference to the author of the request group. 3786 */ 3787 @Child(name = "author", type = {Device.class, Practitioner.class}, order=11, min=0, max=1, modifier=false, summary=false) 3788 @Description(shortDefinition="Device or practitioner that authored the request group", formalDefinition="Provides a reference to the author of the request group." ) 3789 protected Reference author; 3790 3791 /** 3792 * The actual object that is the target of the reference (Provides a reference to the author of the request group.) 3793 */ 3794 protected Resource authorTarget; 3795 3796 /** 3797 * Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response. 3798 */ 3799 @Child(name = "reason", type = {CodeableConcept.class, Reference.class}, order=12, min=0, max=1, modifier=false, summary=false) 3800 @Description(shortDefinition="Reason for the request group", formalDefinition="Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response." ) 3801 protected Type reason; 3802 3803 /** 3804 * Provides a mechanism to communicate additional information about the response. 3805 */ 3806 @Child(name = "note", type = {Annotation.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3807 @Description(shortDefinition="Additional notes about the response", formalDefinition="Provides a mechanism to communicate additional information about the response." ) 3808 protected List<Annotation> note; 3809 3810 /** 3811 * The actions, if any, produced by the evaluation of the artifact. 3812 */ 3813 @Child(name = "action", type = {}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3814 @Description(shortDefinition="Proposed actions, if any", formalDefinition="The actions, if any, produced by the evaluation of the artifact." ) 3815 protected List<RequestGroupActionComponent> action; 3816 3817 private static final long serialVersionUID = -1812083587L; 3818 3819 /** 3820 * Constructor 3821 */ 3822 public RequestGroup() { 3823 super(); 3824 } 3825 3826 /** 3827 * Constructor 3828 */ 3829 public RequestGroup(Enumeration<RequestStatus> status, Enumeration<RequestIntent> intent) { 3830 super(); 3831 this.status = status; 3832 this.intent = intent; 3833 } 3834 3835 /** 3836 * @return {@link #identifier} (Allows a service to provide a unique, business identifier for the request.) 3837 */ 3838 public List<Identifier> getIdentifier() { 3839 if (this.identifier == null) 3840 this.identifier = new ArrayList<Identifier>(); 3841 return this.identifier; 3842 } 3843 3844 /** 3845 * @return Returns a reference to <code>this</code> for easy method chaining 3846 */ 3847 public RequestGroup setIdentifier(List<Identifier> theIdentifier) { 3848 this.identifier = theIdentifier; 3849 return this; 3850 } 3851 3852 public boolean hasIdentifier() { 3853 if (this.identifier == null) 3854 return false; 3855 for (Identifier item : this.identifier) 3856 if (!item.isEmpty()) 3857 return true; 3858 return false; 3859 } 3860 3861 public Identifier addIdentifier() { //3 3862 Identifier t = new Identifier(); 3863 if (this.identifier == null) 3864 this.identifier = new ArrayList<Identifier>(); 3865 this.identifier.add(t); 3866 return t; 3867 } 3868 3869 public RequestGroup addIdentifier(Identifier t) { //3 3870 if (t == null) 3871 return this; 3872 if (this.identifier == null) 3873 this.identifier = new ArrayList<Identifier>(); 3874 this.identifier.add(t); 3875 return this; 3876 } 3877 3878 /** 3879 * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist 3880 */ 3881 public Identifier getIdentifierFirstRep() { 3882 if (getIdentifier().isEmpty()) { 3883 addIdentifier(); 3884 } 3885 return getIdentifier().get(0); 3886 } 3887 3888 /** 3889 * @return {@link #definition} (A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.) 3890 */ 3891 public List<Reference> getDefinition() { 3892 if (this.definition == null) 3893 this.definition = new ArrayList<Reference>(); 3894 return this.definition; 3895 } 3896 3897 /** 3898 * @return Returns a reference to <code>this</code> for easy method chaining 3899 */ 3900 public RequestGroup setDefinition(List<Reference> theDefinition) { 3901 this.definition = theDefinition; 3902 return this; 3903 } 3904 3905 public boolean hasDefinition() { 3906 if (this.definition == null) 3907 return false; 3908 for (Reference item : this.definition) 3909 if (!item.isEmpty()) 3910 return true; 3911 return false; 3912 } 3913 3914 public Reference addDefinition() { //3 3915 Reference t = new Reference(); 3916 if (this.definition == null) 3917 this.definition = new ArrayList<Reference>(); 3918 this.definition.add(t); 3919 return t; 3920 } 3921 3922 public RequestGroup addDefinition(Reference t) { //3 3923 if (t == null) 3924 return this; 3925 if (this.definition == null) 3926 this.definition = new ArrayList<Reference>(); 3927 this.definition.add(t); 3928 return this; 3929 } 3930 3931 /** 3932 * @return The first repetition of repeating field {@link #definition}, creating it if it does not already exist 3933 */ 3934 public Reference getDefinitionFirstRep() { 3935 if (getDefinition().isEmpty()) { 3936 addDefinition(); 3937 } 3938 return getDefinition().get(0); 3939 } 3940 3941 /** 3942 * @deprecated Use Reference#setResource(IBaseResource) instead 3943 */ 3944 @Deprecated 3945 public List<Resource> getDefinitionTarget() { 3946 if (this.definitionTarget == null) 3947 this.definitionTarget = new ArrayList<Resource>(); 3948 return this.definitionTarget; 3949 } 3950 3951 /** 3952 * @return {@link #basedOn} (A plan, proposal or order that is fulfilled in whole or in part by this request.) 3953 */ 3954 public List<Reference> getBasedOn() { 3955 if (this.basedOn == null) 3956 this.basedOn = new ArrayList<Reference>(); 3957 return this.basedOn; 3958 } 3959 3960 /** 3961 * @return Returns a reference to <code>this</code> for easy method chaining 3962 */ 3963 public RequestGroup setBasedOn(List<Reference> theBasedOn) { 3964 this.basedOn = theBasedOn; 3965 return this; 3966 } 3967 3968 public boolean hasBasedOn() { 3969 if (this.basedOn == null) 3970 return false; 3971 for (Reference item : this.basedOn) 3972 if (!item.isEmpty()) 3973 return true; 3974 return false; 3975 } 3976 3977 public Reference addBasedOn() { //3 3978 Reference t = new Reference(); 3979 if (this.basedOn == null) 3980 this.basedOn = new ArrayList<Reference>(); 3981 this.basedOn.add(t); 3982 return t; 3983 } 3984 3985 public RequestGroup addBasedOn(Reference t) { //3 3986 if (t == null) 3987 return this; 3988 if (this.basedOn == null) 3989 this.basedOn = new ArrayList<Reference>(); 3990 this.basedOn.add(t); 3991 return this; 3992 } 3993 3994 /** 3995 * @return The first repetition of repeating field {@link #basedOn}, creating it if it does not already exist 3996 */ 3997 public Reference getBasedOnFirstRep() { 3998 if (getBasedOn().isEmpty()) { 3999 addBasedOn(); 4000 } 4001 return getBasedOn().get(0); 4002 } 4003 4004 /** 4005 * @deprecated Use Reference#setResource(IBaseResource) instead 4006 */ 4007 @Deprecated 4008 public List<Resource> getBasedOnTarget() { 4009 if (this.basedOnTarget == null) 4010 this.basedOnTarget = new ArrayList<Resource>(); 4011 return this.basedOnTarget; 4012 } 4013 4014 /** 4015 * @return {@link #replaces} (Completed or terminated request(s) whose function is taken by this new request.) 4016 */ 4017 public List<Reference> getReplaces() { 4018 if (this.replaces == null) 4019 this.replaces = new ArrayList<Reference>(); 4020 return this.replaces; 4021 } 4022 4023 /** 4024 * @return Returns a reference to <code>this</code> for easy method chaining 4025 */ 4026 public RequestGroup setReplaces(List<Reference> theReplaces) { 4027 this.replaces = theReplaces; 4028 return this; 4029 } 4030 4031 public boolean hasReplaces() { 4032 if (this.replaces == null) 4033 return false; 4034 for (Reference item : this.replaces) 4035 if (!item.isEmpty()) 4036 return true; 4037 return false; 4038 } 4039 4040 public Reference addReplaces() { //3 4041 Reference t = new Reference(); 4042 if (this.replaces == null) 4043 this.replaces = new ArrayList<Reference>(); 4044 this.replaces.add(t); 4045 return t; 4046 } 4047 4048 public RequestGroup addReplaces(Reference t) { //3 4049 if (t == null) 4050 return this; 4051 if (this.replaces == null) 4052 this.replaces = new ArrayList<Reference>(); 4053 this.replaces.add(t); 4054 return this; 4055 } 4056 4057 /** 4058 * @return The first repetition of repeating field {@link #replaces}, creating it if it does not already exist 4059 */ 4060 public Reference getReplacesFirstRep() { 4061 if (getReplaces().isEmpty()) { 4062 addReplaces(); 4063 } 4064 return getReplaces().get(0); 4065 } 4066 4067 /** 4068 * @deprecated Use Reference#setResource(IBaseResource) instead 4069 */ 4070 @Deprecated 4071 public List<Resource> getReplacesTarget() { 4072 if (this.replacesTarget == null) 4073 this.replacesTarget = new ArrayList<Resource>(); 4074 return this.replacesTarget; 4075 } 4076 4077 /** 4078 * @return {@link #groupIdentifier} (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.) 4079 */ 4080 public Identifier getGroupIdentifier() { 4081 if (this.groupIdentifier == null) 4082 if (Configuration.errorOnAutoCreate()) 4083 throw new Error("Attempt to auto-create RequestGroup.groupIdentifier"); 4084 else if (Configuration.doAutoCreate()) 4085 this.groupIdentifier = new Identifier(); // cc 4086 return this.groupIdentifier; 4087 } 4088 4089 public boolean hasGroupIdentifier() { 4090 return this.groupIdentifier != null && !this.groupIdentifier.isEmpty(); 4091 } 4092 4093 /** 4094 * @param value {@link #groupIdentifier} (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.) 4095 */ 4096 public RequestGroup setGroupIdentifier(Identifier value) { 4097 this.groupIdentifier = value; 4098 return this; 4099 } 4100 4101 /** 4102 * @return {@link #status} (The current state of the request. For request groups, the status reflects the status of all the requests in the group.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 4103 */ 4104 public Enumeration<RequestStatus> getStatusElement() { 4105 if (this.status == null) 4106 if (Configuration.errorOnAutoCreate()) 4107 throw new Error("Attempt to auto-create RequestGroup.status"); 4108 else if (Configuration.doAutoCreate()) 4109 this.status = new Enumeration<RequestStatus>(new RequestStatusEnumFactory()); // bb 4110 return this.status; 4111 } 4112 4113 public boolean hasStatusElement() { 4114 return this.status != null && !this.status.isEmpty(); 4115 } 4116 4117 public boolean hasStatus() { 4118 return this.status != null && !this.status.isEmpty(); 4119 } 4120 4121 /** 4122 * @param value {@link #status} (The current state of the request. For request groups, the status reflects the status of all the requests in the group.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 4123 */ 4124 public RequestGroup setStatusElement(Enumeration<RequestStatus> value) { 4125 this.status = value; 4126 return this; 4127 } 4128 4129 /** 4130 * @return The current state of the request. For request groups, the status reflects the status of all the requests in the group. 4131 */ 4132 public RequestStatus getStatus() { 4133 return this.status == null ? null : this.status.getValue(); 4134 } 4135 4136 /** 4137 * @param value The current state of the request. For request groups, the status reflects the status of all the requests in the group. 4138 */ 4139 public RequestGroup setStatus(RequestStatus value) { 4140 if (this.status == null) 4141 this.status = new Enumeration<RequestStatus>(new RequestStatusEnumFactory()); 4142 this.status.setValue(value); 4143 return this; 4144 } 4145 4146 /** 4147 * @return {@link #intent} (Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.). This is the underlying object with id, value and extensions. The accessor "getIntent" gives direct access to the value 4148 */ 4149 public Enumeration<RequestIntent> getIntentElement() { 4150 if (this.intent == null) 4151 if (Configuration.errorOnAutoCreate()) 4152 throw new Error("Attempt to auto-create RequestGroup.intent"); 4153 else if (Configuration.doAutoCreate()) 4154 this.intent = new Enumeration<RequestIntent>(new RequestIntentEnumFactory()); // bb 4155 return this.intent; 4156 } 4157 4158 public boolean hasIntentElement() { 4159 return this.intent != null && !this.intent.isEmpty(); 4160 } 4161 4162 public boolean hasIntent() { 4163 return this.intent != null && !this.intent.isEmpty(); 4164 } 4165 4166 /** 4167 * @param value {@link #intent} (Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.). This is the underlying object with id, value and extensions. The accessor "getIntent" gives direct access to the value 4168 */ 4169 public RequestGroup setIntentElement(Enumeration<RequestIntent> value) { 4170 this.intent = value; 4171 return this; 4172 } 4173 4174 /** 4175 * @return Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain. 4176 */ 4177 public RequestIntent getIntent() { 4178 return this.intent == null ? null : this.intent.getValue(); 4179 } 4180 4181 /** 4182 * @param value Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain. 4183 */ 4184 public RequestGroup setIntent(RequestIntent value) { 4185 if (this.intent == null) 4186 this.intent = new Enumeration<RequestIntent>(new RequestIntentEnumFactory()); 4187 this.intent.setValue(value); 4188 return this; 4189 } 4190 4191 /** 4192 * @return {@link #priority} (Indicates how quickly the request should be addressed with respect to other requests.). This is the underlying object with id, value and extensions. The accessor "getPriority" gives direct access to the value 4193 */ 4194 public Enumeration<RequestPriority> getPriorityElement() { 4195 if (this.priority == null) 4196 if (Configuration.errorOnAutoCreate()) 4197 throw new Error("Attempt to auto-create RequestGroup.priority"); 4198 else if (Configuration.doAutoCreate()) 4199 this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); // bb 4200 return this.priority; 4201 } 4202 4203 public boolean hasPriorityElement() { 4204 return this.priority != null && !this.priority.isEmpty(); 4205 } 4206 4207 public boolean hasPriority() { 4208 return this.priority != null && !this.priority.isEmpty(); 4209 } 4210 4211 /** 4212 * @param value {@link #priority} (Indicates how quickly the request should be addressed with respect to other requests.). This is the underlying object with id, value and extensions. The accessor "getPriority" gives direct access to the value 4213 */ 4214 public RequestGroup setPriorityElement(Enumeration<RequestPriority> value) { 4215 this.priority = value; 4216 return this; 4217 } 4218 4219 /** 4220 * @return Indicates how quickly the request should be addressed with respect to other requests. 4221 */ 4222 public RequestPriority getPriority() { 4223 return this.priority == null ? null : this.priority.getValue(); 4224 } 4225 4226 /** 4227 * @param value Indicates how quickly the request should be addressed with respect to other requests. 4228 */ 4229 public RequestGroup setPriority(RequestPriority value) { 4230 if (value == null) 4231 this.priority = null; 4232 else { 4233 if (this.priority == null) 4234 this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); 4235 this.priority.setValue(value); 4236 } 4237 return this; 4238 } 4239 4240 /** 4241 * @return {@link #subject} (The subject for which the request group was created.) 4242 */ 4243 public Reference getSubject() { 4244 if (this.subject == null) 4245 if (Configuration.errorOnAutoCreate()) 4246 throw new Error("Attempt to auto-create RequestGroup.subject"); 4247 else if (Configuration.doAutoCreate()) 4248 this.subject = new Reference(); // cc 4249 return this.subject; 4250 } 4251 4252 public boolean hasSubject() { 4253 return this.subject != null && !this.subject.isEmpty(); 4254 } 4255 4256 /** 4257 * @param value {@link #subject} (The subject for which the request group was created.) 4258 */ 4259 public RequestGroup setSubject(Reference value) { 4260 this.subject = value; 4261 return this; 4262 } 4263 4264 /** 4265 * @return {@link #subject} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The subject for which the request group was created.) 4266 */ 4267 public Resource getSubjectTarget() { 4268 return this.subjectTarget; 4269 } 4270 4271 /** 4272 * @param value {@link #subject} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The subject for which the request group was created.) 4273 */ 4274 public RequestGroup setSubjectTarget(Resource value) { 4275 this.subjectTarget = value; 4276 return this; 4277 } 4278 4279 /** 4280 * @return {@link #context} (Describes the context of the request group, if any.) 4281 */ 4282 public Reference getContext() { 4283 if (this.context == null) 4284 if (Configuration.errorOnAutoCreate()) 4285 throw new Error("Attempt to auto-create RequestGroup.context"); 4286 else if (Configuration.doAutoCreate()) 4287 this.context = new Reference(); // cc 4288 return this.context; 4289 } 4290 4291 public boolean hasContext() { 4292 return this.context != null && !this.context.isEmpty(); 4293 } 4294 4295 /** 4296 * @param value {@link #context} (Describes the context of the request group, if any.) 4297 */ 4298 public RequestGroup setContext(Reference value) { 4299 this.context = value; 4300 return this; 4301 } 4302 4303 /** 4304 * @return {@link #context} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Describes the context of the request group, if any.) 4305 */ 4306 public Resource getContextTarget() { 4307 return this.contextTarget; 4308 } 4309 4310 /** 4311 * @param value {@link #context} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Describes the context of the request group, if any.) 4312 */ 4313 public RequestGroup setContextTarget(Resource value) { 4314 this.contextTarget = value; 4315 return this; 4316 } 4317 4318 /** 4319 * @return {@link #authoredOn} (Indicates when the request group was created.). This is the underlying object with id, value and extensions. The accessor "getAuthoredOn" gives direct access to the value 4320 */ 4321 public DateTimeType getAuthoredOnElement() { 4322 if (this.authoredOn == null) 4323 if (Configuration.errorOnAutoCreate()) 4324 throw new Error("Attempt to auto-create RequestGroup.authoredOn"); 4325 else if (Configuration.doAutoCreate()) 4326 this.authoredOn = new DateTimeType(); // bb 4327 return this.authoredOn; 4328 } 4329 4330 public boolean hasAuthoredOnElement() { 4331 return this.authoredOn != null && !this.authoredOn.isEmpty(); 4332 } 4333 4334 public boolean hasAuthoredOn() { 4335 return this.authoredOn != null && !this.authoredOn.isEmpty(); 4336 } 4337 4338 /** 4339 * @param value {@link #authoredOn} (Indicates when the request group was created.). This is the underlying object with id, value and extensions. The accessor "getAuthoredOn" gives direct access to the value 4340 */ 4341 public RequestGroup setAuthoredOnElement(DateTimeType value) { 4342 this.authoredOn = value; 4343 return this; 4344 } 4345 4346 /** 4347 * @return Indicates when the request group was created. 4348 */ 4349 public Date getAuthoredOn() { 4350 return this.authoredOn == null ? null : this.authoredOn.getValue(); 4351 } 4352 4353 /** 4354 * @param value Indicates when the request group was created. 4355 */ 4356 public RequestGroup setAuthoredOn(Date value) { 4357 if (value == null) 4358 this.authoredOn = null; 4359 else { 4360 if (this.authoredOn == null) 4361 this.authoredOn = new DateTimeType(); 4362 this.authoredOn.setValue(value); 4363 } 4364 return this; 4365 } 4366 4367 /** 4368 * @return {@link #author} (Provides a reference to the author of the request group.) 4369 */ 4370 public Reference getAuthor() { 4371 if (this.author == null) 4372 if (Configuration.errorOnAutoCreate()) 4373 throw new Error("Attempt to auto-create RequestGroup.author"); 4374 else if (Configuration.doAutoCreate()) 4375 this.author = new Reference(); // cc 4376 return this.author; 4377 } 4378 4379 public boolean hasAuthor() { 4380 return this.author != null && !this.author.isEmpty(); 4381 } 4382 4383 /** 4384 * @param value {@link #author} (Provides a reference to the author of the request group.) 4385 */ 4386 public RequestGroup setAuthor(Reference value) { 4387 this.author = value; 4388 return this; 4389 } 4390 4391 /** 4392 * @return {@link #author} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Provides a reference to the author of the request group.) 4393 */ 4394 public Resource getAuthorTarget() { 4395 return this.authorTarget; 4396 } 4397 4398 /** 4399 * @param value {@link #author} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Provides a reference to the author of the request group.) 4400 */ 4401 public RequestGroup setAuthorTarget(Resource value) { 4402 this.authorTarget = value; 4403 return this; 4404 } 4405 4406 /** 4407 * @return {@link #reason} (Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.) 4408 */ 4409 public Type getReason() { 4410 return this.reason; 4411 } 4412 4413 /** 4414 * @return {@link #reason} (Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.) 4415 */ 4416 public CodeableConcept getReasonCodeableConcept() throws FHIRException { 4417 if (this.reason == null) 4418 return null; 4419 if (!(this.reason instanceof CodeableConcept)) 4420 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.reason.getClass().getName()+" was encountered"); 4421 return (CodeableConcept) this.reason; 4422 } 4423 4424 public boolean hasReasonCodeableConcept() { 4425 return this != null && this.reason instanceof CodeableConcept; 4426 } 4427 4428 /** 4429 * @return {@link #reason} (Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.) 4430 */ 4431 public Reference getReasonReference() throws FHIRException { 4432 if (this.reason == null) 4433 return null; 4434 if (!(this.reason instanceof Reference)) 4435 throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.reason.getClass().getName()+" was encountered"); 4436 return (Reference) this.reason; 4437 } 4438 4439 public boolean hasReasonReference() { 4440 return this != null && this.reason instanceof Reference; 4441 } 4442 4443 public boolean hasReason() { 4444 return this.reason != null && !this.reason.isEmpty(); 4445 } 4446 4447 /** 4448 * @param value {@link #reason} (Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.) 4449 */ 4450 public RequestGroup setReason(Type value) throws FHIRFormatError { 4451 if (value != null && !(value instanceof CodeableConcept || value instanceof Reference)) 4452 throw new FHIRFormatError("Not the right type for RequestGroup.reason[x]: "+value.fhirType()); 4453 this.reason = value; 4454 return this; 4455 } 4456 4457 /** 4458 * @return {@link #note} (Provides a mechanism to communicate additional information about the response.) 4459 */ 4460 public List<Annotation> getNote() { 4461 if (this.note == null) 4462 this.note = new ArrayList<Annotation>(); 4463 return this.note; 4464 } 4465 4466 /** 4467 * @return Returns a reference to <code>this</code> for easy method chaining 4468 */ 4469 public RequestGroup setNote(List<Annotation> theNote) { 4470 this.note = theNote; 4471 return this; 4472 } 4473 4474 public boolean hasNote() { 4475 if (this.note == null) 4476 return false; 4477 for (Annotation item : this.note) 4478 if (!item.isEmpty()) 4479 return true; 4480 return false; 4481 } 4482 4483 public Annotation addNote() { //3 4484 Annotation t = new Annotation(); 4485 if (this.note == null) 4486 this.note = new ArrayList<Annotation>(); 4487 this.note.add(t); 4488 return t; 4489 } 4490 4491 public RequestGroup addNote(Annotation t) { //3 4492 if (t == null) 4493 return this; 4494 if (this.note == null) 4495 this.note = new ArrayList<Annotation>(); 4496 this.note.add(t); 4497 return this; 4498 } 4499 4500 /** 4501 * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist 4502 */ 4503 public Annotation getNoteFirstRep() { 4504 if (getNote().isEmpty()) { 4505 addNote(); 4506 } 4507 return getNote().get(0); 4508 } 4509 4510 /** 4511 * @return {@link #action} (The actions, if any, produced by the evaluation of the artifact.) 4512 */ 4513 public List<RequestGroupActionComponent> getAction() { 4514 if (this.action == null) 4515 this.action = new ArrayList<RequestGroupActionComponent>(); 4516 return this.action; 4517 } 4518 4519 /** 4520 * @return Returns a reference to <code>this</code> for easy method chaining 4521 */ 4522 public RequestGroup setAction(List<RequestGroupActionComponent> theAction) { 4523 this.action = theAction; 4524 return this; 4525 } 4526 4527 public boolean hasAction() { 4528 if (this.action == null) 4529 return false; 4530 for (RequestGroupActionComponent item : this.action) 4531 if (!item.isEmpty()) 4532 return true; 4533 return false; 4534 } 4535 4536 public RequestGroupActionComponent addAction() { //3 4537 RequestGroupActionComponent t = new RequestGroupActionComponent(); 4538 if (this.action == null) 4539 this.action = new ArrayList<RequestGroupActionComponent>(); 4540 this.action.add(t); 4541 return t; 4542 } 4543 4544 public RequestGroup addAction(RequestGroupActionComponent t) { //3 4545 if (t == null) 4546 return this; 4547 if (this.action == null) 4548 this.action = new ArrayList<RequestGroupActionComponent>(); 4549 this.action.add(t); 4550 return this; 4551 } 4552 4553 /** 4554 * @return The first repetition of repeating field {@link #action}, creating it if it does not already exist 4555 */ 4556 public RequestGroupActionComponent getActionFirstRep() { 4557 if (getAction().isEmpty()) { 4558 addAction(); 4559 } 4560 return getAction().get(0); 4561 } 4562 4563 protected void listChildren(List<Property> children) { 4564 super.listChildren(children); 4565 children.add(new Property("identifier", "Identifier", "Allows a service to provide a unique, business identifier for the request.", 0, java.lang.Integer.MAX_VALUE, identifier)); 4566 children.add(new Property("definition", "Reference(Any)", "A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.", 0, java.lang.Integer.MAX_VALUE, definition)); 4567 children.add(new Property("basedOn", "Reference(Any)", "A plan, proposal or order that is fulfilled in whole or in part by this request.", 0, java.lang.Integer.MAX_VALUE, basedOn)); 4568 children.add(new Property("replaces", "Reference(Any)", "Completed or terminated request(s) whose function is taken by this new request.", 0, java.lang.Integer.MAX_VALUE, replaces)); 4569 children.add(new Property("groupIdentifier", "Identifier", "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.", 0, 1, groupIdentifier)); 4570 children.add(new Property("status", "code", "The current state of the request. For request groups, the status reflects the status of all the requests in the group.", 0, 1, status)); 4571 children.add(new Property("intent", "code", "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.", 0, 1, intent)); 4572 children.add(new Property("priority", "code", "Indicates how quickly the request should be addressed with respect to other requests.", 0, 1, priority)); 4573 children.add(new Property("subject", "Reference(Patient|Group)", "The subject for which the request group was created.", 0, 1, subject)); 4574 children.add(new Property("context", "Reference(Encounter|EpisodeOfCare)", "Describes the context of the request group, if any.", 0, 1, context)); 4575 children.add(new Property("authoredOn", "dateTime", "Indicates when the request group was created.", 0, 1, authoredOn)); 4576 children.add(new Property("author", "Reference(Device|Practitioner)", "Provides a reference to the author of the request group.", 0, 1, author)); 4577 children.add(new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason)); 4578 children.add(new Property("note", "Annotation", "Provides a mechanism to communicate additional information about the response.", 0, java.lang.Integer.MAX_VALUE, note)); 4579 children.add(new Property("action", "", "The actions, if any, produced by the evaluation of the artifact.", 0, java.lang.Integer.MAX_VALUE, action)); 4580 } 4581 4582 @Override 4583 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4584 switch (_hash) { 4585 case -1618432855: /*identifier*/ return new Property("identifier", "Identifier", "Allows a service to provide a unique, business identifier for the request.", 0, java.lang.Integer.MAX_VALUE, identifier); 4586 case -1014418093: /*definition*/ return new Property("definition", "Reference(Any)", "A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.", 0, java.lang.Integer.MAX_VALUE, definition); 4587 case -332612366: /*basedOn*/ return new Property("basedOn", "Reference(Any)", "A plan, proposal or order that is fulfilled in whole or in part by this request.", 0, java.lang.Integer.MAX_VALUE, basedOn); 4588 case -430332865: /*replaces*/ return new Property("replaces", "Reference(Any)", "Completed or terminated request(s) whose function is taken by this new request.", 0, java.lang.Integer.MAX_VALUE, replaces); 4589 case -445338488: /*groupIdentifier*/ return new Property("groupIdentifier", "Identifier", "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.", 0, 1, groupIdentifier); 4590 case -892481550: /*status*/ return new Property("status", "code", "The current state of the request. For request groups, the status reflects the status of all the requests in the group.", 0, 1, status); 4591 case -1183762788: /*intent*/ return new Property("intent", "code", "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.", 0, 1, intent); 4592 case -1165461084: /*priority*/ return new Property("priority", "code", "Indicates how quickly the request should be addressed with respect to other requests.", 0, 1, priority); 4593 case -1867885268: /*subject*/ return new Property("subject", "Reference(Patient|Group)", "The subject for which the request group was created.", 0, 1, subject); 4594 case 951530927: /*context*/ return new Property("context", "Reference(Encounter|EpisodeOfCare)", "Describes the context of the request group, if any.", 0, 1, context); 4595 case -1500852503: /*authoredOn*/ return new Property("authoredOn", "dateTime", "Indicates when the request group was created.", 0, 1, authoredOn); 4596 case -1406328437: /*author*/ return new Property("author", "Reference(Device|Practitioner)", "Provides a reference to the author of the request group.", 0, 1, author); 4597 case -669418564: /*reason[x]*/ return new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason); 4598 case -934964668: /*reason*/ return new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason); 4599 case -610155331: /*reasonCodeableConcept*/ return new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason); 4600 case -1146218137: /*reasonReference*/ return new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason); 4601 case 3387378: /*note*/ return new Property("note", "Annotation", "Provides a mechanism to communicate additional information about the response.", 0, java.lang.Integer.MAX_VALUE, note); 4602 case -1422950858: /*action*/ return new Property("action", "", "The actions, if any, produced by the evaluation of the artifact.", 0, java.lang.Integer.MAX_VALUE, action); 4603 default: return super.getNamedProperty(_hash, _name, _checkValid); 4604 } 4605 4606 } 4607 4608 @Override 4609 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4610 switch (hash) { 4611 case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 4612 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : this.definition.toArray(new Base[this.definition.size()]); // Reference 4613 case -332612366: /*basedOn*/ return this.basedOn == null ? new Base[0] : this.basedOn.toArray(new Base[this.basedOn.size()]); // Reference 4614 case -430332865: /*replaces*/ return this.replaces == null ? new Base[0] : this.replaces.toArray(new Base[this.replaces.size()]); // Reference 4615 case -445338488: /*groupIdentifier*/ return this.groupIdentifier == null ? new Base[0] : new Base[] {this.groupIdentifier}; // Identifier 4616 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<RequestStatus> 4617 case -1183762788: /*intent*/ return this.intent == null ? new Base[0] : new Base[] {this.intent}; // Enumeration<RequestIntent> 4618 case -1165461084: /*priority*/ return this.priority == null ? new Base[0] : new Base[] {this.priority}; // Enumeration<RequestPriority> 4619 case -1867885268: /*subject*/ return this.subject == null ? new Base[0] : new Base[] {this.subject}; // Reference 4620 case 951530927: /*context*/ return this.context == null ? new Base[0] : new Base[] {this.context}; // Reference 4621 case -1500852503: /*authoredOn*/ return this.authoredOn == null ? new Base[0] : new Base[] {this.authoredOn}; // DateTimeType 4622 case -1406328437: /*author*/ return this.author == null ? new Base[0] : new Base[] {this.author}; // Reference 4623 case -934964668: /*reason*/ return this.reason == null ? new Base[0] : new Base[] {this.reason}; // Type 4624 case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation 4625 case -1422950858: /*action*/ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // RequestGroupActionComponent 4626 default: return super.getProperty(hash, name, checkValid); 4627 } 4628 4629 } 4630 4631 @Override 4632 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4633 switch (hash) { 4634 case -1618432855: // identifier 4635 this.getIdentifier().add(castToIdentifier(value)); // Identifier 4636 return value; 4637 case -1014418093: // definition 4638 this.getDefinition().add(castToReference(value)); // Reference 4639 return value; 4640 case -332612366: // basedOn 4641 this.getBasedOn().add(castToReference(value)); // Reference 4642 return value; 4643 case -430332865: // replaces 4644 this.getReplaces().add(castToReference(value)); // Reference 4645 return value; 4646 case -445338488: // groupIdentifier 4647 this.groupIdentifier = castToIdentifier(value); // Identifier 4648 return value; 4649 case -892481550: // status 4650 value = new RequestStatusEnumFactory().fromType(castToCode(value)); 4651 this.status = (Enumeration) value; // Enumeration<RequestStatus> 4652 return value; 4653 case -1183762788: // intent 4654 value = new RequestIntentEnumFactory().fromType(castToCode(value)); 4655 this.intent = (Enumeration) value; // Enumeration<RequestIntent> 4656 return value; 4657 case -1165461084: // priority 4658 value = new RequestPriorityEnumFactory().fromType(castToCode(value)); 4659 this.priority = (Enumeration) value; // Enumeration<RequestPriority> 4660 return value; 4661 case -1867885268: // subject 4662 this.subject = castToReference(value); // Reference 4663 return value; 4664 case 951530927: // context 4665 this.context = castToReference(value); // Reference 4666 return value; 4667 case -1500852503: // authoredOn 4668 this.authoredOn = castToDateTime(value); // DateTimeType 4669 return value; 4670 case -1406328437: // author 4671 this.author = castToReference(value); // Reference 4672 return value; 4673 case -934964668: // reason 4674 this.reason = castToType(value); // Type 4675 return value; 4676 case 3387378: // note 4677 this.getNote().add(castToAnnotation(value)); // Annotation 4678 return value; 4679 case -1422950858: // action 4680 this.getAction().add((RequestGroupActionComponent) value); // RequestGroupActionComponent 4681 return value; 4682 default: return super.setProperty(hash, name, value); 4683 } 4684 4685 } 4686 4687 @Override 4688 public Base setProperty(String name, Base value) throws FHIRException { 4689 if (name.equals("identifier")) { 4690 this.getIdentifier().add(castToIdentifier(value)); 4691 } else if (name.equals("definition")) { 4692 this.getDefinition().add(castToReference(value)); 4693 } else if (name.equals("basedOn")) { 4694 this.getBasedOn().add(castToReference(value)); 4695 } else if (name.equals("replaces")) { 4696 this.getReplaces().add(castToReference(value)); 4697 } else if (name.equals("groupIdentifier")) { 4698 this.groupIdentifier = castToIdentifier(value); // Identifier 4699 } else if (name.equals("status")) { 4700 value = new RequestStatusEnumFactory().fromType(castToCode(value)); 4701 this.status = (Enumeration) value; // Enumeration<RequestStatus> 4702 } else if (name.equals("intent")) { 4703 value = new RequestIntentEnumFactory().fromType(castToCode(value)); 4704 this.intent = (Enumeration) value; // Enumeration<RequestIntent> 4705 } else if (name.equals("priority")) { 4706 value = new RequestPriorityEnumFactory().fromType(castToCode(value)); 4707 this.priority = (Enumeration) value; // Enumeration<RequestPriority> 4708 } else if (name.equals("subject")) { 4709 this.subject = castToReference(value); // Reference 4710 } else if (name.equals("context")) { 4711 this.context = castToReference(value); // Reference 4712 } else if (name.equals("authoredOn")) { 4713 this.authoredOn = castToDateTime(value); // DateTimeType 4714 } else if (name.equals("author")) { 4715 this.author = castToReference(value); // Reference 4716 } else if (name.equals("reason[x]")) { 4717 this.reason = castToType(value); // Type 4718 } else if (name.equals("note")) { 4719 this.getNote().add(castToAnnotation(value)); 4720 } else if (name.equals("action")) { 4721 this.getAction().add((RequestGroupActionComponent) value); 4722 } else 4723 return super.setProperty(name, value); 4724 return value; 4725 } 4726 4727 @Override 4728 public Base makeProperty(int hash, String name) throws FHIRException { 4729 switch (hash) { 4730 case -1618432855: return addIdentifier(); 4731 case -1014418093: return addDefinition(); 4732 case -332612366: return addBasedOn(); 4733 case -430332865: return addReplaces(); 4734 case -445338488: return getGroupIdentifier(); 4735 case -892481550: return getStatusElement(); 4736 case -1183762788: return getIntentElement(); 4737 case -1165461084: return getPriorityElement(); 4738 case -1867885268: return getSubject(); 4739 case 951530927: return getContext(); 4740 case -1500852503: return getAuthoredOnElement(); 4741 case -1406328437: return getAuthor(); 4742 case -669418564: return getReason(); 4743 case -934964668: return getReason(); 4744 case 3387378: return addNote(); 4745 case -1422950858: return addAction(); 4746 default: return super.makeProperty(hash, name); 4747 } 4748 4749 } 4750 4751 @Override 4752 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4753 switch (hash) { 4754 case -1618432855: /*identifier*/ return new String[] {"Identifier"}; 4755 case -1014418093: /*definition*/ return new String[] {"Reference"}; 4756 case -332612366: /*basedOn*/ return new String[] {"Reference"}; 4757 case -430332865: /*replaces*/ return new String[] {"Reference"}; 4758 case -445338488: /*groupIdentifier*/ return new String[] {"Identifier"}; 4759 case -892481550: /*status*/ return new String[] {"code"}; 4760 case -1183762788: /*intent*/ return new String[] {"code"}; 4761 case -1165461084: /*priority*/ return new String[] {"code"}; 4762 case -1867885268: /*subject*/ return new String[] {"Reference"}; 4763 case 951530927: /*context*/ return new String[] {"Reference"}; 4764 case -1500852503: /*authoredOn*/ return new String[] {"dateTime"}; 4765 case -1406328437: /*author*/ return new String[] {"Reference"}; 4766 case -934964668: /*reason*/ return new String[] {"CodeableConcept", "Reference"}; 4767 case 3387378: /*note*/ return new String[] {"Annotation"}; 4768 case -1422950858: /*action*/ return new String[] {}; 4769 default: return super.getTypesForProperty(hash, name); 4770 } 4771 4772 } 4773 4774 @Override 4775 public Base addChild(String name) throws FHIRException { 4776 if (name.equals("identifier")) { 4777 return addIdentifier(); 4778 } 4779 else if (name.equals("definition")) { 4780 return addDefinition(); 4781 } 4782 else if (name.equals("basedOn")) { 4783 return addBasedOn(); 4784 } 4785 else if (name.equals("replaces")) { 4786 return addReplaces(); 4787 } 4788 else if (name.equals("groupIdentifier")) { 4789 this.groupIdentifier = new Identifier(); 4790 return this.groupIdentifier; 4791 } 4792 else if (name.equals("status")) { 4793 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.status"); 4794 } 4795 else if (name.equals("intent")) { 4796 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.intent"); 4797 } 4798 else if (name.equals("priority")) { 4799 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.priority"); 4800 } 4801 else if (name.equals("subject")) { 4802 this.subject = new Reference(); 4803 return this.subject; 4804 } 4805 else if (name.equals("context")) { 4806 this.context = new Reference(); 4807 return this.context; 4808 } 4809 else if (name.equals("authoredOn")) { 4810 throw new FHIRException("Cannot call addChild on a singleton property RequestGroup.authoredOn"); 4811 } 4812 else if (name.equals("author")) { 4813 this.author = new Reference(); 4814 return this.author; 4815 } 4816 else if (name.equals("reasonCodeableConcept")) { 4817 this.reason = new CodeableConcept(); 4818 return this.reason; 4819 } 4820 else if (name.equals("reasonReference")) { 4821 this.reason = new Reference(); 4822 return this.reason; 4823 } 4824 else if (name.equals("note")) { 4825 return addNote(); 4826 } 4827 else if (name.equals("action")) { 4828 return addAction(); 4829 } 4830 else 4831 return super.addChild(name); 4832 } 4833 4834 public String fhirType() { 4835 return "RequestGroup"; 4836 4837 } 4838 4839 public RequestGroup copy() { 4840 RequestGroup dst = new RequestGroup(); 4841 copyValues(dst); 4842 if (identifier != null) { 4843 dst.identifier = new ArrayList<Identifier>(); 4844 for (Identifier i : identifier) 4845 dst.identifier.add(i.copy()); 4846 }; 4847 if (definition != null) { 4848 dst.definition = new ArrayList<Reference>(); 4849 for (Reference i : definition) 4850 dst.definition.add(i.copy()); 4851 }; 4852 if (basedOn != null) { 4853 dst.basedOn = new ArrayList<Reference>(); 4854 for (Reference i : basedOn) 4855 dst.basedOn.add(i.copy()); 4856 }; 4857 if (replaces != null) { 4858 dst.replaces = new ArrayList<Reference>(); 4859 for (Reference i : replaces) 4860 dst.replaces.add(i.copy()); 4861 }; 4862 dst.groupIdentifier = groupIdentifier == null ? null : groupIdentifier.copy(); 4863 dst.status = status == null ? null : status.copy(); 4864 dst.intent = intent == null ? null : intent.copy(); 4865 dst.priority = priority == null ? null : priority.copy(); 4866 dst.subject = subject == null ? null : subject.copy(); 4867 dst.context = context == null ? null : context.copy(); 4868 dst.authoredOn = authoredOn == null ? null : authoredOn.copy(); 4869 dst.author = author == null ? null : author.copy(); 4870 dst.reason = reason == null ? null : reason.copy(); 4871 if (note != null) { 4872 dst.note = new ArrayList<Annotation>(); 4873 for (Annotation i : note) 4874 dst.note.add(i.copy()); 4875 }; 4876 if (action != null) { 4877 dst.action = new ArrayList<RequestGroupActionComponent>(); 4878 for (RequestGroupActionComponent i : action) 4879 dst.action.add(i.copy()); 4880 }; 4881 return dst; 4882 } 4883 4884 protected RequestGroup typedCopy() { 4885 return copy(); 4886 } 4887 4888 @Override 4889 public boolean equalsDeep(Base other_) { 4890 if (!super.equalsDeep(other_)) 4891 return false; 4892 if (!(other_ instanceof RequestGroup)) 4893 return false; 4894 RequestGroup o = (RequestGroup) other_; 4895 return compareDeep(identifier, o.identifier, true) && compareDeep(definition, o.definition, true) 4896 && compareDeep(basedOn, o.basedOn, true) && compareDeep(replaces, o.replaces, true) && compareDeep(groupIdentifier, o.groupIdentifier, true) 4897 && compareDeep(status, o.status, true) && compareDeep(intent, o.intent, true) && compareDeep(priority, o.priority, true) 4898 && compareDeep(subject, o.subject, true) && compareDeep(context, o.context, true) && compareDeep(authoredOn, o.authoredOn, true) 4899 && compareDeep(author, o.author, true) && compareDeep(reason, o.reason, true) && compareDeep(note, o.note, true) 4900 && compareDeep(action, o.action, true); 4901 } 4902 4903 @Override 4904 public boolean equalsShallow(Base other_) { 4905 if (!super.equalsShallow(other_)) 4906 return false; 4907 if (!(other_ instanceof RequestGroup)) 4908 return false; 4909 RequestGroup o = (RequestGroup) other_; 4910 return compareValues(status, o.status, true) && compareValues(intent, o.intent, true) && compareValues(priority, o.priority, true) 4911 && compareValues(authoredOn, o.authoredOn, true); 4912 } 4913 4914 public boolean isEmpty() { 4915 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, definition, basedOn 4916 , replaces, groupIdentifier, status, intent, priority, subject, context, authoredOn 4917 , author, reason, note, action); 4918 } 4919 4920 @Override 4921 public ResourceType getResourceType() { 4922 return ResourceType.RequestGroup; 4923 } 4924 4925 /** 4926 * Search parameter: <b>authored</b> 4927 * <p> 4928 * Description: <b>The date the request group was authored</b><br> 4929 * Type: <b>date</b><br> 4930 * Path: <b>RequestGroup.authoredOn</b><br> 4931 * </p> 4932 */ 4933 @SearchParamDefinition(name="authored", path="RequestGroup.authoredOn", description="The date the request group was authored", type="date" ) 4934 public static final String SP_AUTHORED = "authored"; 4935 /** 4936 * <b>Fluent Client</b> search parameter constant for <b>authored</b> 4937 * <p> 4938 * Description: <b>The date the request group was authored</b><br> 4939 * Type: <b>date</b><br> 4940 * Path: <b>RequestGroup.authoredOn</b><br> 4941 * </p> 4942 */ 4943 public static final ca.uhn.fhir.rest.gclient.DateClientParam AUTHORED = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_AUTHORED); 4944 4945 /** 4946 * Search parameter: <b>identifier</b> 4947 * <p> 4948 * Description: <b>External identifiers for the request group</b><br> 4949 * Type: <b>token</b><br> 4950 * Path: <b>RequestGroup.identifier</b><br> 4951 * </p> 4952 */ 4953 @SearchParamDefinition(name="identifier", path="RequestGroup.identifier", description="External identifiers for the request group", type="token" ) 4954 public static final String SP_IDENTIFIER = "identifier"; 4955 /** 4956 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 4957 * <p> 4958 * Description: <b>External identifiers for the request group</b><br> 4959 * Type: <b>token</b><br> 4960 * Path: <b>RequestGroup.identifier</b><br> 4961 * </p> 4962 */ 4963 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER); 4964 4965 /** 4966 * Search parameter: <b>subject</b> 4967 * <p> 4968 * Description: <b>The subject that the request group is about</b><br> 4969 * Type: <b>reference</b><br> 4970 * Path: <b>RequestGroup.subject</b><br> 4971 * </p> 4972 */ 4973 @SearchParamDefinition(name="subject", path="RequestGroup.subject", description="The subject that the request group is about", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") }, target={Group.class, Patient.class } ) 4974 public static final String SP_SUBJECT = "subject"; 4975 /** 4976 * <b>Fluent Client</b> search parameter constant for <b>subject</b> 4977 * <p> 4978 * Description: <b>The subject that the request group is about</b><br> 4979 * Type: <b>reference</b><br> 4980 * Path: <b>RequestGroup.subject</b><br> 4981 * </p> 4982 */ 4983 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUBJECT); 4984 4985/** 4986 * Constant for fluent queries to be used to add include statements. Specifies 4987 * the path value of "<b>RequestGroup:subject</b>". 4988 */ 4989 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT = new ca.uhn.fhir.model.api.Include("RequestGroup:subject").toLocked(); 4990 4991 /** 4992 * Search parameter: <b>author</b> 4993 * <p> 4994 * Description: <b>The author of the request group</b><br> 4995 * Type: <b>reference</b><br> 4996 * Path: <b>RequestGroup.author</b><br> 4997 * </p> 4998 */ 4999 @SearchParamDefinition(name="author", path="RequestGroup.author", description="The author of the request group", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") }, target={Device.class, Practitioner.class } ) 5000 public static final String SP_AUTHOR = "author"; 5001 /** 5002 * <b>Fluent Client</b> search parameter constant for <b>author</b> 5003 * <p> 5004 * Description: <b>The author of the request group</b><br> 5005 * Type: <b>reference</b><br> 5006 * Path: <b>RequestGroup.author</b><br> 5007 * </p> 5008 */ 5009 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam AUTHOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_AUTHOR); 5010 5011/** 5012 * Constant for fluent queries to be used to add include statements. Specifies 5013 * the path value of "<b>RequestGroup:author</b>". 5014 */ 5015 public static final ca.uhn.fhir.model.api.Include INCLUDE_AUTHOR = new ca.uhn.fhir.model.api.Include("RequestGroup:author").toLocked(); 5016 5017 /** 5018 * Search parameter: <b>encounter</b> 5019 * <p> 5020 * Description: <b>The encounter the request group applies to</b><br> 5021 * Type: <b>reference</b><br> 5022 * Path: <b>RequestGroup.context</b><br> 5023 * </p> 5024 */ 5025 @SearchParamDefinition(name="encounter", path="RequestGroup.context", description="The encounter the request group applies to", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Encounter") }, target={Encounter.class } ) 5026 public static final String SP_ENCOUNTER = "encounter"; 5027 /** 5028 * <b>Fluent Client</b> search parameter constant for <b>encounter</b> 5029 * <p> 5030 * Description: <b>The encounter the request group applies to</b><br> 5031 * Type: <b>reference</b><br> 5032 * Path: <b>RequestGroup.context</b><br> 5033 * </p> 5034 */ 5035 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ENCOUNTER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ENCOUNTER); 5036 5037/** 5038 * Constant for fluent queries to be used to add include statements. Specifies 5039 * the path value of "<b>RequestGroup:encounter</b>". 5040 */ 5041 public static final ca.uhn.fhir.model.api.Include INCLUDE_ENCOUNTER = new ca.uhn.fhir.model.api.Include("RequestGroup:encounter").toLocked(); 5042 5043 /** 5044 * Search parameter: <b>priority</b> 5045 * <p> 5046 * Description: <b>The priority of the request group</b><br> 5047 * Type: <b>token</b><br> 5048 * Path: <b>RequestGroup.priority</b><br> 5049 * </p> 5050 */ 5051 @SearchParamDefinition(name="priority", path="RequestGroup.priority", description="The priority of the request group", type="token" ) 5052 public static final String SP_PRIORITY = "priority"; 5053 /** 5054 * <b>Fluent Client</b> search parameter constant for <b>priority</b> 5055 * <p> 5056 * Description: <b>The priority of the request group</b><br> 5057 * Type: <b>token</b><br> 5058 * Path: <b>RequestGroup.priority</b><br> 5059 * </p> 5060 */ 5061 public static final ca.uhn.fhir.rest.gclient.TokenClientParam PRIORITY = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_PRIORITY); 5062 5063 /** 5064 * Search parameter: <b>intent</b> 5065 * <p> 5066 * Description: <b>The intent of the request group</b><br> 5067 * Type: <b>token</b><br> 5068 * Path: <b>RequestGroup.intent</b><br> 5069 * </p> 5070 */ 5071 @SearchParamDefinition(name="intent", path="RequestGroup.intent", description="The intent of the request group", type="token" ) 5072 public static final String SP_INTENT = "intent"; 5073 /** 5074 * <b>Fluent Client</b> search parameter constant for <b>intent</b> 5075 * <p> 5076 * Description: <b>The intent of the request group</b><br> 5077 * Type: <b>token</b><br> 5078 * Path: <b>RequestGroup.intent</b><br> 5079 * </p> 5080 */ 5081 public static final ca.uhn.fhir.rest.gclient.TokenClientParam INTENT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_INTENT); 5082 5083 /** 5084 * Search parameter: <b>participant</b> 5085 * <p> 5086 * Description: <b>The participant in the requests in the group</b><br> 5087 * Type: <b>reference</b><br> 5088 * Path: <b>RequestGroup.action.participant</b><br> 5089 * </p> 5090 */ 5091 @SearchParamDefinition(name="participant", path="RequestGroup.action.participant", description="The participant in the requests in the group", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") }, target={Patient.class, Person.class, Practitioner.class, RelatedPerson.class } ) 5092 public static final String SP_PARTICIPANT = "participant"; 5093 /** 5094 * <b>Fluent Client</b> search parameter constant for <b>participant</b> 5095 * <p> 5096 * Description: <b>The participant in the requests in the group</b><br> 5097 * Type: <b>reference</b><br> 5098 * Path: <b>RequestGroup.action.participant</b><br> 5099 * </p> 5100 */ 5101 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PARTICIPANT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PARTICIPANT); 5102 5103/** 5104 * Constant for fluent queries to be used to add include statements. Specifies 5105 * the path value of "<b>RequestGroup:participant</b>". 5106 */ 5107 public static final ca.uhn.fhir.model.api.Include INCLUDE_PARTICIPANT = new ca.uhn.fhir.model.api.Include("RequestGroup:participant").toLocked(); 5108 5109 /** 5110 * Search parameter: <b>group-identifier</b> 5111 * <p> 5112 * Description: <b>The group identifier for the request group</b><br> 5113 * Type: <b>token</b><br> 5114 * Path: <b>RequestGroup.groupIdentifier</b><br> 5115 * </p> 5116 */ 5117 @SearchParamDefinition(name="group-identifier", path="RequestGroup.groupIdentifier", description="The group identifier for the request group", type="token" ) 5118 public static final String SP_GROUP_IDENTIFIER = "group-identifier"; 5119 /** 5120 * <b>Fluent Client</b> search parameter constant for <b>group-identifier</b> 5121 * <p> 5122 * Description: <b>The group identifier for the request group</b><br> 5123 * Type: <b>token</b><br> 5124 * Path: <b>RequestGroup.groupIdentifier</b><br> 5125 * </p> 5126 */ 5127 public static final ca.uhn.fhir.rest.gclient.TokenClientParam GROUP_IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_GROUP_IDENTIFIER); 5128 5129 /** 5130 * Search parameter: <b>patient</b> 5131 * <p> 5132 * Description: <b>The identity of a patient to search for request groups</b><br> 5133 * Type: <b>reference</b><br> 5134 * Path: <b>RequestGroup.subject</b><br> 5135 * </p> 5136 */ 5137 @SearchParamDefinition(name="patient", path="RequestGroup.subject", description="The identity of a patient to search for request groups", type="reference", target={Patient.class } ) 5138 public static final String SP_PATIENT = "patient"; 5139 /** 5140 * <b>Fluent Client</b> search parameter constant for <b>patient</b> 5141 * <p> 5142 * Description: <b>The identity of a patient to search for request groups</b><br> 5143 * Type: <b>reference</b><br> 5144 * Path: <b>RequestGroup.subject</b><br> 5145 * </p> 5146 */ 5147 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT); 5148 5149/** 5150 * Constant for fluent queries to be used to add include statements. Specifies 5151 * the path value of "<b>RequestGroup:patient</b>". 5152 */ 5153 public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("RequestGroup:patient").toLocked(); 5154 5155 /** 5156 * Search parameter: <b>context</b> 5157 * <p> 5158 * Description: <b>The context the request group applies to</b><br> 5159 * Type: <b>reference</b><br> 5160 * Path: <b>RequestGroup.context</b><br> 5161 * </p> 5162 */ 5163 @SearchParamDefinition(name="context", path="RequestGroup.context", description="The context the request group applies to", type="reference", target={Encounter.class, EpisodeOfCare.class } ) 5164 public static final String SP_CONTEXT = "context"; 5165 /** 5166 * <b>Fluent Client</b> search parameter constant for <b>context</b> 5167 * <p> 5168 * Description: <b>The context the request group applies to</b><br> 5169 * Type: <b>reference</b><br> 5170 * Path: <b>RequestGroup.context</b><br> 5171 * </p> 5172 */ 5173 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_CONTEXT); 5174 5175/** 5176 * Constant for fluent queries to be used to add include statements. Specifies 5177 * the path value of "<b>RequestGroup:context</b>". 5178 */ 5179 public static final ca.uhn.fhir.model.api.Include INCLUDE_CONTEXT = new ca.uhn.fhir.model.api.Include("RequestGroup:context").toLocked(); 5180 5181 /** 5182 * Search parameter: <b>definition</b> 5183 * <p> 5184 * Description: <b>The definition from which the request group is realized</b><br> 5185 * Type: <b>reference</b><br> 5186 * Path: <b>RequestGroup.definition</b><br> 5187 * </p> 5188 */ 5189 @SearchParamDefinition(name="definition", path="RequestGroup.definition", description="The definition from which the request group is realized", type="reference" ) 5190 public static final String SP_DEFINITION = "definition"; 5191 /** 5192 * <b>Fluent Client</b> search parameter constant for <b>definition</b> 5193 * <p> 5194 * Description: <b>The definition from which the request group is realized</b><br> 5195 * Type: <b>reference</b><br> 5196 * Path: <b>RequestGroup.definition</b><br> 5197 * </p> 5198 */ 5199 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam DEFINITION = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_DEFINITION); 5200 5201/** 5202 * Constant for fluent queries to be used to add include statements. Specifies 5203 * the path value of "<b>RequestGroup:definition</b>". 5204 */ 5205 public static final ca.uhn.fhir.model.api.Include INCLUDE_DEFINITION = new ca.uhn.fhir.model.api.Include("RequestGroup:definition").toLocked(); 5206 5207 /** 5208 * Search parameter: <b>status</b> 5209 * <p> 5210 * Description: <b>The status of the request group</b><br> 5211 * Type: <b>token</b><br> 5212 * Path: <b>RequestGroup.status</b><br> 5213 * </p> 5214 */ 5215 @SearchParamDefinition(name="status", path="RequestGroup.status", description="The status of the request group", type="token" ) 5216 public static final String SP_STATUS = "status"; 5217 /** 5218 * <b>Fluent Client</b> search parameter constant for <b>status</b> 5219 * <p> 5220 * Description: <b>The status of the request group</b><br> 5221 * Type: <b>token</b><br> 5222 * Path: <b>RequestGroup.status</b><br> 5223 * </p> 5224 */ 5225 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 5226 5227 5228}