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