001package org.hl7.fhir.r4.model; 002 003/* 004 Copyright (c) 2011+, HL7, Inc. 005 All rights reserved. 006 007 Redistribution and use in source and binary forms, with or without modification, 008 are permitted provided that the following conditions are met: 009 010 * Redistributions of source code must retain the above copyright notice, this 011 list of conditions and the following disclaimer. 012 * Redistributions in binary form must reproduce the above copyright notice, 013 this list of conditions and the following disclaimer in the documentation 014 and/or other materials provided with the distribution. 015 * Neither the name of HL7 nor the names of its contributors may be used to 016 endorse or promote products derived from this software without specific 017 prior written permission. 018 019 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 020 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 021 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 022 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 023 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 024 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 025 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 026 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 027 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 028 POSSIBILITY OF SUCH DAMAGE. 029 030*/ 031 032// Generated on Tue, May 12, 2020 07:26+1000 for FHIR v4.0.1 033import java.util.ArrayList; 034import java.util.Date; 035import java.util.List; 036 037import org.hl7.fhir.exceptions.FHIRException; 038import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 039import org.hl7.fhir.utilities.Utilities; 040 041import ca.uhn.fhir.model.api.annotation.Block; 042import ca.uhn.fhir.model.api.annotation.Child; 043import ca.uhn.fhir.model.api.annotation.Description; 044import ca.uhn.fhir.model.api.annotation.ResourceDef; 045import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 046 047/** 048 * A record of a clinical assessment performed to determine what problem(s) may 049 * affect the patient and before planning the treatments or management 050 * strategies that are best to manage a patient's condition. Assessments are 051 * often 1:1 with a clinical consultation / encounter, but this varies greatly 052 * depending on the clinical workflow. This resource is called 053 * "ClinicalImpression" rather than "ClinicalAssessment" to avoid confusion with 054 * the recording of assessment tools such as Apgar score. 055 */ 056@ResourceDef(name = "ClinicalImpression", profile = "http://hl7.org/fhir/StructureDefinition/ClinicalImpression") 057public class ClinicalImpression extends DomainResource { 058 059 public enum ClinicalImpressionStatus { 060 /** 061 * null 062 */ 063 INPROGRESS, 064 /** 065 * null 066 */ 067 COMPLETED, 068 /** 069 * null 070 */ 071 ENTEREDINERROR, 072 /** 073 * added to help the parsers with the generic types 074 */ 075 NULL; 076 077 public static ClinicalImpressionStatus fromCode(String codeString) throws FHIRException { 078 if (codeString == null || "".equals(codeString)) 079 return null; 080 if ("in-progress".equals(codeString)) 081 return INPROGRESS; 082 if ("completed".equals(codeString)) 083 return COMPLETED; 084 if ("entered-in-error".equals(codeString)) 085 return ENTEREDINERROR; 086 if (Configuration.isAcceptInvalidEnums()) 087 return null; 088 else 089 throw new FHIRException("Unknown ClinicalImpressionStatus code '" + codeString + "'"); 090 } 091 092 public String toCode() { 093 switch (this) { 094 case INPROGRESS: 095 return "in-progress"; 096 case COMPLETED: 097 return "completed"; 098 case ENTEREDINERROR: 099 return "entered-in-error"; 100 case NULL: 101 return null; 102 default: 103 return "?"; 104 } 105 } 106 107 public String getSystem() { 108 switch (this) { 109 case INPROGRESS: 110 return "http://hl7.org/fhir/event-status"; 111 case COMPLETED: 112 return "http://hl7.org/fhir/event-status"; 113 case ENTEREDINERROR: 114 return "http://hl7.org/fhir/event-status"; 115 case NULL: 116 return null; 117 default: 118 return "?"; 119 } 120 } 121 122 public String getDefinition() { 123 switch (this) { 124 case INPROGRESS: 125 return ""; 126 case COMPLETED: 127 return ""; 128 case ENTEREDINERROR: 129 return ""; 130 case NULL: 131 return null; 132 default: 133 return "?"; 134 } 135 } 136 137 public String getDisplay() { 138 switch (this) { 139 case INPROGRESS: 140 return "in-progress"; 141 case COMPLETED: 142 return "completed"; 143 case ENTEREDINERROR: 144 return "entered-in-error"; 145 case NULL: 146 return null; 147 default: 148 return "?"; 149 } 150 } 151 } 152 153 public static class ClinicalImpressionStatusEnumFactory implements EnumFactory<ClinicalImpressionStatus> { 154 public ClinicalImpressionStatus fromCode(String codeString) throws IllegalArgumentException { 155 if (codeString == null || "".equals(codeString)) 156 if (codeString == null || "".equals(codeString)) 157 return null; 158 if ("in-progress".equals(codeString)) 159 return ClinicalImpressionStatus.INPROGRESS; 160 if ("completed".equals(codeString)) 161 return ClinicalImpressionStatus.COMPLETED; 162 if ("entered-in-error".equals(codeString)) 163 return ClinicalImpressionStatus.ENTEREDINERROR; 164 throw new IllegalArgumentException("Unknown ClinicalImpressionStatus code '" + codeString + "'"); 165 } 166 167 public Enumeration<ClinicalImpressionStatus> fromType(PrimitiveType<?> code) throws FHIRException { 168 if (code == null) 169 return null; 170 if (code.isEmpty()) 171 return new Enumeration<ClinicalImpressionStatus>(this, ClinicalImpressionStatus.NULL, code); 172 String codeString = code.asStringValue(); 173 if (codeString == null || "".equals(codeString)) 174 return new Enumeration<ClinicalImpressionStatus>(this, ClinicalImpressionStatus.NULL, code); 175 if ("in-progress".equals(codeString)) 176 return new Enumeration<ClinicalImpressionStatus>(this, ClinicalImpressionStatus.INPROGRESS, code); 177 if ("completed".equals(codeString)) 178 return new Enumeration<ClinicalImpressionStatus>(this, ClinicalImpressionStatus.COMPLETED, code); 179 if ("entered-in-error".equals(codeString)) 180 return new Enumeration<ClinicalImpressionStatus>(this, ClinicalImpressionStatus.ENTEREDINERROR, code); 181 throw new FHIRException("Unknown ClinicalImpressionStatus code '" + codeString + "'"); 182 } 183 184 public String toCode(ClinicalImpressionStatus code) { 185 if (code == ClinicalImpressionStatus.INPROGRESS) 186 return "in-progress"; 187 if (code == ClinicalImpressionStatus.COMPLETED) 188 return "completed"; 189 if (code == ClinicalImpressionStatus.ENTEREDINERROR) 190 return "entered-in-error"; 191 return "?"; 192 } 193 194 public String toSystem(ClinicalImpressionStatus code) { 195 return code.getSystem(); 196 } 197 } 198 199 @Block() 200 public static class ClinicalImpressionInvestigationComponent extends BackboneElement implements IBaseBackboneElement { 201 /** 202 * A name/code for the group ("set") of investigations. Typically, this will be 203 * something like "signs", "symptoms", "clinical", "diagnostic", but the list is 204 * not constrained, and others such groups such as 205 * (exposure|family|travel|nutritional) history may be used. 206 */ 207 @Child(name = "code", type = { 208 CodeableConcept.class }, order = 1, min = 1, max = 1, modifier = false, summary = false) 209 @Description(shortDefinition = "A name/code for the set", formalDefinition = "A name/code for the group (\"set\") of investigations. Typically, this will be something like \"signs\", \"symptoms\", \"clinical\", \"diagnostic\", but the list is not constrained, and others such groups such as (exposure|family|travel|nutritional) history may be used.") 210 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/investigation-sets") 211 protected CodeableConcept code; 212 213 /** 214 * A record of a specific investigation that was undertaken. 215 */ 216 @Child(name = "item", type = { Observation.class, QuestionnaireResponse.class, FamilyMemberHistory.class, 217 DiagnosticReport.class, RiskAssessment.class, ImagingStudy.class, 218 Media.class }, order = 2, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 219 @Description(shortDefinition = "Record of a specific investigation", formalDefinition = "A record of a specific investigation that was undertaken.") 220 protected List<Reference> item; 221 /** 222 * The actual objects that are the target of the reference (A record of a 223 * specific investigation that was undertaken.) 224 */ 225 protected List<Resource> itemTarget; 226 227 private static final long serialVersionUID = -301363326L; 228 229 /** 230 * Constructor 231 */ 232 public ClinicalImpressionInvestigationComponent() { 233 super(); 234 } 235 236 /** 237 * Constructor 238 */ 239 public ClinicalImpressionInvestigationComponent(CodeableConcept code) { 240 super(); 241 this.code = code; 242 } 243 244 /** 245 * @return {@link #code} (A name/code for the group ("set") of investigations. 246 * Typically, this will be something like "signs", "symptoms", 247 * "clinical", "diagnostic", but the list is not constrained, and others 248 * such groups such as (exposure|family|travel|nutritional) history may 249 * be used.) 250 */ 251 public CodeableConcept getCode() { 252 if (this.code == null) 253 if (Configuration.errorOnAutoCreate()) 254 throw new Error("Attempt to auto-create ClinicalImpressionInvestigationComponent.code"); 255 else if (Configuration.doAutoCreate()) 256 this.code = new CodeableConcept(); // cc 257 return this.code; 258 } 259 260 public boolean hasCode() { 261 return this.code != null && !this.code.isEmpty(); 262 } 263 264 /** 265 * @param value {@link #code} (A name/code for the group ("set") of 266 * investigations. Typically, this will be something like "signs", 267 * "symptoms", "clinical", "diagnostic", but the list is not 268 * constrained, and others such groups such as 269 * (exposure|family|travel|nutritional) history may be used.) 270 */ 271 public ClinicalImpressionInvestigationComponent setCode(CodeableConcept value) { 272 this.code = value; 273 return this; 274 } 275 276 /** 277 * @return {@link #item} (A record of a specific investigation that was 278 * undertaken.) 279 */ 280 public List<Reference> getItem() { 281 if (this.item == null) 282 this.item = new ArrayList<Reference>(); 283 return this.item; 284 } 285 286 /** 287 * @return Returns a reference to <code>this</code> for easy method chaining 288 */ 289 public ClinicalImpressionInvestigationComponent setItem(List<Reference> theItem) { 290 this.item = theItem; 291 return this; 292 } 293 294 public boolean hasItem() { 295 if (this.item == null) 296 return false; 297 for (Reference item : this.item) 298 if (!item.isEmpty()) 299 return true; 300 return false; 301 } 302 303 public Reference addItem() { // 3 304 Reference t = new Reference(); 305 if (this.item == null) 306 this.item = new ArrayList<Reference>(); 307 this.item.add(t); 308 return t; 309 } 310 311 public ClinicalImpressionInvestigationComponent addItem(Reference t) { // 3 312 if (t == null) 313 return this; 314 if (this.item == null) 315 this.item = new ArrayList<Reference>(); 316 this.item.add(t); 317 return this; 318 } 319 320 /** 321 * @return The first repetition of repeating field {@link #item}, creating it if 322 * it does not already exist 323 */ 324 public Reference getItemFirstRep() { 325 if (getItem().isEmpty()) { 326 addItem(); 327 } 328 return getItem().get(0); 329 } 330 331 /** 332 * @deprecated Use Reference#setResource(IBaseResource) instead 333 */ 334 @Deprecated 335 public List<Resource> getItemTarget() { 336 if (this.itemTarget == null) 337 this.itemTarget = new ArrayList<Resource>(); 338 return this.itemTarget; 339 } 340 341 protected void listChildren(List<Property> children) { 342 super.listChildren(children); 343 children.add(new Property("code", "CodeableConcept", 344 "A name/code for the group (\"set\") of investigations. Typically, this will be something like \"signs\", \"symptoms\", \"clinical\", \"diagnostic\", but the list is not constrained, and others such groups such as (exposure|family|travel|nutritional) history may be used.", 345 0, 1, code)); 346 children.add(new Property("item", 347 "Reference(Observation|QuestionnaireResponse|FamilyMemberHistory|DiagnosticReport|RiskAssessment|ImagingStudy|Media)", 348 "A record of a specific investigation that was undertaken.", 0, java.lang.Integer.MAX_VALUE, item)); 349 } 350 351 @Override 352 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 353 switch (_hash) { 354 case 3059181: 355 /* code */ return new Property("code", "CodeableConcept", 356 "A name/code for the group (\"set\") of investigations. Typically, this will be something like \"signs\", \"symptoms\", \"clinical\", \"diagnostic\", but the list is not constrained, and others such groups such as (exposure|family|travel|nutritional) history may be used.", 357 0, 1, code); 358 case 3242771: 359 /* item */ return new Property("item", 360 "Reference(Observation|QuestionnaireResponse|FamilyMemberHistory|DiagnosticReport|RiskAssessment|ImagingStudy|Media)", 361 "A record of a specific investigation that was undertaken.", 0, java.lang.Integer.MAX_VALUE, item); 362 default: 363 return super.getNamedProperty(_hash, _name, _checkValid); 364 } 365 366 } 367 368 @Override 369 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 370 switch (hash) { 371 case 3059181: 372 /* code */ return this.code == null ? new Base[0] : new Base[] { this.code }; // CodeableConcept 373 case 3242771: 374 /* item */ return this.item == null ? new Base[0] : this.item.toArray(new Base[this.item.size()]); // Reference 375 default: 376 return super.getProperty(hash, name, checkValid); 377 } 378 379 } 380 381 @Override 382 public Base setProperty(int hash, String name, Base value) throws FHIRException { 383 switch (hash) { 384 case 3059181: // code 385 this.code = castToCodeableConcept(value); // CodeableConcept 386 return value; 387 case 3242771: // item 388 this.getItem().add(castToReference(value)); // Reference 389 return value; 390 default: 391 return super.setProperty(hash, name, value); 392 } 393 394 } 395 396 @Override 397 public Base setProperty(String name, Base value) throws FHIRException { 398 if (name.equals("code")) { 399 this.code = castToCodeableConcept(value); // CodeableConcept 400 } else if (name.equals("item")) { 401 this.getItem().add(castToReference(value)); 402 } else 403 return super.setProperty(name, value); 404 return value; 405 } 406 407 @Override 408 public Base makeProperty(int hash, String name) throws FHIRException { 409 switch (hash) { 410 case 3059181: 411 return getCode(); 412 case 3242771: 413 return addItem(); 414 default: 415 return super.makeProperty(hash, name); 416 } 417 418 } 419 420 @Override 421 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 422 switch (hash) { 423 case 3059181: 424 /* code */ return new String[] { "CodeableConcept" }; 425 case 3242771: 426 /* item */ return new String[] { "Reference" }; 427 default: 428 return super.getTypesForProperty(hash, name); 429 } 430 431 } 432 433 @Override 434 public Base addChild(String name) throws FHIRException { 435 if (name.equals("code")) { 436 this.code = new CodeableConcept(); 437 return this.code; 438 } else if (name.equals("item")) { 439 return addItem(); 440 } else 441 return super.addChild(name); 442 } 443 444 public ClinicalImpressionInvestigationComponent copy() { 445 ClinicalImpressionInvestigationComponent dst = new ClinicalImpressionInvestigationComponent(); 446 copyValues(dst); 447 return dst; 448 } 449 450 public void copyValues(ClinicalImpressionInvestigationComponent dst) { 451 super.copyValues(dst); 452 dst.code = code == null ? null : code.copy(); 453 if (item != null) { 454 dst.item = new ArrayList<Reference>(); 455 for (Reference i : item) 456 dst.item.add(i.copy()); 457 } 458 ; 459 } 460 461 @Override 462 public boolean equalsDeep(Base other_) { 463 if (!super.equalsDeep(other_)) 464 return false; 465 if (!(other_ instanceof ClinicalImpressionInvestigationComponent)) 466 return false; 467 ClinicalImpressionInvestigationComponent o = (ClinicalImpressionInvestigationComponent) other_; 468 return compareDeep(code, o.code, true) && compareDeep(item, o.item, true); 469 } 470 471 @Override 472 public boolean equalsShallow(Base other_) { 473 if (!super.equalsShallow(other_)) 474 return false; 475 if (!(other_ instanceof ClinicalImpressionInvestigationComponent)) 476 return false; 477 ClinicalImpressionInvestigationComponent o = (ClinicalImpressionInvestigationComponent) other_; 478 return true; 479 } 480 481 public boolean isEmpty() { 482 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, item); 483 } 484 485 public String fhirType() { 486 return "ClinicalImpression.investigation"; 487 488 } 489 490 } 491 492 @Block() 493 public static class ClinicalImpressionFindingComponent extends BackboneElement implements IBaseBackboneElement { 494 /** 495 * Specific text or code for finding or diagnosis, which may include ruled-out 496 * or resolved conditions. 497 */ 498 @Child(name = "itemCodeableConcept", type = { 499 CodeableConcept.class }, order = 1, min = 0, max = 1, modifier = false, summary = false) 500 @Description(shortDefinition = "What was found", formalDefinition = "Specific text or code for finding or diagnosis, which may include ruled-out or resolved conditions.") 501 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/condition-code") 502 protected CodeableConcept itemCodeableConcept; 503 504 /** 505 * Specific reference for finding or diagnosis, which may include ruled-out or 506 * resolved conditions. 507 */ 508 @Child(name = "itemReference", type = { Condition.class, Observation.class, 509 Media.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 510 @Description(shortDefinition = "What was found", formalDefinition = "Specific reference for finding or diagnosis, which may include ruled-out or resolved conditions.") 511 protected Reference itemReference; 512 513 /** 514 * The actual object that is the target of the reference (Specific reference for 515 * finding or diagnosis, which may include ruled-out or resolved conditions.) 516 */ 517 protected Resource itemReferenceTarget; 518 519 /** 520 * Which investigations support finding or diagnosis. 521 */ 522 @Child(name = "basis", type = { StringType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false) 523 @Description(shortDefinition = "Which investigations support finding", formalDefinition = "Which investigations support finding or diagnosis.") 524 protected StringType basis; 525 526 private static final long serialVersionUID = -1578446448L; 527 528 /** 529 * Constructor 530 */ 531 public ClinicalImpressionFindingComponent() { 532 super(); 533 } 534 535 /** 536 * @return {@link #itemCodeableConcept} (Specific text or code for finding or 537 * diagnosis, which may include ruled-out or resolved conditions.) 538 */ 539 public CodeableConcept getItemCodeableConcept() { 540 if (this.itemCodeableConcept == null) 541 if (Configuration.errorOnAutoCreate()) 542 throw new Error("Attempt to auto-create ClinicalImpressionFindingComponent.itemCodeableConcept"); 543 else if (Configuration.doAutoCreate()) 544 this.itemCodeableConcept = new CodeableConcept(); // cc 545 return this.itemCodeableConcept; 546 } 547 548 public boolean hasItemCodeableConcept() { 549 return this.itemCodeableConcept != null && !this.itemCodeableConcept.isEmpty(); 550 } 551 552 /** 553 * @param value {@link #itemCodeableConcept} (Specific text or code for finding 554 * or diagnosis, which may include ruled-out or resolved 555 * conditions.) 556 */ 557 public ClinicalImpressionFindingComponent setItemCodeableConcept(CodeableConcept value) { 558 this.itemCodeableConcept = value; 559 return this; 560 } 561 562 /** 563 * @return {@link #itemReference} (Specific reference for finding or diagnosis, 564 * which may include ruled-out or resolved conditions.) 565 */ 566 public Reference getItemReference() { 567 if (this.itemReference == null) 568 if (Configuration.errorOnAutoCreate()) 569 throw new Error("Attempt to auto-create ClinicalImpressionFindingComponent.itemReference"); 570 else if (Configuration.doAutoCreate()) 571 this.itemReference = new Reference(); // cc 572 return this.itemReference; 573 } 574 575 public boolean hasItemReference() { 576 return this.itemReference != null && !this.itemReference.isEmpty(); 577 } 578 579 /** 580 * @param value {@link #itemReference} (Specific reference for finding or 581 * diagnosis, which may include ruled-out or resolved conditions.) 582 */ 583 public ClinicalImpressionFindingComponent setItemReference(Reference value) { 584 this.itemReference = value; 585 return this; 586 } 587 588 /** 589 * @return {@link #itemReference} The actual object that is the target of the 590 * reference. The reference library doesn't populate this, but you can 591 * use it to hold the resource if you resolve it. (Specific reference 592 * for finding or diagnosis, which may include ruled-out or resolved 593 * conditions.) 594 */ 595 public Resource getItemReferenceTarget() { 596 return this.itemReferenceTarget; 597 } 598 599 /** 600 * @param value {@link #itemReference} The actual object that is the target of 601 * the reference. The reference library doesn't use these, but you 602 * can use it to hold the resource if you resolve it. (Specific 603 * reference for finding or diagnosis, which may include ruled-out 604 * or resolved conditions.) 605 */ 606 public ClinicalImpressionFindingComponent setItemReferenceTarget(Resource value) { 607 this.itemReferenceTarget = value; 608 return this; 609 } 610 611 /** 612 * @return {@link #basis} (Which investigations support finding or diagnosis.). 613 * This is the underlying object with id, value and extensions. The 614 * accessor "getBasis" gives direct access to the value 615 */ 616 public StringType getBasisElement() { 617 if (this.basis == null) 618 if (Configuration.errorOnAutoCreate()) 619 throw new Error("Attempt to auto-create ClinicalImpressionFindingComponent.basis"); 620 else if (Configuration.doAutoCreate()) 621 this.basis = new StringType(); // bb 622 return this.basis; 623 } 624 625 public boolean hasBasisElement() { 626 return this.basis != null && !this.basis.isEmpty(); 627 } 628 629 public boolean hasBasis() { 630 return this.basis != null && !this.basis.isEmpty(); 631 } 632 633 /** 634 * @param value {@link #basis} (Which investigations support finding or 635 * diagnosis.). This is the underlying object with id, value and 636 * extensions. The accessor "getBasis" gives direct access to the 637 * value 638 */ 639 public ClinicalImpressionFindingComponent setBasisElement(StringType value) { 640 this.basis = value; 641 return this; 642 } 643 644 /** 645 * @return Which investigations support finding or diagnosis. 646 */ 647 public String getBasis() { 648 return this.basis == null ? null : this.basis.getValue(); 649 } 650 651 /** 652 * @param value Which investigations support finding or diagnosis. 653 */ 654 public ClinicalImpressionFindingComponent setBasis(String value) { 655 if (Utilities.noString(value)) 656 this.basis = null; 657 else { 658 if (this.basis == null) 659 this.basis = new StringType(); 660 this.basis.setValue(value); 661 } 662 return this; 663 } 664 665 protected void listChildren(List<Property> children) { 666 super.listChildren(children); 667 children.add(new Property("itemCodeableConcept", "CodeableConcept", 668 "Specific text or code for finding or diagnosis, which may include ruled-out or resolved conditions.", 0, 1, 669 itemCodeableConcept)); 670 children.add(new Property("itemReference", "Reference(Condition|Observation|Media)", 671 "Specific reference for finding or diagnosis, which may include ruled-out or resolved conditions.", 0, 1, 672 itemReference)); 673 children.add(new Property("basis", "string", "Which investigations support finding or diagnosis.", 0, 1, basis)); 674 } 675 676 @Override 677 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 678 switch (_hash) { 679 case 106644494: 680 /* itemCodeableConcept */ return new Property("itemCodeableConcept", "CodeableConcept", 681 "Specific text or code for finding or diagnosis, which may include ruled-out or resolved conditions.", 0, 1, 682 itemCodeableConcept); 683 case 1376364920: 684 /* itemReference */ return new Property("itemReference", "Reference(Condition|Observation|Media)", 685 "Specific reference for finding or diagnosis, which may include ruled-out or resolved conditions.", 0, 1, 686 itemReference); 687 case 93508670: 688 /* basis */ return new Property("basis", "string", "Which investigations support finding or diagnosis.", 0, 1, 689 basis); 690 default: 691 return super.getNamedProperty(_hash, _name, _checkValid); 692 } 693 694 } 695 696 @Override 697 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 698 switch (hash) { 699 case 106644494: 700 /* itemCodeableConcept */ return this.itemCodeableConcept == null ? new Base[0] 701 : new Base[] { this.itemCodeableConcept }; // CodeableConcept 702 case 1376364920: 703 /* itemReference */ return this.itemReference == null ? new Base[0] : new Base[] { this.itemReference }; // Reference 704 case 93508670: 705 /* basis */ return this.basis == null ? new Base[0] : new Base[] { this.basis }; // StringType 706 default: 707 return super.getProperty(hash, name, checkValid); 708 } 709 710 } 711 712 @Override 713 public Base setProperty(int hash, String name, Base value) throws FHIRException { 714 switch (hash) { 715 case 106644494: // itemCodeableConcept 716 this.itemCodeableConcept = castToCodeableConcept(value); // CodeableConcept 717 return value; 718 case 1376364920: // itemReference 719 this.itemReference = castToReference(value); // Reference 720 return value; 721 case 93508670: // basis 722 this.basis = castToString(value); // StringType 723 return value; 724 default: 725 return super.setProperty(hash, name, value); 726 } 727 728 } 729 730 @Override 731 public Base setProperty(String name, Base value) throws FHIRException { 732 if (name.equals("itemCodeableConcept")) { 733 this.itemCodeableConcept = castToCodeableConcept(value); // CodeableConcept 734 } else if (name.equals("itemReference")) { 735 this.itemReference = castToReference(value); // Reference 736 } else if (name.equals("basis")) { 737 this.basis = castToString(value); // StringType 738 } else 739 return super.setProperty(name, value); 740 return value; 741 } 742 743 @Override 744 public Base makeProperty(int hash, String name) throws FHIRException { 745 switch (hash) { 746 case 106644494: 747 return getItemCodeableConcept(); 748 case 1376364920: 749 return getItemReference(); 750 case 93508670: 751 return getBasisElement(); 752 default: 753 return super.makeProperty(hash, name); 754 } 755 756 } 757 758 @Override 759 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 760 switch (hash) { 761 case 106644494: 762 /* itemCodeableConcept */ return new String[] { "CodeableConcept" }; 763 case 1376364920: 764 /* itemReference */ return new String[] { "Reference" }; 765 case 93508670: 766 /* basis */ return new String[] { "string" }; 767 default: 768 return super.getTypesForProperty(hash, name); 769 } 770 771 } 772 773 @Override 774 public Base addChild(String name) throws FHIRException { 775 if (name.equals("itemCodeableConcept")) { 776 this.itemCodeableConcept = new CodeableConcept(); 777 return this.itemCodeableConcept; 778 } else if (name.equals("itemReference")) { 779 this.itemReference = new Reference(); 780 return this.itemReference; 781 } else if (name.equals("basis")) { 782 throw new FHIRException("Cannot call addChild on a singleton property ClinicalImpression.basis"); 783 } else 784 return super.addChild(name); 785 } 786 787 public ClinicalImpressionFindingComponent copy() { 788 ClinicalImpressionFindingComponent dst = new ClinicalImpressionFindingComponent(); 789 copyValues(dst); 790 return dst; 791 } 792 793 public void copyValues(ClinicalImpressionFindingComponent dst) { 794 super.copyValues(dst); 795 dst.itemCodeableConcept = itemCodeableConcept == null ? null : itemCodeableConcept.copy(); 796 dst.itemReference = itemReference == null ? null : itemReference.copy(); 797 dst.basis = basis == null ? null : basis.copy(); 798 } 799 800 @Override 801 public boolean equalsDeep(Base other_) { 802 if (!super.equalsDeep(other_)) 803 return false; 804 if (!(other_ instanceof ClinicalImpressionFindingComponent)) 805 return false; 806 ClinicalImpressionFindingComponent o = (ClinicalImpressionFindingComponent) other_; 807 return compareDeep(itemCodeableConcept, o.itemCodeableConcept, true) 808 && compareDeep(itemReference, o.itemReference, true) && compareDeep(basis, o.basis, true); 809 } 810 811 @Override 812 public boolean equalsShallow(Base other_) { 813 if (!super.equalsShallow(other_)) 814 return false; 815 if (!(other_ instanceof ClinicalImpressionFindingComponent)) 816 return false; 817 ClinicalImpressionFindingComponent o = (ClinicalImpressionFindingComponent) other_; 818 return compareValues(basis, o.basis, true); 819 } 820 821 public boolean isEmpty() { 822 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(itemCodeableConcept, itemReference, basis); 823 } 824 825 public String fhirType() { 826 return "ClinicalImpression.finding"; 827 828 } 829 830 } 831 832 /** 833 * Business identifiers assigned to this clinical impression by the performer or 834 * other systems which remain constant as the resource is updated and propagates 835 * from server to server. 836 */ 837 @Child(name = "identifier", type = { 838 Identifier.class }, order = 0, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 839 @Description(shortDefinition = "Business identifier", formalDefinition = "Business identifiers assigned to this clinical impression by the performer or other systems which remain constant as the resource is updated and propagates from server to server.") 840 protected List<Identifier> identifier; 841 842 /** 843 * Identifies the workflow status of the assessment. 844 */ 845 @Child(name = "status", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = true, summary = true) 846 @Description(shortDefinition = "in-progress | completed | entered-in-error", formalDefinition = "Identifies the workflow status of the assessment.") 847 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/clinicalimpression-status") 848 protected Enumeration<ClinicalImpressionStatus> status; 849 850 /** 851 * Captures the reason for the current state of the ClinicalImpression. 852 */ 853 @Child(name = "statusReason", type = { 854 CodeableConcept.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 855 @Description(shortDefinition = "Reason for current status", formalDefinition = "Captures the reason for the current state of the ClinicalImpression.") 856 protected CodeableConcept statusReason; 857 858 /** 859 * Categorizes the type of clinical assessment performed. 860 */ 861 @Child(name = "code", type = { CodeableConcept.class }, order = 3, min = 0, max = 1, modifier = false, summary = true) 862 @Description(shortDefinition = "Kind of assessment performed", formalDefinition = "Categorizes the type of clinical assessment performed.") 863 protected CodeableConcept code; 864 865 /** 866 * A summary of the context and/or cause of the assessment - why / where it was 867 * performed, and what patient events/status prompted it. 868 */ 869 @Child(name = "description", type = { 870 StringType.class }, order = 4, min = 0, max = 1, modifier = false, summary = true) 871 @Description(shortDefinition = "Why/how the assessment was performed", formalDefinition = "A summary of the context and/or cause of the assessment - why / where it was performed, and what patient events/status prompted it.") 872 protected StringType description; 873 874 /** 875 * The patient or group of individuals assessed as part of this record. 876 */ 877 @Child(name = "subject", type = { Patient.class, 878 Group.class }, order = 5, min = 1, max = 1, modifier = false, summary = true) 879 @Description(shortDefinition = "Patient or group assessed", formalDefinition = "The patient or group of individuals assessed as part of this record.") 880 protected Reference subject; 881 882 /** 883 * The actual object that is the target of the reference (The patient or group 884 * of individuals assessed as part of this record.) 885 */ 886 protected Resource subjectTarget; 887 888 /** 889 * The Encounter during which this ClinicalImpression was created or to which 890 * the creation of this record is tightly associated. 891 */ 892 @Child(name = "encounter", type = { Encounter.class }, order = 6, min = 0, max = 1, modifier = false, summary = true) 893 @Description(shortDefinition = "Encounter created as part of", formalDefinition = "The Encounter during which this ClinicalImpression was created or to which the creation of this record is tightly associated.") 894 protected Reference encounter; 895 896 /** 897 * The actual object that is the target of the reference (The Encounter during 898 * which this ClinicalImpression was created or to which the creation of this 899 * record is tightly associated.) 900 */ 901 protected Encounter encounterTarget; 902 903 /** 904 * The point in time or period over which the subject was assessed. 905 */ 906 @Child(name = "effective", type = { DateTimeType.class, 907 Period.class }, order = 7, min = 0, max = 1, modifier = false, summary = true) 908 @Description(shortDefinition = "Time of assessment", formalDefinition = "The point in time or period over which the subject was assessed.") 909 protected Type effective; 910 911 /** 912 * Indicates when the documentation of the assessment was complete. 913 */ 914 @Child(name = "date", type = { DateTimeType.class }, order = 8, min = 0, max = 1, modifier = false, summary = true) 915 @Description(shortDefinition = "When the assessment was documented", formalDefinition = "Indicates when the documentation of the assessment was complete.") 916 protected DateTimeType date; 917 918 /** 919 * The clinician performing the assessment. 920 */ 921 @Child(name = "assessor", type = { Practitioner.class, 922 PractitionerRole.class }, order = 9, min = 0, max = 1, modifier = false, summary = true) 923 @Description(shortDefinition = "The clinician performing the assessment", formalDefinition = "The clinician performing the assessment.") 924 protected Reference assessor; 925 926 /** 927 * The actual object that is the target of the reference (The clinician 928 * performing the assessment.) 929 */ 930 protected Resource assessorTarget; 931 932 /** 933 * A reference to the last assessment that was conducted on this patient. 934 * Assessments are often/usually ongoing in nature; a care provider 935 * (practitioner or team) will make new assessments on an ongoing basis as new 936 * data arises or the patient's conditions changes. 937 */ 938 @Child(name = "previous", type = { 939 ClinicalImpression.class }, order = 10, min = 0, max = 1, modifier = false, summary = false) 940 @Description(shortDefinition = "Reference to last assessment", formalDefinition = "A reference to the last assessment that was conducted on this patient. Assessments are often/usually ongoing in nature; a care provider (practitioner or team) will make new assessments on an ongoing basis as new data arises or the patient's conditions changes.") 941 protected Reference previous; 942 943 /** 944 * The actual object that is the target of the reference (A reference to the 945 * last assessment that was conducted on this patient. Assessments are 946 * often/usually ongoing in nature; a care provider (practitioner or team) will 947 * make new assessments on an ongoing basis as new data arises or the patient's 948 * conditions changes.) 949 */ 950 protected ClinicalImpression previousTarget; 951 952 /** 953 * A list of the relevant problems/conditions for a patient. 954 */ 955 @Child(name = "problem", type = { Condition.class, 956 AllergyIntolerance.class }, order = 11, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 957 @Description(shortDefinition = "Relevant impressions of patient state", formalDefinition = "A list of the relevant problems/conditions for a patient.") 958 protected List<Reference> problem; 959 /** 960 * The actual objects that are the target of the reference (A list of the 961 * relevant problems/conditions for a patient.) 962 */ 963 protected List<Resource> problemTarget; 964 965 /** 966 * One or more sets of investigations (signs, symptoms, etc.). The actual 967 * grouping of investigations varies greatly depending on the type and context 968 * of the assessment. These investigations may include data generated during the 969 * assessment process, or data previously generated and recorded that is 970 * pertinent to the outcomes. 971 */ 972 @Child(name = "investigation", type = {}, order = 12, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 973 @Description(shortDefinition = "One or more sets of investigations (signs, symptoms, etc.)", formalDefinition = "One or more sets of investigations (signs, symptoms, etc.). The actual grouping of investigations varies greatly depending on the type and context of the assessment. These investigations may include data generated during the assessment process, or data previously generated and recorded that is pertinent to the outcomes.") 974 protected List<ClinicalImpressionInvestigationComponent> investigation; 975 976 /** 977 * Reference to a specific published clinical protocol that was followed during 978 * this assessment, and/or that provides evidence in support of the diagnosis. 979 */ 980 @Child(name = "protocol", type = { 981 UriType.class }, order = 13, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 982 @Description(shortDefinition = "Clinical Protocol followed", formalDefinition = "Reference to a specific published clinical protocol that was followed during this assessment, and/or that provides evidence in support of the diagnosis.") 983 protected List<UriType> protocol; 984 985 /** 986 * A text summary of the investigations and the diagnosis. 987 */ 988 @Child(name = "summary", type = { StringType.class }, order = 14, min = 0, max = 1, modifier = false, summary = false) 989 @Description(shortDefinition = "Summary of the assessment", formalDefinition = "A text summary of the investigations and the diagnosis.") 990 protected StringType summary; 991 992 /** 993 * Specific findings or diagnoses that were considered likely or relevant to 994 * ongoing treatment. 995 */ 996 @Child(name = "finding", type = {}, order = 15, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 997 @Description(shortDefinition = "Possible or likely findings and diagnoses", formalDefinition = "Specific findings or diagnoses that were considered likely or relevant to ongoing treatment.") 998 protected List<ClinicalImpressionFindingComponent> finding; 999 1000 /** 1001 * Estimate of likely outcome. 1002 */ 1003 @Child(name = "prognosisCodeableConcept", type = { 1004 CodeableConcept.class }, order = 16, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1005 @Description(shortDefinition = "Estimate of likely outcome", formalDefinition = "Estimate of likely outcome.") 1006 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/clinicalimpression-prognosis") 1007 protected List<CodeableConcept> prognosisCodeableConcept; 1008 1009 /** 1010 * RiskAssessment expressing likely outcome. 1011 */ 1012 @Child(name = "prognosisReference", type = { 1013 RiskAssessment.class }, order = 17, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1014 @Description(shortDefinition = "RiskAssessment expressing likely outcome", formalDefinition = "RiskAssessment expressing likely outcome.") 1015 protected List<Reference> prognosisReference; 1016 /** 1017 * The actual objects that are the target of the reference (RiskAssessment 1018 * expressing likely outcome.) 1019 */ 1020 protected List<RiskAssessment> prognosisReferenceTarget; 1021 1022 /** 1023 * Information supporting the clinical impression. 1024 */ 1025 @Child(name = "supportingInfo", type = { 1026 Reference.class }, order = 18, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1027 @Description(shortDefinition = "Information supporting the clinical impression", formalDefinition = "Information supporting the clinical impression.") 1028 protected List<Reference> supportingInfo; 1029 /** 1030 * The actual objects that are the target of the reference (Information 1031 * supporting the clinical impression.) 1032 */ 1033 protected List<Resource> supportingInfoTarget; 1034 1035 /** 1036 * Commentary about the impression, typically recorded after the impression 1037 * itself was made, though supplemental notes by the original author could also 1038 * appear. 1039 */ 1040 @Child(name = "note", type = { 1041 Annotation.class }, order = 19, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1042 @Description(shortDefinition = "Comments made about the ClinicalImpression", formalDefinition = "Commentary about the impression, typically recorded after the impression itself was made, though supplemental notes by the original author could also appear.") 1043 protected List<Annotation> note; 1044 1045 private static final long serialVersionUID = 1158874575L; 1046 1047 /** 1048 * Constructor 1049 */ 1050 public ClinicalImpression() { 1051 super(); 1052 } 1053 1054 /** 1055 * Constructor 1056 */ 1057 public ClinicalImpression(Enumeration<ClinicalImpressionStatus> status, Reference subject) { 1058 super(); 1059 this.status = status; 1060 this.subject = subject; 1061 } 1062 1063 /** 1064 * @return {@link #identifier} (Business identifiers assigned to this clinical 1065 * impression by the performer or other systems which remain constant as 1066 * the resource is updated and propagates from server to server.) 1067 */ 1068 public List<Identifier> getIdentifier() { 1069 if (this.identifier == null) 1070 this.identifier = new ArrayList<Identifier>(); 1071 return this.identifier; 1072 } 1073 1074 /** 1075 * @return Returns a reference to <code>this</code> for easy method chaining 1076 */ 1077 public ClinicalImpression setIdentifier(List<Identifier> theIdentifier) { 1078 this.identifier = theIdentifier; 1079 return this; 1080 } 1081 1082 public boolean hasIdentifier() { 1083 if (this.identifier == null) 1084 return false; 1085 for (Identifier item : this.identifier) 1086 if (!item.isEmpty()) 1087 return true; 1088 return false; 1089 } 1090 1091 public Identifier addIdentifier() { // 3 1092 Identifier t = new Identifier(); 1093 if (this.identifier == null) 1094 this.identifier = new ArrayList<Identifier>(); 1095 this.identifier.add(t); 1096 return t; 1097 } 1098 1099 public ClinicalImpression addIdentifier(Identifier t) { // 3 1100 if (t == null) 1101 return this; 1102 if (this.identifier == null) 1103 this.identifier = new ArrayList<Identifier>(); 1104 this.identifier.add(t); 1105 return this; 1106 } 1107 1108 /** 1109 * @return The first repetition of repeating field {@link #identifier}, creating 1110 * it if it does not already exist 1111 */ 1112 public Identifier getIdentifierFirstRep() { 1113 if (getIdentifier().isEmpty()) { 1114 addIdentifier(); 1115 } 1116 return getIdentifier().get(0); 1117 } 1118 1119 /** 1120 * @return {@link #status} (Identifies the workflow status of the assessment.). 1121 * This is the underlying object with id, value and extensions. The 1122 * accessor "getStatus" gives direct access to the value 1123 */ 1124 public Enumeration<ClinicalImpressionStatus> getStatusElement() { 1125 if (this.status == null) 1126 if (Configuration.errorOnAutoCreate()) 1127 throw new Error("Attempt to auto-create ClinicalImpression.status"); 1128 else if (Configuration.doAutoCreate()) 1129 this.status = new Enumeration<ClinicalImpressionStatus>(new ClinicalImpressionStatusEnumFactory()); // bb 1130 return this.status; 1131 } 1132 1133 public boolean hasStatusElement() { 1134 return this.status != null && !this.status.isEmpty(); 1135 } 1136 1137 public boolean hasStatus() { 1138 return this.status != null && !this.status.isEmpty(); 1139 } 1140 1141 /** 1142 * @param value {@link #status} (Identifies the workflow status of the 1143 * assessment.). This is the underlying object with id, value and 1144 * extensions. The accessor "getStatus" gives direct access to the 1145 * value 1146 */ 1147 public ClinicalImpression setStatusElement(Enumeration<ClinicalImpressionStatus> value) { 1148 this.status = value; 1149 return this; 1150 } 1151 1152 /** 1153 * @return Identifies the workflow status of the assessment. 1154 */ 1155 public ClinicalImpressionStatus getStatus() { 1156 return this.status == null ? null : this.status.getValue(); 1157 } 1158 1159 /** 1160 * @param value Identifies the workflow status of the assessment. 1161 */ 1162 public ClinicalImpression setStatus(ClinicalImpressionStatus value) { 1163 if (this.status == null) 1164 this.status = new Enumeration<ClinicalImpressionStatus>(new ClinicalImpressionStatusEnumFactory()); 1165 this.status.setValue(value); 1166 return this; 1167 } 1168 1169 /** 1170 * @return {@link #statusReason} (Captures the reason for the current state of 1171 * the ClinicalImpression.) 1172 */ 1173 public CodeableConcept getStatusReason() { 1174 if (this.statusReason == null) 1175 if (Configuration.errorOnAutoCreate()) 1176 throw new Error("Attempt to auto-create ClinicalImpression.statusReason"); 1177 else if (Configuration.doAutoCreate()) 1178 this.statusReason = new CodeableConcept(); // cc 1179 return this.statusReason; 1180 } 1181 1182 public boolean hasStatusReason() { 1183 return this.statusReason != null && !this.statusReason.isEmpty(); 1184 } 1185 1186 /** 1187 * @param value {@link #statusReason} (Captures the reason for the current state 1188 * of the ClinicalImpression.) 1189 */ 1190 public ClinicalImpression setStatusReason(CodeableConcept value) { 1191 this.statusReason = value; 1192 return this; 1193 } 1194 1195 /** 1196 * @return {@link #code} (Categorizes the type of clinical assessment 1197 * performed.) 1198 */ 1199 public CodeableConcept getCode() { 1200 if (this.code == null) 1201 if (Configuration.errorOnAutoCreate()) 1202 throw new Error("Attempt to auto-create ClinicalImpression.code"); 1203 else if (Configuration.doAutoCreate()) 1204 this.code = new CodeableConcept(); // cc 1205 return this.code; 1206 } 1207 1208 public boolean hasCode() { 1209 return this.code != null && !this.code.isEmpty(); 1210 } 1211 1212 /** 1213 * @param value {@link #code} (Categorizes the type of clinical assessment 1214 * performed.) 1215 */ 1216 public ClinicalImpression setCode(CodeableConcept value) { 1217 this.code = value; 1218 return this; 1219 } 1220 1221 /** 1222 * @return {@link #description} (A summary of the context and/or cause of the 1223 * assessment - why / where it was performed, and what patient 1224 * events/status prompted it.). This is the underlying object with id, 1225 * value and extensions. The accessor "getDescription" gives direct 1226 * access to the value 1227 */ 1228 public StringType getDescriptionElement() { 1229 if (this.description == null) 1230 if (Configuration.errorOnAutoCreate()) 1231 throw new Error("Attempt to auto-create ClinicalImpression.description"); 1232 else if (Configuration.doAutoCreate()) 1233 this.description = new StringType(); // bb 1234 return this.description; 1235 } 1236 1237 public boolean hasDescriptionElement() { 1238 return this.description != null && !this.description.isEmpty(); 1239 } 1240 1241 public boolean hasDescription() { 1242 return this.description != null && !this.description.isEmpty(); 1243 } 1244 1245 /** 1246 * @param value {@link #description} (A summary of the context and/or cause of 1247 * the assessment - why / where it was performed, and what patient 1248 * events/status prompted it.). This is the underlying object with 1249 * id, value and extensions. The accessor "getDescription" gives 1250 * direct access to the value 1251 */ 1252 public ClinicalImpression setDescriptionElement(StringType value) { 1253 this.description = value; 1254 return this; 1255 } 1256 1257 /** 1258 * @return A summary of the context and/or cause of the assessment - why / where 1259 * it was performed, and what patient events/status prompted it. 1260 */ 1261 public String getDescription() { 1262 return this.description == null ? null : this.description.getValue(); 1263 } 1264 1265 /** 1266 * @param value A summary of the context and/or cause of the assessment - why / 1267 * where it was performed, and what patient events/status prompted 1268 * it. 1269 */ 1270 public ClinicalImpression setDescription(String value) { 1271 if (Utilities.noString(value)) 1272 this.description = null; 1273 else { 1274 if (this.description == null) 1275 this.description = new StringType(); 1276 this.description.setValue(value); 1277 } 1278 return this; 1279 } 1280 1281 /** 1282 * @return {@link #subject} (The patient or group of individuals assessed as 1283 * part of this record.) 1284 */ 1285 public Reference getSubject() { 1286 if (this.subject == null) 1287 if (Configuration.errorOnAutoCreate()) 1288 throw new Error("Attempt to auto-create ClinicalImpression.subject"); 1289 else if (Configuration.doAutoCreate()) 1290 this.subject = new Reference(); // cc 1291 return this.subject; 1292 } 1293 1294 public boolean hasSubject() { 1295 return this.subject != null && !this.subject.isEmpty(); 1296 } 1297 1298 /** 1299 * @param value {@link #subject} (The patient or group of individuals assessed 1300 * as part of this record.) 1301 */ 1302 public ClinicalImpression setSubject(Reference value) { 1303 this.subject = value; 1304 return this; 1305 } 1306 1307 /** 1308 * @return {@link #subject} The actual object that is the target of the 1309 * reference. The reference library doesn't populate this, but you can 1310 * use it to hold the resource if you resolve it. (The patient or group 1311 * of individuals assessed as part of this record.) 1312 */ 1313 public Resource getSubjectTarget() { 1314 return this.subjectTarget; 1315 } 1316 1317 /** 1318 * @param value {@link #subject} The actual object that is the target of the 1319 * reference. The reference library doesn't use these, but you can 1320 * use it to hold the resource if you resolve it. (The patient or 1321 * group of individuals assessed as part of this record.) 1322 */ 1323 public ClinicalImpression setSubjectTarget(Resource value) { 1324 this.subjectTarget = value; 1325 return this; 1326 } 1327 1328 /** 1329 * @return {@link #encounter} (The Encounter during which this 1330 * ClinicalImpression was created or to which the creation of this 1331 * record is tightly associated.) 1332 */ 1333 public Reference getEncounter() { 1334 if (this.encounter == null) 1335 if (Configuration.errorOnAutoCreate()) 1336 throw new Error("Attempt to auto-create ClinicalImpression.encounter"); 1337 else if (Configuration.doAutoCreate()) 1338 this.encounter = new Reference(); // cc 1339 return this.encounter; 1340 } 1341 1342 public boolean hasEncounter() { 1343 return this.encounter != null && !this.encounter.isEmpty(); 1344 } 1345 1346 /** 1347 * @param value {@link #encounter} (The Encounter during which this 1348 * ClinicalImpression was created or to which the creation of this 1349 * record is tightly associated.) 1350 */ 1351 public ClinicalImpression setEncounter(Reference value) { 1352 this.encounter = value; 1353 return this; 1354 } 1355 1356 /** 1357 * @return {@link #encounter} The actual object that is the target of the 1358 * reference. The reference library doesn't populate this, but you can 1359 * use it to hold the resource if you resolve it. (The Encounter during 1360 * which this ClinicalImpression was created or to which the creation of 1361 * this record is tightly associated.) 1362 */ 1363 public Encounter getEncounterTarget() { 1364 if (this.encounterTarget == null) 1365 if (Configuration.errorOnAutoCreate()) 1366 throw new Error("Attempt to auto-create ClinicalImpression.encounter"); 1367 else if (Configuration.doAutoCreate()) 1368 this.encounterTarget = new Encounter(); // aa 1369 return this.encounterTarget; 1370 } 1371 1372 /** 1373 * @param value {@link #encounter} The actual object that is the target of the 1374 * reference. The reference library doesn't use these, but you can 1375 * use it to hold the resource if you resolve it. (The Encounter 1376 * during which this ClinicalImpression was created or to which the 1377 * creation of this record is tightly associated.) 1378 */ 1379 public ClinicalImpression setEncounterTarget(Encounter value) { 1380 this.encounterTarget = value; 1381 return this; 1382 } 1383 1384 /** 1385 * @return {@link #effective} (The point in time or period over which the 1386 * subject was assessed.) 1387 */ 1388 public Type getEffective() { 1389 return this.effective; 1390 } 1391 1392 /** 1393 * @return {@link #effective} (The point in time or period over which the 1394 * subject was assessed.) 1395 */ 1396 public DateTimeType getEffectiveDateTimeType() throws FHIRException { 1397 if (this.effective == null) 1398 this.effective = new DateTimeType(); 1399 if (!(this.effective instanceof DateTimeType)) 1400 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but " 1401 + this.effective.getClass().getName() + " was encountered"); 1402 return (DateTimeType) this.effective; 1403 } 1404 1405 public boolean hasEffectiveDateTimeType() { 1406 return this != null && this.effective instanceof DateTimeType; 1407 } 1408 1409 /** 1410 * @return {@link #effective} (The point in time or period over which the 1411 * subject was assessed.) 1412 */ 1413 public Period getEffectivePeriod() throws FHIRException { 1414 if (this.effective == null) 1415 this.effective = new Period(); 1416 if (!(this.effective instanceof Period)) 1417 throw new FHIRException("Type mismatch: the type Period was expected, but " + this.effective.getClass().getName() 1418 + " was encountered"); 1419 return (Period) this.effective; 1420 } 1421 1422 public boolean hasEffectivePeriod() { 1423 return this != null && this.effective instanceof Period; 1424 } 1425 1426 public boolean hasEffective() { 1427 return this.effective != null && !this.effective.isEmpty(); 1428 } 1429 1430 /** 1431 * @param value {@link #effective} (The point in time or period over which the 1432 * subject was assessed.) 1433 */ 1434 public ClinicalImpression setEffective(Type value) { 1435 if (value != null && !(value instanceof DateTimeType || value instanceof Period)) 1436 throw new Error("Not the right type for ClinicalImpression.effective[x]: " + value.fhirType()); 1437 this.effective = value; 1438 return this; 1439 } 1440 1441 /** 1442 * @return {@link #date} (Indicates when the documentation of the assessment was 1443 * complete.). This is the underlying object with id, value and 1444 * extensions. The accessor "getDate" gives direct access to the value 1445 */ 1446 public DateTimeType getDateElement() { 1447 if (this.date == null) 1448 if (Configuration.errorOnAutoCreate()) 1449 throw new Error("Attempt to auto-create ClinicalImpression.date"); 1450 else if (Configuration.doAutoCreate()) 1451 this.date = new DateTimeType(); // bb 1452 return this.date; 1453 } 1454 1455 public boolean hasDateElement() { 1456 return this.date != null && !this.date.isEmpty(); 1457 } 1458 1459 public boolean hasDate() { 1460 return this.date != null && !this.date.isEmpty(); 1461 } 1462 1463 /** 1464 * @param value {@link #date} (Indicates when the documentation of the 1465 * assessment was complete.). This is the underlying object with 1466 * id, value and extensions. The accessor "getDate" gives direct 1467 * access to the value 1468 */ 1469 public ClinicalImpression setDateElement(DateTimeType value) { 1470 this.date = value; 1471 return this; 1472 } 1473 1474 /** 1475 * @return Indicates when the documentation of the assessment was complete. 1476 */ 1477 public Date getDate() { 1478 return this.date == null ? null : this.date.getValue(); 1479 } 1480 1481 /** 1482 * @param value Indicates when the documentation of the assessment was complete. 1483 */ 1484 public ClinicalImpression setDate(Date value) { 1485 if (value == null) 1486 this.date = null; 1487 else { 1488 if (this.date == null) 1489 this.date = new DateTimeType(); 1490 this.date.setValue(value); 1491 } 1492 return this; 1493 } 1494 1495 /** 1496 * @return {@link #assessor} (The clinician performing the assessment.) 1497 */ 1498 public Reference getAssessor() { 1499 if (this.assessor == null) 1500 if (Configuration.errorOnAutoCreate()) 1501 throw new Error("Attempt to auto-create ClinicalImpression.assessor"); 1502 else if (Configuration.doAutoCreate()) 1503 this.assessor = new Reference(); // cc 1504 return this.assessor; 1505 } 1506 1507 public boolean hasAssessor() { 1508 return this.assessor != null && !this.assessor.isEmpty(); 1509 } 1510 1511 /** 1512 * @param value {@link #assessor} (The clinician performing the assessment.) 1513 */ 1514 public ClinicalImpression setAssessor(Reference value) { 1515 this.assessor = value; 1516 return this; 1517 } 1518 1519 /** 1520 * @return {@link #assessor} The actual object that is the target of the 1521 * reference. The reference library doesn't populate this, but you can 1522 * use it to hold the resource if you resolve it. (The clinician 1523 * performing the assessment.) 1524 */ 1525 public Resource getAssessorTarget() { 1526 return this.assessorTarget; 1527 } 1528 1529 /** 1530 * @param value {@link #assessor} The actual object that is the target of the 1531 * reference. The reference library doesn't use these, but you can 1532 * use it to hold the resource if you resolve it. (The clinician 1533 * performing the assessment.) 1534 */ 1535 public ClinicalImpression setAssessorTarget(Resource value) { 1536 this.assessorTarget = value; 1537 return this; 1538 } 1539 1540 /** 1541 * @return {@link #previous} (A reference to the last assessment that was 1542 * conducted on this patient. Assessments are often/usually ongoing in 1543 * nature; a care provider (practitioner or team) will make new 1544 * assessments on an ongoing basis as new data arises or the patient's 1545 * conditions changes.) 1546 */ 1547 public Reference getPrevious() { 1548 if (this.previous == null) 1549 if (Configuration.errorOnAutoCreate()) 1550 throw new Error("Attempt to auto-create ClinicalImpression.previous"); 1551 else if (Configuration.doAutoCreate()) 1552 this.previous = new Reference(); // cc 1553 return this.previous; 1554 } 1555 1556 public boolean hasPrevious() { 1557 return this.previous != null && !this.previous.isEmpty(); 1558 } 1559 1560 /** 1561 * @param value {@link #previous} (A reference to the last assessment that was 1562 * conducted on this patient. Assessments are often/usually ongoing 1563 * in nature; a care provider (practitioner or team) will make new 1564 * assessments on an ongoing basis as new data arises or the 1565 * patient's conditions changes.) 1566 */ 1567 public ClinicalImpression setPrevious(Reference value) { 1568 this.previous = value; 1569 return this; 1570 } 1571 1572 /** 1573 * @return {@link #previous} The actual object that is the target of the 1574 * reference. The reference library doesn't populate this, but you can 1575 * use it to hold the resource if you resolve it. (A reference to the 1576 * last assessment that was conducted on this patient. Assessments are 1577 * often/usually ongoing in nature; a care provider (practitioner or 1578 * team) will make new assessments on an ongoing basis as new data 1579 * arises or the patient's conditions changes.) 1580 */ 1581 public ClinicalImpression getPreviousTarget() { 1582 if (this.previousTarget == null) 1583 if (Configuration.errorOnAutoCreate()) 1584 throw new Error("Attempt to auto-create ClinicalImpression.previous"); 1585 else if (Configuration.doAutoCreate()) 1586 this.previousTarget = new ClinicalImpression(); // aa 1587 return this.previousTarget; 1588 } 1589 1590 /** 1591 * @param value {@link #previous} The actual object that is the target of the 1592 * reference. The reference library doesn't use these, but you can 1593 * use it to hold the resource if you resolve it. (A reference to 1594 * the last assessment that was conducted on this patient. 1595 * Assessments are often/usually ongoing in nature; a care provider 1596 * (practitioner or team) will make new assessments on an ongoing 1597 * basis as new data arises or the patient's conditions changes.) 1598 */ 1599 public ClinicalImpression setPreviousTarget(ClinicalImpression value) { 1600 this.previousTarget = value; 1601 return this; 1602 } 1603 1604 /** 1605 * @return {@link #problem} (A list of the relevant problems/conditions for a 1606 * patient.) 1607 */ 1608 public List<Reference> getProblem() { 1609 if (this.problem == null) 1610 this.problem = new ArrayList<Reference>(); 1611 return this.problem; 1612 } 1613 1614 /** 1615 * @return Returns a reference to <code>this</code> for easy method chaining 1616 */ 1617 public ClinicalImpression setProblem(List<Reference> theProblem) { 1618 this.problem = theProblem; 1619 return this; 1620 } 1621 1622 public boolean hasProblem() { 1623 if (this.problem == null) 1624 return false; 1625 for (Reference item : this.problem) 1626 if (!item.isEmpty()) 1627 return true; 1628 return false; 1629 } 1630 1631 public Reference addProblem() { // 3 1632 Reference t = new Reference(); 1633 if (this.problem == null) 1634 this.problem = new ArrayList<Reference>(); 1635 this.problem.add(t); 1636 return t; 1637 } 1638 1639 public ClinicalImpression addProblem(Reference t) { // 3 1640 if (t == null) 1641 return this; 1642 if (this.problem == null) 1643 this.problem = new ArrayList<Reference>(); 1644 this.problem.add(t); 1645 return this; 1646 } 1647 1648 /** 1649 * @return The first repetition of repeating field {@link #problem}, creating it 1650 * if it does not already exist 1651 */ 1652 public Reference getProblemFirstRep() { 1653 if (getProblem().isEmpty()) { 1654 addProblem(); 1655 } 1656 return getProblem().get(0); 1657 } 1658 1659 /** 1660 * @deprecated Use Reference#setResource(IBaseResource) instead 1661 */ 1662 @Deprecated 1663 public List<Resource> getProblemTarget() { 1664 if (this.problemTarget == null) 1665 this.problemTarget = new ArrayList<Resource>(); 1666 return this.problemTarget; 1667 } 1668 1669 /** 1670 * @return {@link #investigation} (One or more sets of investigations (signs, 1671 * symptoms, etc.). The actual grouping of investigations varies greatly 1672 * depending on the type and context of the assessment. These 1673 * investigations may include data generated during the assessment 1674 * process, or data previously generated and recorded that is pertinent 1675 * to the outcomes.) 1676 */ 1677 public List<ClinicalImpressionInvestigationComponent> getInvestigation() { 1678 if (this.investigation == null) 1679 this.investigation = new ArrayList<ClinicalImpressionInvestigationComponent>(); 1680 return this.investigation; 1681 } 1682 1683 /** 1684 * @return Returns a reference to <code>this</code> for easy method chaining 1685 */ 1686 public ClinicalImpression setInvestigation(List<ClinicalImpressionInvestigationComponent> theInvestigation) { 1687 this.investigation = theInvestigation; 1688 return this; 1689 } 1690 1691 public boolean hasInvestigation() { 1692 if (this.investigation == null) 1693 return false; 1694 for (ClinicalImpressionInvestigationComponent item : this.investigation) 1695 if (!item.isEmpty()) 1696 return true; 1697 return false; 1698 } 1699 1700 public ClinicalImpressionInvestigationComponent addInvestigation() { // 3 1701 ClinicalImpressionInvestigationComponent t = new ClinicalImpressionInvestigationComponent(); 1702 if (this.investigation == null) 1703 this.investigation = new ArrayList<ClinicalImpressionInvestigationComponent>(); 1704 this.investigation.add(t); 1705 return t; 1706 } 1707 1708 public ClinicalImpression addInvestigation(ClinicalImpressionInvestigationComponent t) { // 3 1709 if (t == null) 1710 return this; 1711 if (this.investigation == null) 1712 this.investigation = new ArrayList<ClinicalImpressionInvestigationComponent>(); 1713 this.investigation.add(t); 1714 return this; 1715 } 1716 1717 /** 1718 * @return The first repetition of repeating field {@link #investigation}, 1719 * creating it if it does not already exist 1720 */ 1721 public ClinicalImpressionInvestigationComponent getInvestigationFirstRep() { 1722 if (getInvestigation().isEmpty()) { 1723 addInvestigation(); 1724 } 1725 return getInvestigation().get(0); 1726 } 1727 1728 /** 1729 * @return {@link #protocol} (Reference to a specific published clinical 1730 * protocol that was followed during this assessment, and/or that 1731 * provides evidence in support of the diagnosis.) 1732 */ 1733 public List<UriType> getProtocol() { 1734 if (this.protocol == null) 1735 this.protocol = new ArrayList<UriType>(); 1736 return this.protocol; 1737 } 1738 1739 /** 1740 * @return Returns a reference to <code>this</code> for easy method chaining 1741 */ 1742 public ClinicalImpression setProtocol(List<UriType> theProtocol) { 1743 this.protocol = theProtocol; 1744 return this; 1745 } 1746 1747 public boolean hasProtocol() { 1748 if (this.protocol == null) 1749 return false; 1750 for (UriType item : this.protocol) 1751 if (!item.isEmpty()) 1752 return true; 1753 return false; 1754 } 1755 1756 /** 1757 * @return {@link #protocol} (Reference to a specific published clinical 1758 * protocol that was followed during this assessment, and/or that 1759 * provides evidence in support of the diagnosis.) 1760 */ 1761 public UriType addProtocolElement() {// 2 1762 UriType t = new UriType(); 1763 if (this.protocol == null) 1764 this.protocol = new ArrayList<UriType>(); 1765 this.protocol.add(t); 1766 return t; 1767 } 1768 1769 /** 1770 * @param value {@link #protocol} (Reference to a specific published clinical 1771 * protocol that was followed during this assessment, and/or that 1772 * provides evidence in support of the diagnosis.) 1773 */ 1774 public ClinicalImpression addProtocol(String value) { // 1 1775 UriType t = new UriType(); 1776 t.setValue(value); 1777 if (this.protocol == null) 1778 this.protocol = new ArrayList<UriType>(); 1779 this.protocol.add(t); 1780 return this; 1781 } 1782 1783 /** 1784 * @param value {@link #protocol} (Reference to a specific published clinical 1785 * protocol that was followed during this assessment, and/or that 1786 * provides evidence in support of the diagnosis.) 1787 */ 1788 public boolean hasProtocol(String value) { 1789 if (this.protocol == null) 1790 return false; 1791 for (UriType v : this.protocol) 1792 if (v.getValue().equals(value)) // uri 1793 return true; 1794 return false; 1795 } 1796 1797 /** 1798 * @return {@link #summary} (A text summary of the investigations and the 1799 * diagnosis.). This is the underlying object with id, value and 1800 * extensions. The accessor "getSummary" gives direct access to the 1801 * value 1802 */ 1803 public StringType getSummaryElement() { 1804 if (this.summary == null) 1805 if (Configuration.errorOnAutoCreate()) 1806 throw new Error("Attempt to auto-create ClinicalImpression.summary"); 1807 else if (Configuration.doAutoCreate()) 1808 this.summary = new StringType(); // bb 1809 return this.summary; 1810 } 1811 1812 public boolean hasSummaryElement() { 1813 return this.summary != null && !this.summary.isEmpty(); 1814 } 1815 1816 public boolean hasSummary() { 1817 return this.summary != null && !this.summary.isEmpty(); 1818 } 1819 1820 /** 1821 * @param value {@link #summary} (A text summary of the investigations and the 1822 * diagnosis.). This is the underlying object with id, value and 1823 * extensions. The accessor "getSummary" gives direct access to the 1824 * value 1825 */ 1826 public ClinicalImpression setSummaryElement(StringType value) { 1827 this.summary = value; 1828 return this; 1829 } 1830 1831 /** 1832 * @return A text summary of the investigations and the diagnosis. 1833 */ 1834 public String getSummary() { 1835 return this.summary == null ? null : this.summary.getValue(); 1836 } 1837 1838 /** 1839 * @param value A text summary of the investigations and the diagnosis. 1840 */ 1841 public ClinicalImpression setSummary(String value) { 1842 if (Utilities.noString(value)) 1843 this.summary = null; 1844 else { 1845 if (this.summary == null) 1846 this.summary = new StringType(); 1847 this.summary.setValue(value); 1848 } 1849 return this; 1850 } 1851 1852 /** 1853 * @return {@link #finding} (Specific findings or diagnoses that were considered 1854 * likely or relevant to ongoing treatment.) 1855 */ 1856 public List<ClinicalImpressionFindingComponent> getFinding() { 1857 if (this.finding == null) 1858 this.finding = new ArrayList<ClinicalImpressionFindingComponent>(); 1859 return this.finding; 1860 } 1861 1862 /** 1863 * @return Returns a reference to <code>this</code> for easy method chaining 1864 */ 1865 public ClinicalImpression setFinding(List<ClinicalImpressionFindingComponent> theFinding) { 1866 this.finding = theFinding; 1867 return this; 1868 } 1869 1870 public boolean hasFinding() { 1871 if (this.finding == null) 1872 return false; 1873 for (ClinicalImpressionFindingComponent item : this.finding) 1874 if (!item.isEmpty()) 1875 return true; 1876 return false; 1877 } 1878 1879 public ClinicalImpressionFindingComponent addFinding() { // 3 1880 ClinicalImpressionFindingComponent t = new ClinicalImpressionFindingComponent(); 1881 if (this.finding == null) 1882 this.finding = new ArrayList<ClinicalImpressionFindingComponent>(); 1883 this.finding.add(t); 1884 return t; 1885 } 1886 1887 public ClinicalImpression addFinding(ClinicalImpressionFindingComponent t) { // 3 1888 if (t == null) 1889 return this; 1890 if (this.finding == null) 1891 this.finding = new ArrayList<ClinicalImpressionFindingComponent>(); 1892 this.finding.add(t); 1893 return this; 1894 } 1895 1896 /** 1897 * @return The first repetition of repeating field {@link #finding}, creating it 1898 * if it does not already exist 1899 */ 1900 public ClinicalImpressionFindingComponent getFindingFirstRep() { 1901 if (getFinding().isEmpty()) { 1902 addFinding(); 1903 } 1904 return getFinding().get(0); 1905 } 1906 1907 /** 1908 * @return {@link #prognosisCodeableConcept} (Estimate of likely outcome.) 1909 */ 1910 public List<CodeableConcept> getPrognosisCodeableConcept() { 1911 if (this.prognosisCodeableConcept == null) 1912 this.prognosisCodeableConcept = new ArrayList<CodeableConcept>(); 1913 return this.prognosisCodeableConcept; 1914 } 1915 1916 /** 1917 * @return Returns a reference to <code>this</code> for easy method chaining 1918 */ 1919 public ClinicalImpression setPrognosisCodeableConcept(List<CodeableConcept> thePrognosisCodeableConcept) { 1920 this.prognosisCodeableConcept = thePrognosisCodeableConcept; 1921 return this; 1922 } 1923 1924 public boolean hasPrognosisCodeableConcept() { 1925 if (this.prognosisCodeableConcept == null) 1926 return false; 1927 for (CodeableConcept item : this.prognosisCodeableConcept) 1928 if (!item.isEmpty()) 1929 return true; 1930 return false; 1931 } 1932 1933 public CodeableConcept addPrognosisCodeableConcept() { // 3 1934 CodeableConcept t = new CodeableConcept(); 1935 if (this.prognosisCodeableConcept == null) 1936 this.prognosisCodeableConcept = new ArrayList<CodeableConcept>(); 1937 this.prognosisCodeableConcept.add(t); 1938 return t; 1939 } 1940 1941 public ClinicalImpression addPrognosisCodeableConcept(CodeableConcept t) { // 3 1942 if (t == null) 1943 return this; 1944 if (this.prognosisCodeableConcept == null) 1945 this.prognosisCodeableConcept = new ArrayList<CodeableConcept>(); 1946 this.prognosisCodeableConcept.add(t); 1947 return this; 1948 } 1949 1950 /** 1951 * @return The first repetition of repeating field 1952 * {@link #prognosisCodeableConcept}, creating it if it does not already 1953 * exist 1954 */ 1955 public CodeableConcept getPrognosisCodeableConceptFirstRep() { 1956 if (getPrognosisCodeableConcept().isEmpty()) { 1957 addPrognosisCodeableConcept(); 1958 } 1959 return getPrognosisCodeableConcept().get(0); 1960 } 1961 1962 /** 1963 * @return {@link #prognosisReference} (RiskAssessment expressing likely 1964 * outcome.) 1965 */ 1966 public List<Reference> getPrognosisReference() { 1967 if (this.prognosisReference == null) 1968 this.prognosisReference = new ArrayList<Reference>(); 1969 return this.prognosisReference; 1970 } 1971 1972 /** 1973 * @return Returns a reference to <code>this</code> for easy method chaining 1974 */ 1975 public ClinicalImpression setPrognosisReference(List<Reference> thePrognosisReference) { 1976 this.prognosisReference = thePrognosisReference; 1977 return this; 1978 } 1979 1980 public boolean hasPrognosisReference() { 1981 if (this.prognosisReference == null) 1982 return false; 1983 for (Reference item : this.prognosisReference) 1984 if (!item.isEmpty()) 1985 return true; 1986 return false; 1987 } 1988 1989 public Reference addPrognosisReference() { // 3 1990 Reference t = new Reference(); 1991 if (this.prognosisReference == null) 1992 this.prognosisReference = new ArrayList<Reference>(); 1993 this.prognosisReference.add(t); 1994 return t; 1995 } 1996 1997 public ClinicalImpression addPrognosisReference(Reference t) { // 3 1998 if (t == null) 1999 return this; 2000 if (this.prognosisReference == null) 2001 this.prognosisReference = new ArrayList<Reference>(); 2002 this.prognosisReference.add(t); 2003 return this; 2004 } 2005 2006 /** 2007 * @return The first repetition of repeating field {@link #prognosisReference}, 2008 * creating it if it does not already exist 2009 */ 2010 public Reference getPrognosisReferenceFirstRep() { 2011 if (getPrognosisReference().isEmpty()) { 2012 addPrognosisReference(); 2013 } 2014 return getPrognosisReference().get(0); 2015 } 2016 2017 /** 2018 * @deprecated Use Reference#setResource(IBaseResource) instead 2019 */ 2020 @Deprecated 2021 public List<RiskAssessment> getPrognosisReferenceTarget() { 2022 if (this.prognosisReferenceTarget == null) 2023 this.prognosisReferenceTarget = new ArrayList<RiskAssessment>(); 2024 return this.prognosisReferenceTarget; 2025 } 2026 2027 /** 2028 * @deprecated Use Reference#setResource(IBaseResource) instead 2029 */ 2030 @Deprecated 2031 public RiskAssessment addPrognosisReferenceTarget() { 2032 RiskAssessment r = new RiskAssessment(); 2033 if (this.prognosisReferenceTarget == null) 2034 this.prognosisReferenceTarget = new ArrayList<RiskAssessment>(); 2035 this.prognosisReferenceTarget.add(r); 2036 return r; 2037 } 2038 2039 /** 2040 * @return {@link #supportingInfo} (Information supporting the clinical 2041 * impression.) 2042 */ 2043 public List<Reference> getSupportingInfo() { 2044 if (this.supportingInfo == null) 2045 this.supportingInfo = new ArrayList<Reference>(); 2046 return this.supportingInfo; 2047 } 2048 2049 /** 2050 * @return Returns a reference to <code>this</code> for easy method chaining 2051 */ 2052 public ClinicalImpression setSupportingInfo(List<Reference> theSupportingInfo) { 2053 this.supportingInfo = theSupportingInfo; 2054 return this; 2055 } 2056 2057 public boolean hasSupportingInfo() { 2058 if (this.supportingInfo == null) 2059 return false; 2060 for (Reference item : this.supportingInfo) 2061 if (!item.isEmpty()) 2062 return true; 2063 return false; 2064 } 2065 2066 public Reference addSupportingInfo() { // 3 2067 Reference t = new Reference(); 2068 if (this.supportingInfo == null) 2069 this.supportingInfo = new ArrayList<Reference>(); 2070 this.supportingInfo.add(t); 2071 return t; 2072 } 2073 2074 public ClinicalImpression addSupportingInfo(Reference t) { // 3 2075 if (t == null) 2076 return this; 2077 if (this.supportingInfo == null) 2078 this.supportingInfo = new ArrayList<Reference>(); 2079 this.supportingInfo.add(t); 2080 return this; 2081 } 2082 2083 /** 2084 * @return The first repetition of repeating field {@link #supportingInfo}, 2085 * creating it if it does not already exist 2086 */ 2087 public Reference getSupportingInfoFirstRep() { 2088 if (getSupportingInfo().isEmpty()) { 2089 addSupportingInfo(); 2090 } 2091 return getSupportingInfo().get(0); 2092 } 2093 2094 /** 2095 * @deprecated Use Reference#setResource(IBaseResource) instead 2096 */ 2097 @Deprecated 2098 public List<Resource> getSupportingInfoTarget() { 2099 if (this.supportingInfoTarget == null) 2100 this.supportingInfoTarget = new ArrayList<Resource>(); 2101 return this.supportingInfoTarget; 2102 } 2103 2104 /** 2105 * @return {@link #note} (Commentary about the impression, typically recorded 2106 * after the impression itself was made, though supplemental notes by 2107 * the original author could also appear.) 2108 */ 2109 public List<Annotation> getNote() { 2110 if (this.note == null) 2111 this.note = new ArrayList<Annotation>(); 2112 return this.note; 2113 } 2114 2115 /** 2116 * @return Returns a reference to <code>this</code> for easy method chaining 2117 */ 2118 public ClinicalImpression setNote(List<Annotation> theNote) { 2119 this.note = theNote; 2120 return this; 2121 } 2122 2123 public boolean hasNote() { 2124 if (this.note == null) 2125 return false; 2126 for (Annotation item : this.note) 2127 if (!item.isEmpty()) 2128 return true; 2129 return false; 2130 } 2131 2132 public Annotation addNote() { // 3 2133 Annotation t = new Annotation(); 2134 if (this.note == null) 2135 this.note = new ArrayList<Annotation>(); 2136 this.note.add(t); 2137 return t; 2138 } 2139 2140 public ClinicalImpression addNote(Annotation t) { // 3 2141 if (t == null) 2142 return this; 2143 if (this.note == null) 2144 this.note = new ArrayList<Annotation>(); 2145 this.note.add(t); 2146 return this; 2147 } 2148 2149 /** 2150 * @return The first repetition of repeating field {@link #note}, creating it if 2151 * it does not already exist 2152 */ 2153 public Annotation getNoteFirstRep() { 2154 if (getNote().isEmpty()) { 2155 addNote(); 2156 } 2157 return getNote().get(0); 2158 } 2159 2160 protected void listChildren(List<Property> children) { 2161 super.listChildren(children); 2162 children.add(new Property("identifier", "Identifier", 2163 "Business identifiers assigned to this clinical impression by the performer or other systems which remain constant as the resource is updated and propagates from server to server.", 2164 0, java.lang.Integer.MAX_VALUE, identifier)); 2165 children.add(new Property("status", "code", "Identifies the workflow status of the assessment.", 0, 1, status)); 2166 children.add(new Property("statusReason", "CodeableConcept", 2167 "Captures the reason for the current state of the ClinicalImpression.", 0, 1, statusReason)); 2168 children.add( 2169 new Property("code", "CodeableConcept", "Categorizes the type of clinical assessment performed.", 0, 1, code)); 2170 children.add(new Property("description", "string", 2171 "A summary of the context and/or cause of the assessment - why / where it was performed, and what patient events/status prompted it.", 2172 0, 1, description)); 2173 children.add(new Property("subject", "Reference(Patient|Group)", 2174 "The patient or group of individuals assessed as part of this record.", 0, 1, subject)); 2175 children.add(new Property("encounter", "Reference(Encounter)", 2176 "The Encounter during which this ClinicalImpression was created or to which the creation of this record is tightly associated.", 2177 0, 1, encounter)); 2178 children.add(new Property("effective[x]", "dateTime|Period", 2179 "The point in time or period over which the subject was assessed.", 0, 1, effective)); 2180 children.add(new Property("date", "dateTime", "Indicates when the documentation of the assessment was complete.", 0, 2181 1, date)); 2182 children.add(new Property("assessor", "Reference(Practitioner|PractitionerRole)", 2183 "The clinician performing the assessment.", 0, 1, assessor)); 2184 children.add(new Property("previous", "Reference(ClinicalImpression)", 2185 "A reference to the last assessment that was conducted on this patient. Assessments are often/usually ongoing in nature; a care provider (practitioner or team) will make new assessments on an ongoing basis as new data arises or the patient's conditions changes.", 2186 0, 1, previous)); 2187 children.add(new Property("problem", "Reference(Condition|AllergyIntolerance)", 2188 "A list of the relevant problems/conditions for a patient.", 0, java.lang.Integer.MAX_VALUE, problem)); 2189 children.add(new Property("investigation", "", 2190 "One or more sets of investigations (signs, symptoms, etc.). The actual grouping of investigations varies greatly depending on the type and context of the assessment. These investigations may include data generated during the assessment process, or data previously generated and recorded that is pertinent to the outcomes.", 2191 0, java.lang.Integer.MAX_VALUE, investigation)); 2192 children.add(new Property("protocol", "uri", 2193 "Reference to a specific published clinical protocol that was followed during this assessment, and/or that provides evidence in support of the diagnosis.", 2194 0, java.lang.Integer.MAX_VALUE, protocol)); 2195 children.add( 2196 new Property("summary", "string", "A text summary of the investigations and the diagnosis.", 0, 1, summary)); 2197 children.add(new Property("finding", "", 2198 "Specific findings or diagnoses that were considered likely or relevant to ongoing treatment.", 0, 2199 java.lang.Integer.MAX_VALUE, finding)); 2200 children.add(new Property("prognosisCodeableConcept", "CodeableConcept", "Estimate of likely outcome.", 0, 2201 java.lang.Integer.MAX_VALUE, prognosisCodeableConcept)); 2202 children.add(new Property("prognosisReference", "Reference(RiskAssessment)", 2203 "RiskAssessment expressing likely outcome.", 0, java.lang.Integer.MAX_VALUE, prognosisReference)); 2204 children.add(new Property("supportingInfo", "Reference(Any)", "Information supporting the clinical impression.", 0, 2205 java.lang.Integer.MAX_VALUE, supportingInfo)); 2206 children.add(new Property("note", "Annotation", 2207 "Commentary about the impression, typically recorded after the impression itself was made, though supplemental notes by the original author could also appear.", 2208 0, java.lang.Integer.MAX_VALUE, note)); 2209 } 2210 2211 @Override 2212 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2213 switch (_hash) { 2214 case -1618432855: 2215 /* identifier */ return new Property("identifier", "Identifier", 2216 "Business identifiers assigned to this clinical impression by the performer or other systems which remain constant as the resource is updated and propagates from server to server.", 2217 0, java.lang.Integer.MAX_VALUE, identifier); 2218 case -892481550: 2219 /* status */ return new Property("status", "code", "Identifies the workflow status of the assessment.", 0, 1, 2220 status); 2221 case 2051346646: 2222 /* statusReason */ return new Property("statusReason", "CodeableConcept", 2223 "Captures the reason for the current state of the ClinicalImpression.", 0, 1, statusReason); 2224 case 3059181: 2225 /* code */ return new Property("code", "CodeableConcept", 2226 "Categorizes the type of clinical assessment performed.", 0, 1, code); 2227 case -1724546052: 2228 /* description */ return new Property("description", "string", 2229 "A summary of the context and/or cause of the assessment - why / where it was performed, and what patient events/status prompted it.", 2230 0, 1, description); 2231 case -1867885268: 2232 /* subject */ return new Property("subject", "Reference(Patient|Group)", 2233 "The patient or group of individuals assessed as part of this record.", 0, 1, subject); 2234 case 1524132147: 2235 /* encounter */ return new Property("encounter", "Reference(Encounter)", 2236 "The Encounter during which this ClinicalImpression was created or to which the creation of this record is tightly associated.", 2237 0, 1, encounter); 2238 case 247104889: 2239 /* effective[x] */ return new Property("effective[x]", "dateTime|Period", 2240 "The point in time or period over which the subject was assessed.", 0, 1, effective); 2241 case -1468651097: 2242 /* effective */ return new Property("effective[x]", "dateTime|Period", 2243 "The point in time or period over which the subject was assessed.", 0, 1, effective); 2244 case -275306910: 2245 /* effectiveDateTime */ return new Property("effective[x]", "dateTime|Period", 2246 "The point in time or period over which the subject was assessed.", 0, 1, effective); 2247 case -403934648: 2248 /* effectivePeriod */ return new Property("effective[x]", "dateTime|Period", 2249 "The point in time or period over which the subject was assessed.", 0, 1, effective); 2250 case 3076014: 2251 /* date */ return new Property("date", "dateTime", 2252 "Indicates when the documentation of the assessment was complete.", 0, 1, date); 2253 case -373213113: 2254 /* assessor */ return new Property("assessor", "Reference(Practitioner|PractitionerRole)", 2255 "The clinician performing the assessment.", 0, 1, assessor); 2256 case -1273775369: 2257 /* previous */ return new Property("previous", "Reference(ClinicalImpression)", 2258 "A reference to the last assessment that was conducted on this patient. Assessments are often/usually ongoing in nature; a care provider (practitioner or team) will make new assessments on an ongoing basis as new data arises or the patient's conditions changes.", 2259 0, 1, previous); 2260 case -309542241: 2261 /* problem */ return new Property("problem", "Reference(Condition|AllergyIntolerance)", 2262 "A list of the relevant problems/conditions for a patient.", 0, java.lang.Integer.MAX_VALUE, problem); 2263 case 956015362: 2264 /* investigation */ return new Property("investigation", "", 2265 "One or more sets of investigations (signs, symptoms, etc.). The actual grouping of investigations varies greatly depending on the type and context of the assessment. These investigations may include data generated during the assessment process, or data previously generated and recorded that is pertinent to the outcomes.", 2266 0, java.lang.Integer.MAX_VALUE, investigation); 2267 case -989163880: 2268 /* protocol */ return new Property("protocol", "uri", 2269 "Reference to a specific published clinical protocol that was followed during this assessment, and/or that provides evidence in support of the diagnosis.", 2270 0, java.lang.Integer.MAX_VALUE, protocol); 2271 case -1857640538: 2272 /* summary */ return new Property("summary", "string", "A text summary of the investigations and the diagnosis.", 2273 0, 1, summary); 2274 case -853173367: 2275 /* finding */ return new Property("finding", "", 2276 "Specific findings or diagnoses that were considered likely or relevant to ongoing treatment.", 0, 2277 java.lang.Integer.MAX_VALUE, finding); 2278 case -676337953: 2279 /* prognosisCodeableConcept */ return new Property("prognosisCodeableConcept", "CodeableConcept", 2280 "Estimate of likely outcome.", 0, java.lang.Integer.MAX_VALUE, prognosisCodeableConcept); 2281 case -587137783: 2282 /* prognosisReference */ return new Property("prognosisReference", "Reference(RiskAssessment)", 2283 "RiskAssessment expressing likely outcome.", 0, java.lang.Integer.MAX_VALUE, prognosisReference); 2284 case 1922406657: 2285 /* supportingInfo */ return new Property("supportingInfo", "Reference(Any)", 2286 "Information supporting the clinical impression.", 0, java.lang.Integer.MAX_VALUE, supportingInfo); 2287 case 3387378: 2288 /* note */ return new Property("note", "Annotation", 2289 "Commentary about the impression, typically recorded after the impression itself was made, though supplemental notes by the original author could also appear.", 2290 0, java.lang.Integer.MAX_VALUE, note); 2291 default: 2292 return super.getNamedProperty(_hash, _name, _checkValid); 2293 } 2294 2295 } 2296 2297 @Override 2298 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2299 switch (hash) { 2300 case -1618432855: 2301 /* identifier */ return this.identifier == null ? new Base[0] 2302 : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 2303 case -892481550: 2304 /* status */ return this.status == null ? new Base[0] : new Base[] { this.status }; // Enumeration<ClinicalImpressionStatus> 2305 case 2051346646: 2306 /* statusReason */ return this.statusReason == null ? new Base[0] : new Base[] { this.statusReason }; // CodeableConcept 2307 case 3059181: 2308 /* code */ return this.code == null ? new Base[0] : new Base[] { this.code }; // CodeableConcept 2309 case -1724546052: 2310 /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType 2311 case -1867885268: 2312 /* subject */ return this.subject == null ? new Base[0] : new Base[] { this.subject }; // Reference 2313 case 1524132147: 2314 /* encounter */ return this.encounter == null ? new Base[0] : new Base[] { this.encounter }; // Reference 2315 case -1468651097: 2316 /* effective */ return this.effective == null ? new Base[0] : new Base[] { this.effective }; // Type 2317 case 3076014: 2318 /* date */ return this.date == null ? new Base[0] : new Base[] { this.date }; // DateTimeType 2319 case -373213113: 2320 /* assessor */ return this.assessor == null ? new Base[0] : new Base[] { this.assessor }; // Reference 2321 case -1273775369: 2322 /* previous */ return this.previous == null ? new Base[0] : new Base[] { this.previous }; // Reference 2323 case -309542241: 2324 /* problem */ return this.problem == null ? new Base[0] : this.problem.toArray(new Base[this.problem.size()]); // Reference 2325 case 956015362: 2326 /* investigation */ return this.investigation == null ? new Base[0] 2327 : this.investigation.toArray(new Base[this.investigation.size()]); // ClinicalImpressionInvestigationComponent 2328 case -989163880: 2329 /* protocol */ return this.protocol == null ? new Base[0] : this.protocol.toArray(new Base[this.protocol.size()]); // UriType 2330 case -1857640538: 2331 /* summary */ return this.summary == null ? new Base[0] : new Base[] { this.summary }; // StringType 2332 case -853173367: 2333 /* finding */ return this.finding == null ? new Base[0] : this.finding.toArray(new Base[this.finding.size()]); // ClinicalImpressionFindingComponent 2334 case -676337953: 2335 /* prognosisCodeableConcept */ return this.prognosisCodeableConcept == null ? new Base[0] 2336 : this.prognosisCodeableConcept.toArray(new Base[this.prognosisCodeableConcept.size()]); // CodeableConcept 2337 case -587137783: 2338 /* prognosisReference */ return this.prognosisReference == null ? new Base[0] 2339 : this.prognosisReference.toArray(new Base[this.prognosisReference.size()]); // Reference 2340 case 1922406657: 2341 /* supportingInfo */ return this.supportingInfo == null ? new Base[0] 2342 : this.supportingInfo.toArray(new Base[this.supportingInfo.size()]); // Reference 2343 case 3387378: 2344 /* note */ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation 2345 default: 2346 return super.getProperty(hash, name, checkValid); 2347 } 2348 2349 } 2350 2351 @Override 2352 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2353 switch (hash) { 2354 case -1618432855: // identifier 2355 this.getIdentifier().add(castToIdentifier(value)); // Identifier 2356 return value; 2357 case -892481550: // status 2358 value = new ClinicalImpressionStatusEnumFactory().fromType(castToCode(value)); 2359 this.status = (Enumeration) value; // Enumeration<ClinicalImpressionStatus> 2360 return value; 2361 case 2051346646: // statusReason 2362 this.statusReason = castToCodeableConcept(value); // CodeableConcept 2363 return value; 2364 case 3059181: // code 2365 this.code = castToCodeableConcept(value); // CodeableConcept 2366 return value; 2367 case -1724546052: // description 2368 this.description = castToString(value); // StringType 2369 return value; 2370 case -1867885268: // subject 2371 this.subject = castToReference(value); // Reference 2372 return value; 2373 case 1524132147: // encounter 2374 this.encounter = castToReference(value); // Reference 2375 return value; 2376 case -1468651097: // effective 2377 this.effective = castToType(value); // Type 2378 return value; 2379 case 3076014: // date 2380 this.date = castToDateTime(value); // DateTimeType 2381 return value; 2382 case -373213113: // assessor 2383 this.assessor = castToReference(value); // Reference 2384 return value; 2385 case -1273775369: // previous 2386 this.previous = castToReference(value); // Reference 2387 return value; 2388 case -309542241: // problem 2389 this.getProblem().add(castToReference(value)); // Reference 2390 return value; 2391 case 956015362: // investigation 2392 this.getInvestigation().add((ClinicalImpressionInvestigationComponent) value); // ClinicalImpressionInvestigationComponent 2393 return value; 2394 case -989163880: // protocol 2395 this.getProtocol().add(castToUri(value)); // UriType 2396 return value; 2397 case -1857640538: // summary 2398 this.summary = castToString(value); // StringType 2399 return value; 2400 case -853173367: // finding 2401 this.getFinding().add((ClinicalImpressionFindingComponent) value); // ClinicalImpressionFindingComponent 2402 return value; 2403 case -676337953: // prognosisCodeableConcept 2404 this.getPrognosisCodeableConcept().add(castToCodeableConcept(value)); // CodeableConcept 2405 return value; 2406 case -587137783: // prognosisReference 2407 this.getPrognosisReference().add(castToReference(value)); // Reference 2408 return value; 2409 case 1922406657: // supportingInfo 2410 this.getSupportingInfo().add(castToReference(value)); // Reference 2411 return value; 2412 case 3387378: // note 2413 this.getNote().add(castToAnnotation(value)); // Annotation 2414 return value; 2415 default: 2416 return super.setProperty(hash, name, value); 2417 } 2418 2419 } 2420 2421 @Override 2422 public Base setProperty(String name, Base value) throws FHIRException { 2423 if (name.equals("identifier")) { 2424 this.getIdentifier().add(castToIdentifier(value)); 2425 } else if (name.equals("status")) { 2426 value = new ClinicalImpressionStatusEnumFactory().fromType(castToCode(value)); 2427 this.status = (Enumeration) value; // Enumeration<ClinicalImpressionStatus> 2428 } else if (name.equals("statusReason")) { 2429 this.statusReason = castToCodeableConcept(value); // CodeableConcept 2430 } else if (name.equals("code")) { 2431 this.code = castToCodeableConcept(value); // CodeableConcept 2432 } else if (name.equals("description")) { 2433 this.description = castToString(value); // StringType 2434 } else if (name.equals("subject")) { 2435 this.subject = castToReference(value); // Reference 2436 } else if (name.equals("encounter")) { 2437 this.encounter = castToReference(value); // Reference 2438 } else if (name.equals("effective[x]")) { 2439 this.effective = castToType(value); // Type 2440 } else if (name.equals("date")) { 2441 this.date = castToDateTime(value); // DateTimeType 2442 } else if (name.equals("assessor")) { 2443 this.assessor = castToReference(value); // Reference 2444 } else if (name.equals("previous")) { 2445 this.previous = castToReference(value); // Reference 2446 } else if (name.equals("problem")) { 2447 this.getProblem().add(castToReference(value)); 2448 } else if (name.equals("investigation")) { 2449 this.getInvestigation().add((ClinicalImpressionInvestigationComponent) value); 2450 } else if (name.equals("protocol")) { 2451 this.getProtocol().add(castToUri(value)); 2452 } else if (name.equals("summary")) { 2453 this.summary = castToString(value); // StringType 2454 } else if (name.equals("finding")) { 2455 this.getFinding().add((ClinicalImpressionFindingComponent) value); 2456 } else if (name.equals("prognosisCodeableConcept")) { 2457 this.getPrognosisCodeableConcept().add(castToCodeableConcept(value)); 2458 } else if (name.equals("prognosisReference")) { 2459 this.getPrognosisReference().add(castToReference(value)); 2460 } else if (name.equals("supportingInfo")) { 2461 this.getSupportingInfo().add(castToReference(value)); 2462 } else if (name.equals("note")) { 2463 this.getNote().add(castToAnnotation(value)); 2464 } else 2465 return super.setProperty(name, value); 2466 return value; 2467 } 2468 2469 @Override 2470 public Base makeProperty(int hash, String name) throws FHIRException { 2471 switch (hash) { 2472 case -1618432855: 2473 return addIdentifier(); 2474 case -892481550: 2475 return getStatusElement(); 2476 case 2051346646: 2477 return getStatusReason(); 2478 case 3059181: 2479 return getCode(); 2480 case -1724546052: 2481 return getDescriptionElement(); 2482 case -1867885268: 2483 return getSubject(); 2484 case 1524132147: 2485 return getEncounter(); 2486 case 247104889: 2487 return getEffective(); 2488 case -1468651097: 2489 return getEffective(); 2490 case 3076014: 2491 return getDateElement(); 2492 case -373213113: 2493 return getAssessor(); 2494 case -1273775369: 2495 return getPrevious(); 2496 case -309542241: 2497 return addProblem(); 2498 case 956015362: 2499 return addInvestigation(); 2500 case -989163880: 2501 return addProtocolElement(); 2502 case -1857640538: 2503 return getSummaryElement(); 2504 case -853173367: 2505 return addFinding(); 2506 case -676337953: 2507 return addPrognosisCodeableConcept(); 2508 case -587137783: 2509 return addPrognosisReference(); 2510 case 1922406657: 2511 return addSupportingInfo(); 2512 case 3387378: 2513 return addNote(); 2514 default: 2515 return super.makeProperty(hash, name); 2516 } 2517 2518 } 2519 2520 @Override 2521 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2522 switch (hash) { 2523 case -1618432855: 2524 /* identifier */ return new String[] { "Identifier" }; 2525 case -892481550: 2526 /* status */ return new String[] { "code" }; 2527 case 2051346646: 2528 /* statusReason */ return new String[] { "CodeableConcept" }; 2529 case 3059181: 2530 /* code */ return new String[] { "CodeableConcept" }; 2531 case -1724546052: 2532 /* description */ return new String[] { "string" }; 2533 case -1867885268: 2534 /* subject */ return new String[] { "Reference" }; 2535 case 1524132147: 2536 /* encounter */ return new String[] { "Reference" }; 2537 case -1468651097: 2538 /* effective */ return new String[] { "dateTime", "Period" }; 2539 case 3076014: 2540 /* date */ return new String[] { "dateTime" }; 2541 case -373213113: 2542 /* assessor */ return new String[] { "Reference" }; 2543 case -1273775369: 2544 /* previous */ return new String[] { "Reference" }; 2545 case -309542241: 2546 /* problem */ return new String[] { "Reference" }; 2547 case 956015362: 2548 /* investigation */ return new String[] {}; 2549 case -989163880: 2550 /* protocol */ return new String[] { "uri" }; 2551 case -1857640538: 2552 /* summary */ return new String[] { "string" }; 2553 case -853173367: 2554 /* finding */ return new String[] {}; 2555 case -676337953: 2556 /* prognosisCodeableConcept */ return new String[] { "CodeableConcept" }; 2557 case -587137783: 2558 /* prognosisReference */ return new String[] { "Reference" }; 2559 case 1922406657: 2560 /* supportingInfo */ return new String[] { "Reference" }; 2561 case 3387378: 2562 /* note */ return new String[] { "Annotation" }; 2563 default: 2564 return super.getTypesForProperty(hash, name); 2565 } 2566 2567 } 2568 2569 @Override 2570 public Base addChild(String name) throws FHIRException { 2571 if (name.equals("identifier")) { 2572 return addIdentifier(); 2573 } else if (name.equals("status")) { 2574 throw new FHIRException("Cannot call addChild on a singleton property ClinicalImpression.status"); 2575 } else if (name.equals("statusReason")) { 2576 this.statusReason = new CodeableConcept(); 2577 return this.statusReason; 2578 } else if (name.equals("code")) { 2579 this.code = new CodeableConcept(); 2580 return this.code; 2581 } else if (name.equals("description")) { 2582 throw new FHIRException("Cannot call addChild on a singleton property ClinicalImpression.description"); 2583 } else if (name.equals("subject")) { 2584 this.subject = new Reference(); 2585 return this.subject; 2586 } else if (name.equals("encounter")) { 2587 this.encounter = new Reference(); 2588 return this.encounter; 2589 } else if (name.equals("effectiveDateTime")) { 2590 this.effective = new DateTimeType(); 2591 return this.effective; 2592 } else if (name.equals("effectivePeriod")) { 2593 this.effective = new Period(); 2594 return this.effective; 2595 } else if (name.equals("date")) { 2596 throw new FHIRException("Cannot call addChild on a singleton property ClinicalImpression.date"); 2597 } else if (name.equals("assessor")) { 2598 this.assessor = new Reference(); 2599 return this.assessor; 2600 } else if (name.equals("previous")) { 2601 this.previous = new Reference(); 2602 return this.previous; 2603 } else if (name.equals("problem")) { 2604 return addProblem(); 2605 } else if (name.equals("investigation")) { 2606 return addInvestigation(); 2607 } else if (name.equals("protocol")) { 2608 throw new FHIRException("Cannot call addChild on a singleton property ClinicalImpression.protocol"); 2609 } else if (name.equals("summary")) { 2610 throw new FHIRException("Cannot call addChild on a singleton property ClinicalImpression.summary"); 2611 } else if (name.equals("finding")) { 2612 return addFinding(); 2613 } else if (name.equals("prognosisCodeableConcept")) { 2614 return addPrognosisCodeableConcept(); 2615 } else if (name.equals("prognosisReference")) { 2616 return addPrognosisReference(); 2617 } else if (name.equals("supportingInfo")) { 2618 return addSupportingInfo(); 2619 } else if (name.equals("note")) { 2620 return addNote(); 2621 } else 2622 return super.addChild(name); 2623 } 2624 2625 public String fhirType() { 2626 return "ClinicalImpression"; 2627 2628 } 2629 2630 public ClinicalImpression copy() { 2631 ClinicalImpression dst = new ClinicalImpression(); 2632 copyValues(dst); 2633 return dst; 2634 } 2635 2636 public void copyValues(ClinicalImpression dst) { 2637 super.copyValues(dst); 2638 if (identifier != null) { 2639 dst.identifier = new ArrayList<Identifier>(); 2640 for (Identifier i : identifier) 2641 dst.identifier.add(i.copy()); 2642 } 2643 ; 2644 dst.status = status == null ? null : status.copy(); 2645 dst.statusReason = statusReason == null ? null : statusReason.copy(); 2646 dst.code = code == null ? null : code.copy(); 2647 dst.description = description == null ? null : description.copy(); 2648 dst.subject = subject == null ? null : subject.copy(); 2649 dst.encounter = encounter == null ? null : encounter.copy(); 2650 dst.effective = effective == null ? null : effective.copy(); 2651 dst.date = date == null ? null : date.copy(); 2652 dst.assessor = assessor == null ? null : assessor.copy(); 2653 dst.previous = previous == null ? null : previous.copy(); 2654 if (problem != null) { 2655 dst.problem = new ArrayList<Reference>(); 2656 for (Reference i : problem) 2657 dst.problem.add(i.copy()); 2658 } 2659 ; 2660 if (investigation != null) { 2661 dst.investigation = new ArrayList<ClinicalImpressionInvestigationComponent>(); 2662 for (ClinicalImpressionInvestigationComponent i : investigation) 2663 dst.investigation.add(i.copy()); 2664 } 2665 ; 2666 if (protocol != null) { 2667 dst.protocol = new ArrayList<UriType>(); 2668 for (UriType i : protocol) 2669 dst.protocol.add(i.copy()); 2670 } 2671 ; 2672 dst.summary = summary == null ? null : summary.copy(); 2673 if (finding != null) { 2674 dst.finding = new ArrayList<ClinicalImpressionFindingComponent>(); 2675 for (ClinicalImpressionFindingComponent i : finding) 2676 dst.finding.add(i.copy()); 2677 } 2678 ; 2679 if (prognosisCodeableConcept != null) { 2680 dst.prognosisCodeableConcept = new ArrayList<CodeableConcept>(); 2681 for (CodeableConcept i : prognosisCodeableConcept) 2682 dst.prognosisCodeableConcept.add(i.copy()); 2683 } 2684 ; 2685 if (prognosisReference != null) { 2686 dst.prognosisReference = new ArrayList<Reference>(); 2687 for (Reference i : prognosisReference) 2688 dst.prognosisReference.add(i.copy()); 2689 } 2690 ; 2691 if (supportingInfo != null) { 2692 dst.supportingInfo = new ArrayList<Reference>(); 2693 for (Reference i : supportingInfo) 2694 dst.supportingInfo.add(i.copy()); 2695 } 2696 ; 2697 if (note != null) { 2698 dst.note = new ArrayList<Annotation>(); 2699 for (Annotation i : note) 2700 dst.note.add(i.copy()); 2701 } 2702 ; 2703 } 2704 2705 protected ClinicalImpression typedCopy() { 2706 return copy(); 2707 } 2708 2709 @Override 2710 public boolean equalsDeep(Base other_) { 2711 if (!super.equalsDeep(other_)) 2712 return false; 2713 if (!(other_ instanceof ClinicalImpression)) 2714 return false; 2715 ClinicalImpression o = (ClinicalImpression) other_; 2716 return compareDeep(identifier, o.identifier, true) && compareDeep(status, o.status, true) 2717 && compareDeep(statusReason, o.statusReason, true) && compareDeep(code, o.code, true) 2718 && compareDeep(description, o.description, true) && compareDeep(subject, o.subject, true) 2719 && compareDeep(encounter, o.encounter, true) && compareDeep(effective, o.effective, true) 2720 && compareDeep(date, o.date, true) && compareDeep(assessor, o.assessor, true) 2721 && compareDeep(previous, o.previous, true) && compareDeep(problem, o.problem, true) 2722 && compareDeep(investigation, o.investigation, true) && compareDeep(protocol, o.protocol, true) 2723 && compareDeep(summary, o.summary, true) && compareDeep(finding, o.finding, true) 2724 && compareDeep(prognosisCodeableConcept, o.prognosisCodeableConcept, true) 2725 && compareDeep(prognosisReference, o.prognosisReference, true) 2726 && compareDeep(supportingInfo, o.supportingInfo, true) && compareDeep(note, o.note, true); 2727 } 2728 2729 @Override 2730 public boolean equalsShallow(Base other_) { 2731 if (!super.equalsShallow(other_)) 2732 return false; 2733 if (!(other_ instanceof ClinicalImpression)) 2734 return false; 2735 ClinicalImpression o = (ClinicalImpression) other_; 2736 return compareValues(status, o.status, true) && compareValues(description, o.description, true) 2737 && compareValues(date, o.date, true) && compareValues(protocol, o.protocol, true) 2738 && compareValues(summary, o.summary, true); 2739 } 2740 2741 public boolean isEmpty() { 2742 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, status, statusReason, code, description, 2743 subject, encounter, effective, date, assessor, previous, problem, investigation, protocol, summary, finding, 2744 prognosisCodeableConcept, prognosisReference, supportingInfo, note); 2745 } 2746 2747 @Override 2748 public ResourceType getResourceType() { 2749 return ResourceType.ClinicalImpression; 2750 } 2751 2752 /** 2753 * Search parameter: <b>date</b> 2754 * <p> 2755 * Description: <b>When the assessment was documented</b><br> 2756 * Type: <b>date</b><br> 2757 * Path: <b>ClinicalImpression.date</b><br> 2758 * </p> 2759 */ 2760 @SearchParamDefinition(name = "date", path = "ClinicalImpression.date", description = "When the assessment was documented", type = "date") 2761 public static final String SP_DATE = "date"; 2762 /** 2763 * <b>Fluent Client</b> search parameter constant for <b>date</b> 2764 * <p> 2765 * Description: <b>When the assessment was documented</b><br> 2766 * Type: <b>date</b><br> 2767 * Path: <b>ClinicalImpression.date</b><br> 2768 * </p> 2769 */ 2770 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam( 2771 SP_DATE); 2772 2773 /** 2774 * Search parameter: <b>identifier</b> 2775 * <p> 2776 * Description: <b>Business identifier</b><br> 2777 * Type: <b>token</b><br> 2778 * Path: <b>ClinicalImpression.identifier</b><br> 2779 * </p> 2780 */ 2781 @SearchParamDefinition(name = "identifier", path = "ClinicalImpression.identifier", description = "Business identifier", type = "token") 2782 public static final String SP_IDENTIFIER = "identifier"; 2783 /** 2784 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 2785 * <p> 2786 * Description: <b>Business identifier</b><br> 2787 * Type: <b>token</b><br> 2788 * Path: <b>ClinicalImpression.identifier</b><br> 2789 * </p> 2790 */ 2791 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam( 2792 SP_IDENTIFIER); 2793 2794 /** 2795 * Search parameter: <b>previous</b> 2796 * <p> 2797 * Description: <b>Reference to last assessment</b><br> 2798 * Type: <b>reference</b><br> 2799 * Path: <b>ClinicalImpression.previous</b><br> 2800 * </p> 2801 */ 2802 @SearchParamDefinition(name = "previous", path = "ClinicalImpression.previous", description = "Reference to last assessment", type = "reference", target = { 2803 ClinicalImpression.class }) 2804 public static final String SP_PREVIOUS = "previous"; 2805 /** 2806 * <b>Fluent Client</b> search parameter constant for <b>previous</b> 2807 * <p> 2808 * Description: <b>Reference to last assessment</b><br> 2809 * Type: <b>reference</b><br> 2810 * Path: <b>ClinicalImpression.previous</b><br> 2811 * </p> 2812 */ 2813 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PREVIOUS = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 2814 SP_PREVIOUS); 2815 2816 /** 2817 * Constant for fluent queries to be used to add include statements. Specifies 2818 * the path value of "<b>ClinicalImpression:previous</b>". 2819 */ 2820 public static final ca.uhn.fhir.model.api.Include INCLUDE_PREVIOUS = new ca.uhn.fhir.model.api.Include( 2821 "ClinicalImpression:previous").toLocked(); 2822 2823 /** 2824 * Search parameter: <b>finding-code</b> 2825 * <p> 2826 * Description: <b>What was found</b><br> 2827 * Type: <b>token</b><br> 2828 * Path: <b>ClinicalImpression.finding.itemCodeableConcept</b><br> 2829 * </p> 2830 */ 2831 @SearchParamDefinition(name = "finding-code", path = "ClinicalImpression.finding.itemCodeableConcept", description = "What was found", type = "token") 2832 public static final String SP_FINDING_CODE = "finding-code"; 2833 /** 2834 * <b>Fluent Client</b> search parameter constant for <b>finding-code</b> 2835 * <p> 2836 * Description: <b>What was found</b><br> 2837 * Type: <b>token</b><br> 2838 * Path: <b>ClinicalImpression.finding.itemCodeableConcept</b><br> 2839 * </p> 2840 */ 2841 public static final ca.uhn.fhir.rest.gclient.TokenClientParam FINDING_CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam( 2842 SP_FINDING_CODE); 2843 2844 /** 2845 * Search parameter: <b>assessor</b> 2846 * <p> 2847 * Description: <b>The clinician performing the assessment</b><br> 2848 * Type: <b>reference</b><br> 2849 * Path: <b>ClinicalImpression.assessor</b><br> 2850 * </p> 2851 */ 2852 @SearchParamDefinition(name = "assessor", path = "ClinicalImpression.assessor", description = "The clinician performing the assessment", type = "reference", providesMembershipIn = { 2853 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Practitioner") }, target = { Practitioner.class, 2854 PractitionerRole.class }) 2855 public static final String SP_ASSESSOR = "assessor"; 2856 /** 2857 * <b>Fluent Client</b> search parameter constant for <b>assessor</b> 2858 * <p> 2859 * Description: <b>The clinician performing the assessment</b><br> 2860 * Type: <b>reference</b><br> 2861 * Path: <b>ClinicalImpression.assessor</b><br> 2862 * </p> 2863 */ 2864 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ASSESSOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 2865 SP_ASSESSOR); 2866 2867 /** 2868 * Constant for fluent queries to be used to add include statements. Specifies 2869 * the path value of "<b>ClinicalImpression:assessor</b>". 2870 */ 2871 public static final ca.uhn.fhir.model.api.Include INCLUDE_ASSESSOR = new ca.uhn.fhir.model.api.Include( 2872 "ClinicalImpression:assessor").toLocked(); 2873 2874 /** 2875 * Search parameter: <b>subject</b> 2876 * <p> 2877 * Description: <b>Patient or group assessed</b><br> 2878 * Type: <b>reference</b><br> 2879 * Path: <b>ClinicalImpression.subject</b><br> 2880 * </p> 2881 */ 2882 @SearchParamDefinition(name = "subject", path = "ClinicalImpression.subject", description = "Patient or group assessed", type = "reference", providesMembershipIn = { 2883 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Patient") }, target = { Group.class, Patient.class }) 2884 public static final String SP_SUBJECT = "subject"; 2885 /** 2886 * <b>Fluent Client</b> search parameter constant for <b>subject</b> 2887 * <p> 2888 * Description: <b>Patient or group assessed</b><br> 2889 * Type: <b>reference</b><br> 2890 * Path: <b>ClinicalImpression.subject</b><br> 2891 * </p> 2892 */ 2893 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 2894 SP_SUBJECT); 2895 2896 /** 2897 * Constant for fluent queries to be used to add include statements. Specifies 2898 * the path value of "<b>ClinicalImpression:subject</b>". 2899 */ 2900 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT = new ca.uhn.fhir.model.api.Include( 2901 "ClinicalImpression:subject").toLocked(); 2902 2903 /** 2904 * Search parameter: <b>encounter</b> 2905 * <p> 2906 * Description: <b>Encounter created as part of</b><br> 2907 * Type: <b>reference</b><br> 2908 * Path: <b>ClinicalImpression.encounter</b><br> 2909 * </p> 2910 */ 2911 @SearchParamDefinition(name = "encounter", path = "ClinicalImpression.encounter", description = "Encounter created as part of", type = "reference", providesMembershipIn = { 2912 @ca.uhn.fhir.model.api.annotation.Compartment(name = "Encounter") }, target = { Encounter.class }) 2913 public static final String SP_ENCOUNTER = "encounter"; 2914 /** 2915 * <b>Fluent Client</b> search parameter constant for <b>encounter</b> 2916 * <p> 2917 * Description: <b>Encounter created as part of</b><br> 2918 * Type: <b>reference</b><br> 2919 * Path: <b>ClinicalImpression.encounter</b><br> 2920 * </p> 2921 */ 2922 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ENCOUNTER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 2923 SP_ENCOUNTER); 2924 2925 /** 2926 * Constant for fluent queries to be used to add include statements. Specifies 2927 * the path value of "<b>ClinicalImpression:encounter</b>". 2928 */ 2929 public static final ca.uhn.fhir.model.api.Include INCLUDE_ENCOUNTER = new ca.uhn.fhir.model.api.Include( 2930 "ClinicalImpression:encounter").toLocked(); 2931 2932 /** 2933 * Search parameter: <b>finding-ref</b> 2934 * <p> 2935 * Description: <b>What was found</b><br> 2936 * Type: <b>reference</b><br> 2937 * Path: <b>ClinicalImpression.finding.itemReference</b><br> 2938 * </p> 2939 */ 2940 @SearchParamDefinition(name = "finding-ref", path = "ClinicalImpression.finding.itemReference", description = "What was found", type = "reference", target = { 2941 Condition.class, Media.class, Observation.class }) 2942 public static final String SP_FINDING_REF = "finding-ref"; 2943 /** 2944 * <b>Fluent Client</b> search parameter constant for <b>finding-ref</b> 2945 * <p> 2946 * Description: <b>What was found</b><br> 2947 * Type: <b>reference</b><br> 2948 * Path: <b>ClinicalImpression.finding.itemReference</b><br> 2949 * </p> 2950 */ 2951 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam FINDING_REF = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 2952 SP_FINDING_REF); 2953 2954 /** 2955 * Constant for fluent queries to be used to add include statements. Specifies 2956 * the path value of "<b>ClinicalImpression:finding-ref</b>". 2957 */ 2958 public static final ca.uhn.fhir.model.api.Include INCLUDE_FINDING_REF = new ca.uhn.fhir.model.api.Include( 2959 "ClinicalImpression:finding-ref").toLocked(); 2960 2961 /** 2962 * Search parameter: <b>problem</b> 2963 * <p> 2964 * Description: <b>Relevant impressions of patient state</b><br> 2965 * Type: <b>reference</b><br> 2966 * Path: <b>ClinicalImpression.problem</b><br> 2967 * </p> 2968 */ 2969 @SearchParamDefinition(name = "problem", path = "ClinicalImpression.problem", description = "Relevant impressions of patient state", type = "reference", target = { 2970 AllergyIntolerance.class, Condition.class }) 2971 public static final String SP_PROBLEM = "problem"; 2972 /** 2973 * <b>Fluent Client</b> search parameter constant for <b>problem</b> 2974 * <p> 2975 * Description: <b>Relevant impressions of patient state</b><br> 2976 * Type: <b>reference</b><br> 2977 * Path: <b>ClinicalImpression.problem</b><br> 2978 * </p> 2979 */ 2980 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PROBLEM = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 2981 SP_PROBLEM); 2982 2983 /** 2984 * Constant for fluent queries to be used to add include statements. Specifies 2985 * the path value of "<b>ClinicalImpression:problem</b>". 2986 */ 2987 public static final ca.uhn.fhir.model.api.Include INCLUDE_PROBLEM = new ca.uhn.fhir.model.api.Include( 2988 "ClinicalImpression:problem").toLocked(); 2989 2990 /** 2991 * Search parameter: <b>patient</b> 2992 * <p> 2993 * Description: <b>Patient or group assessed</b><br> 2994 * Type: <b>reference</b><br> 2995 * Path: <b>ClinicalImpression.subject</b><br> 2996 * </p> 2997 */ 2998 @SearchParamDefinition(name = "patient", path = "ClinicalImpression.subject.where(resolve() is Patient)", description = "Patient or group assessed", type = "reference", target = { 2999 Patient.class }) 3000 public static final String SP_PATIENT = "patient"; 3001 /** 3002 * <b>Fluent Client</b> search parameter constant for <b>patient</b> 3003 * <p> 3004 * Description: <b>Patient or group assessed</b><br> 3005 * Type: <b>reference</b><br> 3006 * Path: <b>ClinicalImpression.subject</b><br> 3007 * </p> 3008 */ 3009 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 3010 SP_PATIENT); 3011 3012 /** 3013 * Constant for fluent queries to be used to add include statements. Specifies 3014 * the path value of "<b>ClinicalImpression:patient</b>". 3015 */ 3016 public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include( 3017 "ClinicalImpression:patient").toLocked(); 3018 3019 /** 3020 * Search parameter: <b>supporting-info</b> 3021 * <p> 3022 * Description: <b>Information supporting the clinical impression</b><br> 3023 * Type: <b>reference</b><br> 3024 * Path: <b>ClinicalImpression.supportingInfo</b><br> 3025 * </p> 3026 */ 3027 @SearchParamDefinition(name = "supporting-info", path = "ClinicalImpression.supportingInfo", description = "Information supporting the clinical impression", type = "reference") 3028 public static final String SP_SUPPORTING_INFO = "supporting-info"; 3029 /** 3030 * <b>Fluent Client</b> search parameter constant for <b>supporting-info</b> 3031 * <p> 3032 * Description: <b>Information supporting the clinical impression</b><br> 3033 * Type: <b>reference</b><br> 3034 * Path: <b>ClinicalImpression.supportingInfo</b><br> 3035 * </p> 3036 */ 3037 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUPPORTING_INFO = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 3038 SP_SUPPORTING_INFO); 3039 3040 /** 3041 * Constant for fluent queries to be used to add include statements. Specifies 3042 * the path value of "<b>ClinicalImpression:supporting-info</b>". 3043 */ 3044 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUPPORTING_INFO = new ca.uhn.fhir.model.api.Include( 3045 "ClinicalImpression:supporting-info").toLocked(); 3046 3047 /** 3048 * Search parameter: <b>investigation</b> 3049 * <p> 3050 * Description: <b>Record of a specific investigation</b><br> 3051 * Type: <b>reference</b><br> 3052 * Path: <b>ClinicalImpression.investigation.item</b><br> 3053 * </p> 3054 */ 3055 @SearchParamDefinition(name = "investigation", path = "ClinicalImpression.investigation.item", description = "Record of a specific investigation", type = "reference", target = { 3056 DiagnosticReport.class, FamilyMemberHistory.class, ImagingStudy.class, Media.class, Observation.class, 3057 QuestionnaireResponse.class, RiskAssessment.class }) 3058 public static final String SP_INVESTIGATION = "investigation"; 3059 /** 3060 * <b>Fluent Client</b> search parameter constant for <b>investigation</b> 3061 * <p> 3062 * Description: <b>Record of a specific investigation</b><br> 3063 * Type: <b>reference</b><br> 3064 * Path: <b>ClinicalImpression.investigation.item</b><br> 3065 * </p> 3066 */ 3067 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam INVESTIGATION = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 3068 SP_INVESTIGATION); 3069 3070 /** 3071 * Constant for fluent queries to be used to add include statements. Specifies 3072 * the path value of "<b>ClinicalImpression:investigation</b>". 3073 */ 3074 public static final ca.uhn.fhir.model.api.Include INCLUDE_INVESTIGATION = new ca.uhn.fhir.model.api.Include( 3075 "ClinicalImpression:investigation").toLocked(); 3076 3077 /** 3078 * Search parameter: <b>status</b> 3079 * <p> 3080 * Description: <b>in-progress | completed | entered-in-error</b><br> 3081 * Type: <b>token</b><br> 3082 * Path: <b>ClinicalImpression.status</b><br> 3083 * </p> 3084 */ 3085 @SearchParamDefinition(name = "status", path = "ClinicalImpression.status", description = "in-progress | completed | entered-in-error", type = "token") 3086 public static final String SP_STATUS = "status"; 3087 /** 3088 * <b>Fluent Client</b> search parameter constant for <b>status</b> 3089 * <p> 3090 * Description: <b>in-progress | completed | entered-in-error</b><br> 3091 * Type: <b>token</b><br> 3092 * Path: <b>ClinicalImpression.status</b><br> 3093 * </p> 3094 */ 3095 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam( 3096 SP_STATUS); 3097 3098}