001package org.hl7.fhir.r4.model; 002 003/* 004 Copyright (c) 2011+, HL7, Inc. 005 All rights reserved. 006 007 Redistribution and use in source and binary forms, with or without modification, 008 are permitted provided that the following conditions are met: 009 010 * Redistributions of source code must retain the above copyright notice, this 011 list of conditions and the following disclaimer. 012 * Redistributions in binary form must reproduce the above copyright notice, 013 this list of conditions and the following disclaimer in the documentation 014 and/or other materials provided with the distribution. 015 * Neither the name of HL7 nor the names of its contributors may be used to 016 endorse or promote products derived from this software without specific 017 prior written permission. 018 019 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 020 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 021 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 022 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 023 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 024 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 025 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 026 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 027 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 028 POSSIBILITY OF SUCH DAMAGE. 029 030*/ 031 032// Generated on Tue, May 12, 2020 07:26+1000 for FHIR v4.0.1 033import java.util.ArrayList; 034import java.util.Date; 035import java.util.List; 036 037import org.hl7.fhir.exceptions.FHIRException; 038import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 039import org.hl7.fhir.r4.model.Enumerations.PublicationStatus; 040import org.hl7.fhir.r4.model.Enumerations.PublicationStatusEnumFactory; 041import org.hl7.fhir.utilities.Utilities; 042 043import ca.uhn.fhir.model.api.annotation.Block; 044import ca.uhn.fhir.model.api.annotation.Child; 045import ca.uhn.fhir.model.api.annotation.ChildOrder; 046import ca.uhn.fhir.model.api.annotation.Description; 047import ca.uhn.fhir.model.api.annotation.ResourceDef; 048import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 049 050/** 051 * The EvidenceVariable resource describes a "PICO" element that knowledge 052 * (evidence, assertion, recommendation) is about. 053 */ 054@ResourceDef(name = "EvidenceVariable", profile = "http://hl7.org/fhir/StructureDefinition/EvidenceVariable") 055@ChildOrder(names = { "url", "identifier", "version", "name", "title", "shortTitle", "subtitle", "status", "date", 056 "publisher", "contact", "description", "note", "useContext", "jurisdiction", "copyright", "approvalDate", 057 "lastReviewDate", "effectivePeriod", "topic", "author", "editor", "reviewer", "endorser", "relatedArtifact", "type", 058 "characteristic" }) 059public class EvidenceVariable extends MetadataResource { 060 061 public enum EvidenceVariableType { 062 /** 063 * The variable is dichotomous, such as present or absent. 064 */ 065 DICHOTOMOUS, 066 /** 067 * The variable is a continuous result such as a quantity. 068 */ 069 CONTINUOUS, 070 /** 071 * The variable is described narratively rather than quantitatively. 072 */ 073 DESCRIPTIVE, 074 /** 075 * added to help the parsers with the generic types 076 */ 077 NULL; 078 079 public static EvidenceVariableType fromCode(String codeString) throws FHIRException { 080 if (codeString == null || "".equals(codeString)) 081 return null; 082 if ("dichotomous".equals(codeString)) 083 return DICHOTOMOUS; 084 if ("continuous".equals(codeString)) 085 return CONTINUOUS; 086 if ("descriptive".equals(codeString)) 087 return DESCRIPTIVE; 088 if (Configuration.isAcceptInvalidEnums()) 089 return null; 090 else 091 throw new FHIRException("Unknown EvidenceVariableType code '" + codeString + "'"); 092 } 093 094 public String toCode() { 095 switch (this) { 096 case DICHOTOMOUS: 097 return "dichotomous"; 098 case CONTINUOUS: 099 return "continuous"; 100 case DESCRIPTIVE: 101 return "descriptive"; 102 case NULL: 103 return null; 104 default: 105 return "?"; 106 } 107 } 108 109 public String getSystem() { 110 switch (this) { 111 case DICHOTOMOUS: 112 return "http://hl7.org/fhir/variable-type"; 113 case CONTINUOUS: 114 return "http://hl7.org/fhir/variable-type"; 115 case DESCRIPTIVE: 116 return "http://hl7.org/fhir/variable-type"; 117 case NULL: 118 return null; 119 default: 120 return "?"; 121 } 122 } 123 124 public String getDefinition() { 125 switch (this) { 126 case DICHOTOMOUS: 127 return "The variable is dichotomous, such as present or absent."; 128 case CONTINUOUS: 129 return "The variable is a continuous result such as a quantity."; 130 case DESCRIPTIVE: 131 return "The variable is described narratively rather than quantitatively."; 132 case NULL: 133 return null; 134 default: 135 return "?"; 136 } 137 } 138 139 public String getDisplay() { 140 switch (this) { 141 case DICHOTOMOUS: 142 return "Dichotomous"; 143 case CONTINUOUS: 144 return "Continuous"; 145 case DESCRIPTIVE: 146 return "Descriptive"; 147 case NULL: 148 return null; 149 default: 150 return "?"; 151 } 152 } 153 } 154 155 public static class EvidenceVariableTypeEnumFactory implements EnumFactory<EvidenceVariableType> { 156 public EvidenceVariableType fromCode(String codeString) throws IllegalArgumentException { 157 if (codeString == null || "".equals(codeString)) 158 if (codeString == null || "".equals(codeString)) 159 return null; 160 if ("dichotomous".equals(codeString)) 161 return EvidenceVariableType.DICHOTOMOUS; 162 if ("continuous".equals(codeString)) 163 return EvidenceVariableType.CONTINUOUS; 164 if ("descriptive".equals(codeString)) 165 return EvidenceVariableType.DESCRIPTIVE; 166 throw new IllegalArgumentException("Unknown EvidenceVariableType code '" + codeString + "'"); 167 } 168 169 public Enumeration<EvidenceVariableType> fromType(PrimitiveType<?> code) throws FHIRException { 170 if (code == null) 171 return null; 172 if (code.isEmpty()) 173 return new Enumeration<EvidenceVariableType>(this, EvidenceVariableType.NULL, code); 174 String codeString = code.asStringValue(); 175 if (codeString == null || "".equals(codeString)) 176 return new Enumeration<EvidenceVariableType>(this, EvidenceVariableType.NULL, code); 177 if ("dichotomous".equals(codeString)) 178 return new Enumeration<EvidenceVariableType>(this, EvidenceVariableType.DICHOTOMOUS, code); 179 if ("continuous".equals(codeString)) 180 return new Enumeration<EvidenceVariableType>(this, EvidenceVariableType.CONTINUOUS, code); 181 if ("descriptive".equals(codeString)) 182 return new Enumeration<EvidenceVariableType>(this, EvidenceVariableType.DESCRIPTIVE, code); 183 throw new FHIRException("Unknown EvidenceVariableType code '" + codeString + "'"); 184 } 185 186 public String toCode(EvidenceVariableType code) { 187 if (code == EvidenceVariableType.DICHOTOMOUS) 188 return "dichotomous"; 189 if (code == EvidenceVariableType.CONTINUOUS) 190 return "continuous"; 191 if (code == EvidenceVariableType.DESCRIPTIVE) 192 return "descriptive"; 193 return "?"; 194 } 195 196 public String toSystem(EvidenceVariableType code) { 197 return code.getSystem(); 198 } 199 } 200 201 public enum GroupMeasure { 202 /** 203 * Aggregated using Mean of participant values. 204 */ 205 MEAN, 206 /** 207 * Aggregated using Median of participant values. 208 */ 209 MEDIAN, 210 /** 211 * Aggregated using Mean of study mean values. 212 */ 213 MEANOFMEAN, 214 /** 215 * Aggregated using Mean of study median values. 216 */ 217 MEANOFMEDIAN, 218 /** 219 * Aggregated using Median of study mean values. 220 */ 221 MEDIANOFMEAN, 222 /** 223 * Aggregated using Median of study median values. 224 */ 225 MEDIANOFMEDIAN, 226 /** 227 * added to help the parsers with the generic types 228 */ 229 NULL; 230 231 public static GroupMeasure fromCode(String codeString) throws FHIRException { 232 if (codeString == null || "".equals(codeString)) 233 return null; 234 if ("mean".equals(codeString)) 235 return MEAN; 236 if ("median".equals(codeString)) 237 return MEDIAN; 238 if ("mean-of-mean".equals(codeString)) 239 return MEANOFMEAN; 240 if ("mean-of-median".equals(codeString)) 241 return MEANOFMEDIAN; 242 if ("median-of-mean".equals(codeString)) 243 return MEDIANOFMEAN; 244 if ("median-of-median".equals(codeString)) 245 return MEDIANOFMEDIAN; 246 if (Configuration.isAcceptInvalidEnums()) 247 return null; 248 else 249 throw new FHIRException("Unknown GroupMeasure code '" + codeString + "'"); 250 } 251 252 public String toCode() { 253 switch (this) { 254 case MEAN: 255 return "mean"; 256 case MEDIAN: 257 return "median"; 258 case MEANOFMEAN: 259 return "mean-of-mean"; 260 case MEANOFMEDIAN: 261 return "mean-of-median"; 262 case MEDIANOFMEAN: 263 return "median-of-mean"; 264 case MEDIANOFMEDIAN: 265 return "median-of-median"; 266 case NULL: 267 return null; 268 default: 269 return "?"; 270 } 271 } 272 273 public String getSystem() { 274 switch (this) { 275 case MEAN: 276 return "http://hl7.org/fhir/group-measure"; 277 case MEDIAN: 278 return "http://hl7.org/fhir/group-measure"; 279 case MEANOFMEAN: 280 return "http://hl7.org/fhir/group-measure"; 281 case MEANOFMEDIAN: 282 return "http://hl7.org/fhir/group-measure"; 283 case MEDIANOFMEAN: 284 return "http://hl7.org/fhir/group-measure"; 285 case MEDIANOFMEDIAN: 286 return "http://hl7.org/fhir/group-measure"; 287 case NULL: 288 return null; 289 default: 290 return "?"; 291 } 292 } 293 294 public String getDefinition() { 295 switch (this) { 296 case MEAN: 297 return "Aggregated using Mean of participant values."; 298 case MEDIAN: 299 return "Aggregated using Median of participant values."; 300 case MEANOFMEAN: 301 return "Aggregated using Mean of study mean values."; 302 case MEANOFMEDIAN: 303 return "Aggregated using Mean of study median values."; 304 case MEDIANOFMEAN: 305 return "Aggregated using Median of study mean values."; 306 case MEDIANOFMEDIAN: 307 return "Aggregated using Median of study median values."; 308 case NULL: 309 return null; 310 default: 311 return "?"; 312 } 313 } 314 315 public String getDisplay() { 316 switch (this) { 317 case MEAN: 318 return "Mean"; 319 case MEDIAN: 320 return "Median"; 321 case MEANOFMEAN: 322 return "Mean of Study Means"; 323 case MEANOFMEDIAN: 324 return "Mean of Study Medins"; 325 case MEDIANOFMEAN: 326 return "Median of Study Means"; 327 case MEDIANOFMEDIAN: 328 return "Median of Study Medians"; 329 case NULL: 330 return null; 331 default: 332 return "?"; 333 } 334 } 335 } 336 337 public static class GroupMeasureEnumFactory implements EnumFactory<GroupMeasure> { 338 public GroupMeasure fromCode(String codeString) throws IllegalArgumentException { 339 if (codeString == null || "".equals(codeString)) 340 if (codeString == null || "".equals(codeString)) 341 return null; 342 if ("mean".equals(codeString)) 343 return GroupMeasure.MEAN; 344 if ("median".equals(codeString)) 345 return GroupMeasure.MEDIAN; 346 if ("mean-of-mean".equals(codeString)) 347 return GroupMeasure.MEANOFMEAN; 348 if ("mean-of-median".equals(codeString)) 349 return GroupMeasure.MEANOFMEDIAN; 350 if ("median-of-mean".equals(codeString)) 351 return GroupMeasure.MEDIANOFMEAN; 352 if ("median-of-median".equals(codeString)) 353 return GroupMeasure.MEDIANOFMEDIAN; 354 throw new IllegalArgumentException("Unknown GroupMeasure code '" + codeString + "'"); 355 } 356 357 public Enumeration<GroupMeasure> fromType(PrimitiveType<?> code) throws FHIRException { 358 if (code == null) 359 return null; 360 if (code.isEmpty()) 361 return new Enumeration<GroupMeasure>(this, GroupMeasure.NULL, code); 362 String codeString = code.asStringValue(); 363 if (codeString == null || "".equals(codeString)) 364 return new Enumeration<GroupMeasure>(this, GroupMeasure.NULL, code); 365 if ("mean".equals(codeString)) 366 return new Enumeration<GroupMeasure>(this, GroupMeasure.MEAN, code); 367 if ("median".equals(codeString)) 368 return new Enumeration<GroupMeasure>(this, GroupMeasure.MEDIAN, code); 369 if ("mean-of-mean".equals(codeString)) 370 return new Enumeration<GroupMeasure>(this, GroupMeasure.MEANOFMEAN, code); 371 if ("mean-of-median".equals(codeString)) 372 return new Enumeration<GroupMeasure>(this, GroupMeasure.MEANOFMEDIAN, code); 373 if ("median-of-mean".equals(codeString)) 374 return new Enumeration<GroupMeasure>(this, GroupMeasure.MEDIANOFMEAN, code); 375 if ("median-of-median".equals(codeString)) 376 return new Enumeration<GroupMeasure>(this, GroupMeasure.MEDIANOFMEDIAN, code); 377 throw new FHIRException("Unknown GroupMeasure code '" + codeString + "'"); 378 } 379 380 public String toCode(GroupMeasure code) { 381 if (code == GroupMeasure.MEAN) 382 return "mean"; 383 if (code == GroupMeasure.MEDIAN) 384 return "median"; 385 if (code == GroupMeasure.MEANOFMEAN) 386 return "mean-of-mean"; 387 if (code == GroupMeasure.MEANOFMEDIAN) 388 return "mean-of-median"; 389 if (code == GroupMeasure.MEDIANOFMEAN) 390 return "median-of-mean"; 391 if (code == GroupMeasure.MEDIANOFMEDIAN) 392 return "median-of-median"; 393 return "?"; 394 } 395 396 public String toSystem(GroupMeasure code) { 397 return code.getSystem(); 398 } 399 } 400 401 @Block() 402 public static class EvidenceVariableCharacteristicComponent extends BackboneElement implements IBaseBackboneElement { 403 /** 404 * A short, natural language description of the characteristic that could be 405 * used to communicate the criteria to an end-user. 406 */ 407 @Child(name = "description", type = { 408 StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false) 409 @Description(shortDefinition = "Natural language description of the characteristic", formalDefinition = "A short, natural language description of the characteristic that could be used to communicate the criteria to an end-user.") 410 protected StringType description; 411 412 /** 413 * Define members of the evidence element using Codes (such as condition, 414 * medication, or observation), Expressions ( using an expression language such 415 * as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in 416 * the last year). 417 */ 418 @Child(name = "definition", type = { Group.class, CanonicalType.class, CodeableConcept.class, Expression.class, 419 DataRequirement.class, TriggerDefinition.class }, order = 2, min = 1, max = 1, modifier = false, summary = true) 420 @Description(shortDefinition = "What code or expression defines members?", formalDefinition = "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).") 421 protected Type definition; 422 423 /** 424 * Use UsageContext to define the members of the population, such as Age Ranges, 425 * Genders, Settings. 426 */ 427 @Child(name = "usageContext", type = { 428 UsageContext.class }, order = 3, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 429 @Description(shortDefinition = "What code/value pairs define members?", formalDefinition = "Use UsageContext to define the members of the population, such as Age Ranges, Genders, Settings.") 430 protected List<UsageContext> usageContext; 431 432 /** 433 * When true, members with this characteristic are excluded from the element. 434 */ 435 @Child(name = "exclude", type = { 436 BooleanType.class }, order = 4, min = 0, max = 1, modifier = false, summary = false) 437 @Description(shortDefinition = "Whether the characteristic includes or excludes members", formalDefinition = "When true, members with this characteristic are excluded from the element.") 438 protected BooleanType exclude; 439 440 /** 441 * Indicates what effective period the study covers. 442 */ 443 @Child(name = "participantEffective", type = { DateTimeType.class, Period.class, Duration.class, 444 Timing.class }, order = 5, min = 0, max = 1, modifier = false, summary = false) 445 @Description(shortDefinition = "What time period do participants cover", formalDefinition = "Indicates what effective period the study covers.") 446 protected Type participantEffective; 447 448 /** 449 * Indicates duration from the participant's study entry. 450 */ 451 @Child(name = "timeFromStart", type = { 452 Duration.class }, order = 6, min = 0, max = 1, modifier = false, summary = false) 453 @Description(shortDefinition = "Observation time from study start", formalDefinition = "Indicates duration from the participant's study entry.") 454 protected Duration timeFromStart; 455 456 /** 457 * Indicates how elements are aggregated within the study effective period. 458 */ 459 @Child(name = "groupMeasure", type = { 460 CodeType.class }, order = 7, min = 0, max = 1, modifier = false, summary = false) 461 @Description(shortDefinition = "mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median", formalDefinition = "Indicates how elements are aggregated within the study effective period.") 462 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/group-measure") 463 protected Enumeration<GroupMeasure> groupMeasure; 464 465 private static final long serialVersionUID = 1901961318L; 466 467 /** 468 * Constructor 469 */ 470 public EvidenceVariableCharacteristicComponent() { 471 super(); 472 } 473 474 /** 475 * Constructor 476 */ 477 public EvidenceVariableCharacteristicComponent(Type definition) { 478 super(); 479 this.definition = definition; 480 } 481 482 /** 483 * @return {@link #description} (A short, natural language description of the 484 * characteristic that could be used to communicate the criteria to an 485 * end-user.). This is the underlying object with id, value and 486 * extensions. The accessor "getDescription" gives direct access to the 487 * value 488 */ 489 public StringType getDescriptionElement() { 490 if (this.description == null) 491 if (Configuration.errorOnAutoCreate()) 492 throw new Error("Attempt to auto-create EvidenceVariableCharacteristicComponent.description"); 493 else if (Configuration.doAutoCreate()) 494 this.description = new StringType(); // bb 495 return this.description; 496 } 497 498 public boolean hasDescriptionElement() { 499 return this.description != null && !this.description.isEmpty(); 500 } 501 502 public boolean hasDescription() { 503 return this.description != null && !this.description.isEmpty(); 504 } 505 506 /** 507 * @param value {@link #description} (A short, natural language description of 508 * the characteristic that could be used to communicate the 509 * criteria to an end-user.). This is the underlying object with 510 * id, value and extensions. The accessor "getDescription" gives 511 * direct access to the value 512 */ 513 public EvidenceVariableCharacteristicComponent setDescriptionElement(StringType value) { 514 this.description = value; 515 return this; 516 } 517 518 /** 519 * @return A short, natural language description of the characteristic that 520 * could be used to communicate the criteria to an end-user. 521 */ 522 public String getDescription() { 523 return this.description == null ? null : this.description.getValue(); 524 } 525 526 /** 527 * @param value A short, natural language description of the characteristic that 528 * could be used to communicate the criteria to an end-user. 529 */ 530 public EvidenceVariableCharacteristicComponent setDescription(String value) { 531 if (Utilities.noString(value)) 532 this.description = null; 533 else { 534 if (this.description == null) 535 this.description = new StringType(); 536 this.description.setValue(value); 537 } 538 return this; 539 } 540 541 /** 542 * @return {@link #definition} (Define members of the evidence element using 543 * Codes (such as condition, medication, or observation), Expressions ( 544 * using an expression language such as FHIRPath or CQL) or 545 * DataRequirements (such as Diabetes diagnosis onset in the last 546 * year).) 547 */ 548 public Type getDefinition() { 549 return this.definition; 550 } 551 552 /** 553 * @return {@link #definition} (Define members of the evidence element using 554 * Codes (such as condition, medication, or observation), Expressions ( 555 * using an expression language such as FHIRPath or CQL) or 556 * DataRequirements (such as Diabetes diagnosis onset in the last 557 * year).) 558 */ 559 public Reference getDefinitionReference() throws FHIRException { 560 if (this.definition == null) 561 this.definition = new Reference(); 562 if (!(this.definition instanceof Reference)) 563 throw new FHIRException("Type mismatch: the type Reference was expected, but " 564 + this.definition.getClass().getName() + " was encountered"); 565 return (Reference) this.definition; 566 } 567 568 public boolean hasDefinitionReference() { 569 return this != null && this.definition instanceof Reference; 570 } 571 572 /** 573 * @return {@link #definition} (Define members of the evidence element using 574 * Codes (such as condition, medication, or observation), Expressions ( 575 * using an expression language such as FHIRPath or CQL) or 576 * DataRequirements (such as Diabetes diagnosis onset in the last 577 * year).) 578 */ 579 public CanonicalType getDefinitionCanonicalType() throws FHIRException { 580 if (this.definition == null) 581 this.definition = new CanonicalType(); 582 if (!(this.definition instanceof CanonicalType)) 583 throw new FHIRException("Type mismatch: the type CanonicalType was expected, but " 584 + this.definition.getClass().getName() + " was encountered"); 585 return (CanonicalType) this.definition; 586 } 587 588 public boolean hasDefinitionCanonicalType() { 589 return this != null && this.definition instanceof CanonicalType; 590 } 591 592 /** 593 * @return {@link #definition} (Define members of the evidence element using 594 * Codes (such as condition, medication, or observation), Expressions ( 595 * using an expression language such as FHIRPath or CQL) or 596 * DataRequirements (such as Diabetes diagnosis onset in the last 597 * year).) 598 */ 599 public CodeableConcept getDefinitionCodeableConcept() throws FHIRException { 600 if (this.definition == null) 601 this.definition = new CodeableConcept(); 602 if (!(this.definition instanceof CodeableConcept)) 603 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but " 604 + this.definition.getClass().getName() + " was encountered"); 605 return (CodeableConcept) this.definition; 606 } 607 608 public boolean hasDefinitionCodeableConcept() { 609 return this != null && this.definition instanceof CodeableConcept; 610 } 611 612 /** 613 * @return {@link #definition} (Define members of the evidence element using 614 * Codes (such as condition, medication, or observation), Expressions ( 615 * using an expression language such as FHIRPath or CQL) or 616 * DataRequirements (such as Diabetes diagnosis onset in the last 617 * year).) 618 */ 619 public Expression getDefinitionExpression() throws FHIRException { 620 if (this.definition == null) 621 this.definition = new Expression(); 622 if (!(this.definition instanceof Expression)) 623 throw new FHIRException("Type mismatch: the type Expression was expected, but " 624 + this.definition.getClass().getName() + " was encountered"); 625 return (Expression) this.definition; 626 } 627 628 public boolean hasDefinitionExpression() { 629 return this != null && this.definition instanceof Expression; 630 } 631 632 /** 633 * @return {@link #definition} (Define members of the evidence element using 634 * Codes (such as condition, medication, or observation), Expressions ( 635 * using an expression language such as FHIRPath or CQL) or 636 * DataRequirements (such as Diabetes diagnosis onset in the last 637 * year).) 638 */ 639 public DataRequirement getDefinitionDataRequirement() throws FHIRException { 640 if (this.definition == null) 641 this.definition = new DataRequirement(); 642 if (!(this.definition instanceof DataRequirement)) 643 throw new FHIRException("Type mismatch: the type DataRequirement was expected, but " 644 + this.definition.getClass().getName() + " was encountered"); 645 return (DataRequirement) this.definition; 646 } 647 648 public boolean hasDefinitionDataRequirement() { 649 return this != null && this.definition instanceof DataRequirement; 650 } 651 652 /** 653 * @return {@link #definition} (Define members of the evidence element using 654 * Codes (such as condition, medication, or observation), Expressions ( 655 * using an expression language such as FHIRPath or CQL) or 656 * DataRequirements (such as Diabetes diagnosis onset in the last 657 * year).) 658 */ 659 public TriggerDefinition getDefinitionTriggerDefinition() throws FHIRException { 660 if (this.definition == null) 661 this.definition = new TriggerDefinition(); 662 if (!(this.definition instanceof TriggerDefinition)) 663 throw new FHIRException("Type mismatch: the type TriggerDefinition was expected, but " 664 + this.definition.getClass().getName() + " was encountered"); 665 return (TriggerDefinition) this.definition; 666 } 667 668 public boolean hasDefinitionTriggerDefinition() { 669 return this != null && this.definition instanceof TriggerDefinition; 670 } 671 672 public boolean hasDefinition() { 673 return this.definition != null && !this.definition.isEmpty(); 674 } 675 676 /** 677 * @param value {@link #definition} (Define members of the evidence element 678 * using Codes (such as condition, medication, or observation), 679 * Expressions ( using an expression language such as FHIRPath or 680 * CQL) or DataRequirements (such as Diabetes diagnosis onset in 681 * the last year).) 682 */ 683 public EvidenceVariableCharacteristicComponent setDefinition(Type value) { 684 if (value != null 685 && !(value instanceof Reference || value instanceof CanonicalType || value instanceof CodeableConcept 686 || value instanceof Expression || value instanceof DataRequirement || value instanceof TriggerDefinition)) 687 throw new Error("Not the right type for EvidenceVariable.characteristic.definition[x]: " + value.fhirType()); 688 this.definition = value; 689 return this; 690 } 691 692 /** 693 * @return {@link #usageContext} (Use UsageContext to define the members of the 694 * population, such as Age Ranges, Genders, Settings.) 695 */ 696 public List<UsageContext> getUsageContext() { 697 if (this.usageContext == null) 698 this.usageContext = new ArrayList<UsageContext>(); 699 return this.usageContext; 700 } 701 702 /** 703 * @return Returns a reference to <code>this</code> for easy method chaining 704 */ 705 public EvidenceVariableCharacteristicComponent setUsageContext(List<UsageContext> theUsageContext) { 706 this.usageContext = theUsageContext; 707 return this; 708 } 709 710 public boolean hasUsageContext() { 711 if (this.usageContext == null) 712 return false; 713 for (UsageContext item : this.usageContext) 714 if (!item.isEmpty()) 715 return true; 716 return false; 717 } 718 719 public UsageContext addUsageContext() { // 3 720 UsageContext t = new UsageContext(); 721 if (this.usageContext == null) 722 this.usageContext = new ArrayList<UsageContext>(); 723 this.usageContext.add(t); 724 return t; 725 } 726 727 public EvidenceVariableCharacteristicComponent addUsageContext(UsageContext t) { // 3 728 if (t == null) 729 return this; 730 if (this.usageContext == null) 731 this.usageContext = new ArrayList<UsageContext>(); 732 this.usageContext.add(t); 733 return this; 734 } 735 736 /** 737 * @return The first repetition of repeating field {@link #usageContext}, 738 * creating it if it does not already exist 739 */ 740 public UsageContext getUsageContextFirstRep() { 741 if (getUsageContext().isEmpty()) { 742 addUsageContext(); 743 } 744 return getUsageContext().get(0); 745 } 746 747 /** 748 * @return {@link #exclude} (When true, members with this characteristic are 749 * excluded from the element.). This is the underlying object with id, 750 * value and extensions. The accessor "getExclude" gives direct access 751 * to the value 752 */ 753 public BooleanType getExcludeElement() { 754 if (this.exclude == null) 755 if (Configuration.errorOnAutoCreate()) 756 throw new Error("Attempt to auto-create EvidenceVariableCharacteristicComponent.exclude"); 757 else if (Configuration.doAutoCreate()) 758 this.exclude = new BooleanType(); // bb 759 return this.exclude; 760 } 761 762 public boolean hasExcludeElement() { 763 return this.exclude != null && !this.exclude.isEmpty(); 764 } 765 766 public boolean hasExclude() { 767 return this.exclude != null && !this.exclude.isEmpty(); 768 } 769 770 /** 771 * @param value {@link #exclude} (When true, members with this characteristic 772 * are excluded from the element.). This is the underlying object 773 * with id, value and extensions. The accessor "getExclude" gives 774 * direct access to the value 775 */ 776 public EvidenceVariableCharacteristicComponent setExcludeElement(BooleanType value) { 777 this.exclude = value; 778 return this; 779 } 780 781 /** 782 * @return When true, members with this characteristic are excluded from the 783 * element. 784 */ 785 public boolean getExclude() { 786 return this.exclude == null || this.exclude.isEmpty() ? false : this.exclude.getValue(); 787 } 788 789 /** 790 * @param value When true, members with this characteristic are excluded from 791 * the element. 792 */ 793 public EvidenceVariableCharacteristicComponent setExclude(boolean value) { 794 if (this.exclude == null) 795 this.exclude = new BooleanType(); 796 this.exclude.setValue(value); 797 return this; 798 } 799 800 /** 801 * @return {@link #participantEffective} (Indicates what effective period the 802 * study covers.) 803 */ 804 public Type getParticipantEffective() { 805 return this.participantEffective; 806 } 807 808 /** 809 * @return {@link #participantEffective} (Indicates what effective period the 810 * study covers.) 811 */ 812 public DateTimeType getParticipantEffectiveDateTimeType() throws FHIRException { 813 if (this.participantEffective == null) 814 this.participantEffective = new DateTimeType(); 815 if (!(this.participantEffective instanceof DateTimeType)) 816 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but " 817 + this.participantEffective.getClass().getName() + " was encountered"); 818 return (DateTimeType) this.participantEffective; 819 } 820 821 public boolean hasParticipantEffectiveDateTimeType() { 822 return this != null && this.participantEffective instanceof DateTimeType; 823 } 824 825 /** 826 * @return {@link #participantEffective} (Indicates what effective period the 827 * study covers.) 828 */ 829 public Period getParticipantEffectivePeriod() throws FHIRException { 830 if (this.participantEffective == null) 831 this.participantEffective = new Period(); 832 if (!(this.participantEffective instanceof Period)) 833 throw new FHIRException("Type mismatch: the type Period was expected, but " 834 + this.participantEffective.getClass().getName() + " was encountered"); 835 return (Period) this.participantEffective; 836 } 837 838 public boolean hasParticipantEffectivePeriod() { 839 return this != null && this.participantEffective instanceof Period; 840 } 841 842 /** 843 * @return {@link #participantEffective} (Indicates what effective period the 844 * study covers.) 845 */ 846 public Duration getParticipantEffectiveDuration() throws FHIRException { 847 if (this.participantEffective == null) 848 this.participantEffective = new Duration(); 849 if (!(this.participantEffective instanceof Duration)) 850 throw new FHIRException("Type mismatch: the type Duration was expected, but " 851 + this.participantEffective.getClass().getName() + " was encountered"); 852 return (Duration) this.participantEffective; 853 } 854 855 public boolean hasParticipantEffectiveDuration() { 856 return this != null && this.participantEffective instanceof Duration; 857 } 858 859 /** 860 * @return {@link #participantEffective} (Indicates what effective period the 861 * study covers.) 862 */ 863 public Timing getParticipantEffectiveTiming() throws FHIRException { 864 if (this.participantEffective == null) 865 this.participantEffective = new Timing(); 866 if (!(this.participantEffective instanceof Timing)) 867 throw new FHIRException("Type mismatch: the type Timing was expected, but " 868 + this.participantEffective.getClass().getName() + " was encountered"); 869 return (Timing) this.participantEffective; 870 } 871 872 public boolean hasParticipantEffectiveTiming() { 873 return this != null && this.participantEffective instanceof Timing; 874 } 875 876 public boolean hasParticipantEffective() { 877 return this.participantEffective != null && !this.participantEffective.isEmpty(); 878 } 879 880 /** 881 * @param value {@link #participantEffective} (Indicates what effective period 882 * the study covers.) 883 */ 884 public EvidenceVariableCharacteristicComponent setParticipantEffective(Type value) { 885 if (value != null && !(value instanceof DateTimeType || value instanceof Period || value instanceof Duration 886 || value instanceof Timing)) 887 throw new Error( 888 "Not the right type for EvidenceVariable.characteristic.participantEffective[x]: " + value.fhirType()); 889 this.participantEffective = value; 890 return this; 891 } 892 893 /** 894 * @return {@link #timeFromStart} (Indicates duration from the participant's 895 * study entry.) 896 */ 897 public Duration getTimeFromStart() { 898 if (this.timeFromStart == null) 899 if (Configuration.errorOnAutoCreate()) 900 throw new Error("Attempt to auto-create EvidenceVariableCharacteristicComponent.timeFromStart"); 901 else if (Configuration.doAutoCreate()) 902 this.timeFromStart = new Duration(); // cc 903 return this.timeFromStart; 904 } 905 906 public boolean hasTimeFromStart() { 907 return this.timeFromStart != null && !this.timeFromStart.isEmpty(); 908 } 909 910 /** 911 * @param value {@link #timeFromStart} (Indicates duration from the 912 * participant's study entry.) 913 */ 914 public EvidenceVariableCharacteristicComponent setTimeFromStart(Duration value) { 915 this.timeFromStart = value; 916 return this; 917 } 918 919 /** 920 * @return {@link #groupMeasure} (Indicates how elements are aggregated within 921 * the study effective period.). This is the underlying object with id, 922 * value and extensions. The accessor "getGroupMeasure" gives direct 923 * access to the value 924 */ 925 public Enumeration<GroupMeasure> getGroupMeasureElement() { 926 if (this.groupMeasure == null) 927 if (Configuration.errorOnAutoCreate()) 928 throw new Error("Attempt to auto-create EvidenceVariableCharacteristicComponent.groupMeasure"); 929 else if (Configuration.doAutoCreate()) 930 this.groupMeasure = new Enumeration<GroupMeasure>(new GroupMeasureEnumFactory()); // bb 931 return this.groupMeasure; 932 } 933 934 public boolean hasGroupMeasureElement() { 935 return this.groupMeasure != null && !this.groupMeasure.isEmpty(); 936 } 937 938 public boolean hasGroupMeasure() { 939 return this.groupMeasure != null && !this.groupMeasure.isEmpty(); 940 } 941 942 /** 943 * @param value {@link #groupMeasure} (Indicates how elements are aggregated 944 * within the study effective period.). This is the underlying 945 * object with id, value and extensions. The accessor 946 * "getGroupMeasure" gives direct access to the value 947 */ 948 public EvidenceVariableCharacteristicComponent setGroupMeasureElement(Enumeration<GroupMeasure> value) { 949 this.groupMeasure = value; 950 return this; 951 } 952 953 /** 954 * @return Indicates how elements are aggregated within the study effective 955 * period. 956 */ 957 public GroupMeasure getGroupMeasure() { 958 return this.groupMeasure == null ? null : this.groupMeasure.getValue(); 959 } 960 961 /** 962 * @param value Indicates how elements are aggregated within the study effective 963 * period. 964 */ 965 public EvidenceVariableCharacteristicComponent setGroupMeasure(GroupMeasure value) { 966 if (value == null) 967 this.groupMeasure = null; 968 else { 969 if (this.groupMeasure == null) 970 this.groupMeasure = new Enumeration<GroupMeasure>(new GroupMeasureEnumFactory()); 971 this.groupMeasure.setValue(value); 972 } 973 return this; 974 } 975 976 protected void listChildren(List<Property> children) { 977 super.listChildren(children); 978 children.add(new Property("description", "string", 979 "A short, natural language description of the characteristic that could be used to communicate the criteria to an end-user.", 980 0, 1, description)); 981 children.add(new Property("definition[x]", 982 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 983 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 984 0, 1, definition)); 985 children.add(new Property("usageContext", "UsageContext", 986 "Use UsageContext to define the members of the population, such as Age Ranges, Genders, Settings.", 0, 987 java.lang.Integer.MAX_VALUE, usageContext)); 988 children.add(new Property("exclude", "boolean", 989 "When true, members with this characteristic are excluded from the element.", 0, 1, exclude)); 990 children.add(new Property("participantEffective[x]", "dateTime|Period|Duration|Timing", 991 "Indicates what effective period the study covers.", 0, 1, participantEffective)); 992 children.add(new Property("timeFromStart", "Duration", "Indicates duration from the participant's study entry.", 993 0, 1, timeFromStart)); 994 children.add(new Property("groupMeasure", "code", 995 "Indicates how elements are aggregated within the study effective period.", 0, 1, groupMeasure)); 996 } 997 998 @Override 999 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1000 switch (_hash) { 1001 case -1724546052: 1002 /* description */ return new Property("description", "string", 1003 "A short, natural language description of the characteristic that could be used to communicate the criteria to an end-user.", 1004 0, 1, description); 1005 case -1139422643: 1006 /* definition[x] */ return new Property("definition[x]", 1007 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 1008 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 1009 0, 1, definition); 1010 case -1014418093: 1011 /* definition */ return new Property("definition[x]", 1012 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 1013 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 1014 0, 1, definition); 1015 case -820021448: 1016 /* definitionReference */ return new Property("definition[x]", 1017 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 1018 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 1019 0, 1, definition); 1020 case 933485793: 1021 /* definitionCanonical */ return new Property("definition[x]", 1022 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 1023 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 1024 0, 1, definition); 1025 case -1446002226: 1026 /* definitionCodeableConcept */ return new Property("definition[x]", 1027 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 1028 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 1029 0, 1, definition); 1030 case 1463703627: 1031 /* definitionExpression */ return new Property("definition[x]", 1032 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 1033 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 1034 0, 1, definition); 1035 case -660350874: 1036 /* definitionDataRequirement */ return new Property("definition[x]", 1037 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 1038 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 1039 0, 1, definition); 1040 case -1130324968: 1041 /* definitionTriggerDefinition */ return new Property("definition[x]", 1042 "Reference(Group)|canonical(ActivityDefinition)|CodeableConcept|Expression|DataRequirement|TriggerDefinition", 1043 "Define members of the evidence element using Codes (such as condition, medication, or observation), Expressions ( using an expression language such as FHIRPath or CQL) or DataRequirements (such as Diabetes diagnosis onset in the last year).", 1044 0, 1, definition); 1045 case 907012302: 1046 /* usageContext */ return new Property("usageContext", "UsageContext", 1047 "Use UsageContext to define the members of the population, such as Age Ranges, Genders, Settings.", 0, 1048 java.lang.Integer.MAX_VALUE, usageContext); 1049 case -1321148966: 1050 /* exclude */ return new Property("exclude", "boolean", 1051 "When true, members with this characteristic are excluded from the element.", 0, 1, exclude); 1052 case 1777308748: 1053 /* participantEffective[x] */ return new Property("participantEffective[x]", "dateTime|Period|Duration|Timing", 1054 "Indicates what effective period the study covers.", 0, 1, participantEffective); 1055 case 1376306100: 1056 /* participantEffective */ return new Property("participantEffective[x]", "dateTime|Period|Duration|Timing", 1057 "Indicates what effective period the study covers.", 0, 1, participantEffective); 1058 case -1721146513: 1059 /* participantEffectiveDateTime */ return new Property("participantEffective[x]", 1060 "dateTime|Period|Duration|Timing", "Indicates what effective period the study covers.", 0, 1, 1061 participantEffective); 1062 case -883650923: 1063 /* participantEffectivePeriod */ return new Property("participantEffective[x]", 1064 "dateTime|Period|Duration|Timing", "Indicates what effective period the study covers.", 0, 1, 1065 participantEffective); 1066 case -1210941080: 1067 /* participantEffectiveDuration */ return new Property("participantEffective[x]", 1068 "dateTime|Period|Duration|Timing", "Indicates what effective period the study covers.", 0, 1, 1069 participantEffective); 1070 case -765589218: 1071 /* participantEffectiveTiming */ return new Property("participantEffective[x]", 1072 "dateTime|Period|Duration|Timing", "Indicates what effective period the study covers.", 0, 1, 1073 participantEffective); 1074 case 2100140683: 1075 /* timeFromStart */ return new Property("timeFromStart", "Duration", 1076 "Indicates duration from the participant's study entry.", 0, 1, timeFromStart); 1077 case 588892639: 1078 /* groupMeasure */ return new Property("groupMeasure", "code", 1079 "Indicates how elements are aggregated within the study effective period.", 0, 1, groupMeasure); 1080 default: 1081 return super.getNamedProperty(_hash, _name, _checkValid); 1082 } 1083 1084 } 1085 1086 @Override 1087 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1088 switch (hash) { 1089 case -1724546052: 1090 /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType 1091 case -1014418093: 1092 /* definition */ return this.definition == null ? new Base[0] : new Base[] { this.definition }; // Type 1093 case 907012302: 1094 /* usageContext */ return this.usageContext == null ? new Base[0] 1095 : this.usageContext.toArray(new Base[this.usageContext.size()]); // UsageContext 1096 case -1321148966: 1097 /* exclude */ return this.exclude == null ? new Base[0] : new Base[] { this.exclude }; // BooleanType 1098 case 1376306100: 1099 /* participantEffective */ return this.participantEffective == null ? new Base[0] 1100 : new Base[] { this.participantEffective }; // Type 1101 case 2100140683: 1102 /* timeFromStart */ return this.timeFromStart == null ? new Base[0] : new Base[] { this.timeFromStart }; // Duration 1103 case 588892639: 1104 /* groupMeasure */ return this.groupMeasure == null ? new Base[0] : new Base[] { this.groupMeasure }; // Enumeration<GroupMeasure> 1105 default: 1106 return super.getProperty(hash, name, checkValid); 1107 } 1108 1109 } 1110 1111 @Override 1112 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1113 switch (hash) { 1114 case -1724546052: // description 1115 this.description = castToString(value); // StringType 1116 return value; 1117 case -1014418093: // definition 1118 this.definition = castToType(value); // Type 1119 return value; 1120 case 907012302: // usageContext 1121 this.getUsageContext().add(castToUsageContext(value)); // UsageContext 1122 return value; 1123 case -1321148966: // exclude 1124 this.exclude = castToBoolean(value); // BooleanType 1125 return value; 1126 case 1376306100: // participantEffective 1127 this.participantEffective = castToType(value); // Type 1128 return value; 1129 case 2100140683: // timeFromStart 1130 this.timeFromStart = castToDuration(value); // Duration 1131 return value; 1132 case 588892639: // groupMeasure 1133 value = new GroupMeasureEnumFactory().fromType(castToCode(value)); 1134 this.groupMeasure = (Enumeration) value; // Enumeration<GroupMeasure> 1135 return value; 1136 default: 1137 return super.setProperty(hash, name, value); 1138 } 1139 1140 } 1141 1142 @Override 1143 public Base setProperty(String name, Base value) throws FHIRException { 1144 if (name.equals("description")) { 1145 this.description = castToString(value); // StringType 1146 } else if (name.equals("definition[x]")) { 1147 this.definition = castToType(value); // Type 1148 } else if (name.equals("usageContext")) { 1149 this.getUsageContext().add(castToUsageContext(value)); 1150 } else if (name.equals("exclude")) { 1151 this.exclude = castToBoolean(value); // BooleanType 1152 } else if (name.equals("participantEffective[x]")) { 1153 this.participantEffective = castToType(value); // Type 1154 } else if (name.equals("timeFromStart")) { 1155 this.timeFromStart = castToDuration(value); // Duration 1156 } else if (name.equals("groupMeasure")) { 1157 value = new GroupMeasureEnumFactory().fromType(castToCode(value)); 1158 this.groupMeasure = (Enumeration) value; // Enumeration<GroupMeasure> 1159 } else 1160 return super.setProperty(name, value); 1161 return value; 1162 } 1163 1164 @Override 1165 public Base makeProperty(int hash, String name) throws FHIRException { 1166 switch (hash) { 1167 case -1724546052: 1168 return getDescriptionElement(); 1169 case -1139422643: 1170 return getDefinition(); 1171 case -1014418093: 1172 return getDefinition(); 1173 case 907012302: 1174 return addUsageContext(); 1175 case -1321148966: 1176 return getExcludeElement(); 1177 case 1777308748: 1178 return getParticipantEffective(); 1179 case 1376306100: 1180 return getParticipantEffective(); 1181 case 2100140683: 1182 return getTimeFromStart(); 1183 case 588892639: 1184 return getGroupMeasureElement(); 1185 default: 1186 return super.makeProperty(hash, name); 1187 } 1188 1189 } 1190 1191 @Override 1192 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1193 switch (hash) { 1194 case -1724546052: 1195 /* description */ return new String[] { "string" }; 1196 case -1014418093: 1197 /* definition */ return new String[] { "Reference", "canonical", "CodeableConcept", "Expression", 1198 "DataRequirement", "TriggerDefinition" }; 1199 case 907012302: 1200 /* usageContext */ return new String[] { "UsageContext" }; 1201 case -1321148966: 1202 /* exclude */ return new String[] { "boolean" }; 1203 case 1376306100: 1204 /* participantEffective */ return new String[] { "dateTime", "Period", "Duration", "Timing" }; 1205 case 2100140683: 1206 /* timeFromStart */ return new String[] { "Duration" }; 1207 case 588892639: 1208 /* groupMeasure */ return new String[] { "code" }; 1209 default: 1210 return super.getTypesForProperty(hash, name); 1211 } 1212 1213 } 1214 1215 @Override 1216 public Base addChild(String name) throws FHIRException { 1217 if (name.equals("description")) { 1218 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.description"); 1219 } else if (name.equals("definitionReference")) { 1220 this.definition = new Reference(); 1221 return this.definition; 1222 } else if (name.equals("definitionCanonical")) { 1223 this.definition = new CanonicalType(); 1224 return this.definition; 1225 } else if (name.equals("definitionCodeableConcept")) { 1226 this.definition = new CodeableConcept(); 1227 return this.definition; 1228 } else if (name.equals("definitionExpression")) { 1229 this.definition = new Expression(); 1230 return this.definition; 1231 } else if (name.equals("definitionDataRequirement")) { 1232 this.definition = new DataRequirement(); 1233 return this.definition; 1234 } else if (name.equals("definitionTriggerDefinition")) { 1235 this.definition = new TriggerDefinition(); 1236 return this.definition; 1237 } else if (name.equals("usageContext")) { 1238 return addUsageContext(); 1239 } else if (name.equals("exclude")) { 1240 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.exclude"); 1241 } else if (name.equals("participantEffectiveDateTime")) { 1242 this.participantEffective = new DateTimeType(); 1243 return this.participantEffective; 1244 } else if (name.equals("participantEffectivePeriod")) { 1245 this.participantEffective = new Period(); 1246 return this.participantEffective; 1247 } else if (name.equals("participantEffectiveDuration")) { 1248 this.participantEffective = new Duration(); 1249 return this.participantEffective; 1250 } else if (name.equals("participantEffectiveTiming")) { 1251 this.participantEffective = new Timing(); 1252 return this.participantEffective; 1253 } else if (name.equals("timeFromStart")) { 1254 this.timeFromStart = new Duration(); 1255 return this.timeFromStart; 1256 } else if (name.equals("groupMeasure")) { 1257 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.groupMeasure"); 1258 } else 1259 return super.addChild(name); 1260 } 1261 1262 public EvidenceVariableCharacteristicComponent copy() { 1263 EvidenceVariableCharacteristicComponent dst = new EvidenceVariableCharacteristicComponent(); 1264 copyValues(dst); 1265 return dst; 1266 } 1267 1268 public void copyValues(EvidenceVariableCharacteristicComponent dst) { 1269 super.copyValues(dst); 1270 dst.description = description == null ? null : description.copy(); 1271 dst.definition = definition == null ? null : definition.copy(); 1272 if (usageContext != null) { 1273 dst.usageContext = new ArrayList<UsageContext>(); 1274 for (UsageContext i : usageContext) 1275 dst.usageContext.add(i.copy()); 1276 } 1277 ; 1278 dst.exclude = exclude == null ? null : exclude.copy(); 1279 dst.participantEffective = participantEffective == null ? null : participantEffective.copy(); 1280 dst.timeFromStart = timeFromStart == null ? null : timeFromStart.copy(); 1281 dst.groupMeasure = groupMeasure == null ? null : groupMeasure.copy(); 1282 } 1283 1284 @Override 1285 public boolean equalsDeep(Base other_) { 1286 if (!super.equalsDeep(other_)) 1287 return false; 1288 if (!(other_ instanceof EvidenceVariableCharacteristicComponent)) 1289 return false; 1290 EvidenceVariableCharacteristicComponent o = (EvidenceVariableCharacteristicComponent) other_; 1291 return compareDeep(description, o.description, true) && compareDeep(definition, o.definition, true) 1292 && compareDeep(usageContext, o.usageContext, true) && compareDeep(exclude, o.exclude, true) 1293 && compareDeep(participantEffective, o.participantEffective, true) 1294 && compareDeep(timeFromStart, o.timeFromStart, true) && compareDeep(groupMeasure, o.groupMeasure, true); 1295 } 1296 1297 @Override 1298 public boolean equalsShallow(Base other_) { 1299 if (!super.equalsShallow(other_)) 1300 return false; 1301 if (!(other_ instanceof EvidenceVariableCharacteristicComponent)) 1302 return false; 1303 EvidenceVariableCharacteristicComponent o = (EvidenceVariableCharacteristicComponent) other_; 1304 return compareValues(description, o.description, true) && compareValues(exclude, o.exclude, true) 1305 && compareValues(groupMeasure, o.groupMeasure, true); 1306 } 1307 1308 public boolean isEmpty() { 1309 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(description, definition, usageContext, exclude, 1310 participantEffective, timeFromStart, groupMeasure); 1311 } 1312 1313 public String fhirType() { 1314 return "EvidenceVariable.characteristic"; 1315 1316 } 1317 1318 } 1319 1320 /** 1321 * A formal identifier that is used to identify this evidence variable when it 1322 * is represented in other formats, or referenced in a specification, model, 1323 * design or an instance. 1324 */ 1325 @Child(name = "identifier", type = { 1326 Identifier.class }, order = 0, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 1327 @Description(shortDefinition = "Additional identifier for the evidence variable", formalDefinition = "A formal identifier that is used to identify this evidence variable when it is represented in other formats, or referenced in a specification, model, design or an instance.") 1328 protected List<Identifier> identifier; 1329 1330 /** 1331 * The short title provides an alternate title for use in informal descriptive 1332 * contexts where the full, formal title is not necessary. 1333 */ 1334 @Child(name = "shortTitle", type = { 1335 StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = true) 1336 @Description(shortDefinition = "Title for use in informal contexts", formalDefinition = "The short title provides an alternate title for use in informal descriptive contexts where the full, formal title is not necessary.") 1337 protected StringType shortTitle; 1338 1339 /** 1340 * An explanatory or alternate title for the EvidenceVariable giving additional 1341 * information about its content. 1342 */ 1343 @Child(name = "subtitle", type = { StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 1344 @Description(shortDefinition = "Subordinate title of the EvidenceVariable", formalDefinition = "An explanatory or alternate title for the EvidenceVariable giving additional information about its content.") 1345 protected StringType subtitle; 1346 1347 /** 1348 * A human-readable string to clarify or explain concepts about the resource. 1349 */ 1350 @Child(name = "note", type = { 1351 Annotation.class }, order = 3, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1352 @Description(shortDefinition = "Used for footnotes or explanatory notes", formalDefinition = "A human-readable string to clarify or explain concepts about the resource.") 1353 protected List<Annotation> note; 1354 1355 /** 1356 * A copyright statement relating to the evidence variable and/or its contents. 1357 * Copyright statements are generally legal restrictions on the use and 1358 * publishing of the evidence variable. 1359 */ 1360 @Child(name = "copyright", type = { 1361 MarkdownType.class }, order = 4, min = 0, max = 1, modifier = false, summary = false) 1362 @Description(shortDefinition = "Use and/or publishing restrictions", formalDefinition = "A copyright statement relating to the evidence variable and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the evidence variable.") 1363 protected MarkdownType copyright; 1364 1365 /** 1366 * The date on which the resource content was approved by the publisher. 1367 * Approval happens once when the content is officially approved for usage. 1368 */ 1369 @Child(name = "approvalDate", type = { 1370 DateType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false) 1371 @Description(shortDefinition = "When the evidence variable was approved by publisher", formalDefinition = "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.") 1372 protected DateType approvalDate; 1373 1374 /** 1375 * The date on which the resource content was last reviewed. Review happens 1376 * periodically after approval but does not change the original approval date. 1377 */ 1378 @Child(name = "lastReviewDate", type = { 1379 DateType.class }, order = 6, min = 0, max = 1, modifier = false, summary = false) 1380 @Description(shortDefinition = "When the evidence variable was last reviewed", formalDefinition = "The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date.") 1381 protected DateType lastReviewDate; 1382 1383 /** 1384 * The period during which the evidence variable content was or is planned to be 1385 * in active use. 1386 */ 1387 @Child(name = "effectivePeriod", type = { 1388 Period.class }, order = 7, min = 0, max = 1, modifier = false, summary = true) 1389 @Description(shortDefinition = "When the evidence variable is expected to be used", formalDefinition = "The period during which the evidence variable content was or is planned to be in active use.") 1390 protected Period effectivePeriod; 1391 1392 /** 1393 * Descriptive topics related to the content of the EvidenceVariable. Topics 1394 * provide a high-level categorization grouping types of EvidenceVariables that 1395 * can be useful for filtering and searching. 1396 */ 1397 @Child(name = "topic", type = { 1398 CodeableConcept.class }, order = 8, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1399 @Description(shortDefinition = "The category of the EvidenceVariable, such as Education, Treatment, Assessment, etc.", formalDefinition = "Descriptive topics related to the content of the EvidenceVariable. Topics provide a high-level categorization grouping types of EvidenceVariables that can be useful for filtering and searching.") 1400 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/definition-topic") 1401 protected List<CodeableConcept> topic; 1402 1403 /** 1404 * An individiual or organization primarily involved in the creation and 1405 * maintenance of the content. 1406 */ 1407 @Child(name = "author", type = { 1408 ContactDetail.class }, order = 9, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1409 @Description(shortDefinition = "Who authored the content", formalDefinition = "An individiual or organization primarily involved in the creation and maintenance of the content.") 1410 protected List<ContactDetail> author; 1411 1412 /** 1413 * An individual or organization primarily responsible for internal coherence of 1414 * the content. 1415 */ 1416 @Child(name = "editor", type = { 1417 ContactDetail.class }, order = 10, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1418 @Description(shortDefinition = "Who edited the content", formalDefinition = "An individual or organization primarily responsible for internal coherence of the content.") 1419 protected List<ContactDetail> editor; 1420 1421 /** 1422 * An individual or organization primarily responsible for review of some aspect 1423 * of the content. 1424 */ 1425 @Child(name = "reviewer", type = { 1426 ContactDetail.class }, order = 11, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1427 @Description(shortDefinition = "Who reviewed the content", formalDefinition = "An individual or organization primarily responsible for review of some aspect of the content.") 1428 protected List<ContactDetail> reviewer; 1429 1430 /** 1431 * An individual or organization responsible for officially endorsing the 1432 * content for use in some setting. 1433 */ 1434 @Child(name = "endorser", type = { 1435 ContactDetail.class }, order = 12, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1436 @Description(shortDefinition = "Who endorsed the content", formalDefinition = "An individual or organization responsible for officially endorsing the content for use in some setting.") 1437 protected List<ContactDetail> endorser; 1438 1439 /** 1440 * Related artifacts such as additional documentation, justification, or 1441 * bibliographic references. 1442 */ 1443 @Child(name = "relatedArtifact", type = { 1444 RelatedArtifact.class }, order = 13, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 1445 @Description(shortDefinition = "Additional documentation, citations, etc.", formalDefinition = "Related artifacts such as additional documentation, justification, or bibliographic references.") 1446 protected List<RelatedArtifact> relatedArtifact; 1447 1448 /** 1449 * The type of evidence element, a population, an exposure, or an outcome. 1450 */ 1451 @Child(name = "type", type = { CodeType.class }, order = 14, min = 0, max = 1, modifier = false, summary = true) 1452 @Description(shortDefinition = "dichotomous | continuous | descriptive", formalDefinition = "The type of evidence element, a population, an exposure, or an outcome.") 1453 @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/variable-type") 1454 protected Enumeration<EvidenceVariableType> type; 1455 1456 /** 1457 * A characteristic that defines the members of the evidence element. Multiple 1458 * characteristics are applied with "and" semantics. 1459 */ 1460 @Child(name = "characteristic", type = {}, order = 15, min = 1, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 1461 @Description(shortDefinition = "What defines the members of the evidence element", formalDefinition = "A characteristic that defines the members of the evidence element. Multiple characteristics are applied with \"and\" semantics.") 1462 protected List<EvidenceVariableCharacteristicComponent> characteristic; 1463 1464 private static final long serialVersionUID = -317280154L; 1465 1466 /** 1467 * Constructor 1468 */ 1469 public EvidenceVariable() { 1470 super(); 1471 } 1472 1473 /** 1474 * Constructor 1475 */ 1476 public EvidenceVariable(Enumeration<PublicationStatus> status) { 1477 super(); 1478 this.status = status; 1479 } 1480 1481 /** 1482 * @return {@link #url} (An absolute URI that is used to identify this evidence 1483 * variable when it is referenced in a specification, model, design or 1484 * an instance; also called its canonical identifier. This SHOULD be 1485 * globally unique and SHOULD be a literal address at which at which an 1486 * authoritative instance of this evidence variable is (or will be) 1487 * published. This URL can be the target of a canonical reference. It 1488 * SHALL remain the same when the evidence variable is stored on 1489 * different servers.). This is the underlying object with id, value and 1490 * extensions. The accessor "getUrl" gives direct access to the value 1491 */ 1492 public UriType getUrlElement() { 1493 if (this.url == null) 1494 if (Configuration.errorOnAutoCreate()) 1495 throw new Error("Attempt to auto-create EvidenceVariable.url"); 1496 else if (Configuration.doAutoCreate()) 1497 this.url = new UriType(); // bb 1498 return this.url; 1499 } 1500 1501 public boolean hasUrlElement() { 1502 return this.url != null && !this.url.isEmpty(); 1503 } 1504 1505 public boolean hasUrl() { 1506 return this.url != null && !this.url.isEmpty(); 1507 } 1508 1509 /** 1510 * @param value {@link #url} (An absolute URI that is used to identify this 1511 * evidence variable when it is referenced in a specification, 1512 * model, design or an instance; also called its canonical 1513 * identifier. This SHOULD be globally unique and SHOULD be a 1514 * literal address at which at which an authoritative instance of 1515 * this evidence variable is (or will be) published. This URL can 1516 * be the target of a canonical reference. It SHALL remain the same 1517 * when the evidence variable is stored on different servers.). 1518 * This is the underlying object with id, value and extensions. The 1519 * accessor "getUrl" gives direct access to the value 1520 */ 1521 public EvidenceVariable setUrlElement(UriType value) { 1522 this.url = value; 1523 return this; 1524 } 1525 1526 /** 1527 * @return An absolute URI that is used to identify this evidence variable when 1528 * it is referenced in a specification, model, design or an instance; 1529 * also called its canonical identifier. This SHOULD be globally unique 1530 * and SHOULD be a literal address at which at which an authoritative 1531 * instance of this evidence variable is (or will be) published. This 1532 * URL can be the target of a canonical reference. It SHALL remain the 1533 * same when the evidence variable is stored on different servers. 1534 */ 1535 public String getUrl() { 1536 return this.url == null ? null : this.url.getValue(); 1537 } 1538 1539 /** 1540 * @param value An absolute URI that is used to identify this evidence variable 1541 * when it is referenced in a specification, model, design or an 1542 * instance; also called its canonical identifier. This SHOULD be 1543 * globally unique and SHOULD be a literal address at which at 1544 * which an authoritative instance of this evidence variable is (or 1545 * will be) published. This URL can be the target of a canonical 1546 * reference. It SHALL remain the same when the evidence variable 1547 * is stored on different servers. 1548 */ 1549 public EvidenceVariable setUrl(String value) { 1550 if (Utilities.noString(value)) 1551 this.url = null; 1552 else { 1553 if (this.url == null) 1554 this.url = new UriType(); 1555 this.url.setValue(value); 1556 } 1557 return this; 1558 } 1559 1560 /** 1561 * @return {@link #identifier} (A formal identifier that is used to identify 1562 * this evidence variable when it is represented in other formats, or 1563 * referenced in a specification, model, design or an instance.) 1564 */ 1565 public List<Identifier> getIdentifier() { 1566 if (this.identifier == null) 1567 this.identifier = new ArrayList<Identifier>(); 1568 return this.identifier; 1569 } 1570 1571 /** 1572 * @return Returns a reference to <code>this</code> for easy method chaining 1573 */ 1574 public EvidenceVariable setIdentifier(List<Identifier> theIdentifier) { 1575 this.identifier = theIdentifier; 1576 return this; 1577 } 1578 1579 public boolean hasIdentifier() { 1580 if (this.identifier == null) 1581 return false; 1582 for (Identifier item : this.identifier) 1583 if (!item.isEmpty()) 1584 return true; 1585 return false; 1586 } 1587 1588 public Identifier addIdentifier() { // 3 1589 Identifier t = new Identifier(); 1590 if (this.identifier == null) 1591 this.identifier = new ArrayList<Identifier>(); 1592 this.identifier.add(t); 1593 return t; 1594 } 1595 1596 public EvidenceVariable addIdentifier(Identifier t) { // 3 1597 if (t == null) 1598 return this; 1599 if (this.identifier == null) 1600 this.identifier = new ArrayList<Identifier>(); 1601 this.identifier.add(t); 1602 return this; 1603 } 1604 1605 /** 1606 * @return The first repetition of repeating field {@link #identifier}, creating 1607 * it if it does not already exist 1608 */ 1609 public Identifier getIdentifierFirstRep() { 1610 if (getIdentifier().isEmpty()) { 1611 addIdentifier(); 1612 } 1613 return getIdentifier().get(0); 1614 } 1615 1616 /** 1617 * @return {@link #version} (The identifier that is used to identify this 1618 * version of the evidence variable when it is referenced in a 1619 * specification, model, design or instance. This is an arbitrary value 1620 * managed by the evidence variable author and is not expected to be 1621 * globally unique. For example, it might be a timestamp (e.g. yyyymmdd) 1622 * if a managed version is not available. There is also no expectation 1623 * that versions can be placed in a lexicographical sequence. To provide 1624 * a version consistent with the Decision Support Service specification, 1625 * use the format Major.Minor.Revision (e.g. 1.0.0). For more 1626 * information on versioning knowledge assets, refer to the Decision 1627 * Support Service specification. Note that a version is required for 1628 * non-experimental active artifacts.). This is the underlying object 1629 * with id, value and extensions. The accessor "getVersion" gives direct 1630 * access to the value 1631 */ 1632 public StringType getVersionElement() { 1633 if (this.version == null) 1634 if (Configuration.errorOnAutoCreate()) 1635 throw new Error("Attempt to auto-create EvidenceVariable.version"); 1636 else if (Configuration.doAutoCreate()) 1637 this.version = new StringType(); // bb 1638 return this.version; 1639 } 1640 1641 public boolean hasVersionElement() { 1642 return this.version != null && !this.version.isEmpty(); 1643 } 1644 1645 public boolean hasVersion() { 1646 return this.version != null && !this.version.isEmpty(); 1647 } 1648 1649 /** 1650 * @param value {@link #version} (The identifier that is used to identify this 1651 * version of the evidence variable when it is referenced in a 1652 * specification, model, design or instance. This is an arbitrary 1653 * value managed by the evidence variable author and is not 1654 * expected to be globally unique. For example, it might be a 1655 * timestamp (e.g. yyyymmdd) if a managed version is not available. 1656 * There is also no expectation that versions can be placed in a 1657 * lexicographical sequence. To provide a version consistent with 1658 * the Decision Support Service specification, use the format 1659 * Major.Minor.Revision (e.g. 1.0.0). For more information on 1660 * versioning knowledge assets, refer to the Decision Support 1661 * Service specification. Note that a version is required for 1662 * non-experimental active artifacts.). This is the underlying 1663 * object with id, value and extensions. The accessor "getVersion" 1664 * gives direct access to the value 1665 */ 1666 public EvidenceVariable setVersionElement(StringType value) { 1667 this.version = value; 1668 return this; 1669 } 1670 1671 /** 1672 * @return The identifier that is used to identify this version of the evidence 1673 * variable when it is referenced in a specification, model, design or 1674 * instance. This is an arbitrary value managed by the evidence variable 1675 * author and is not expected to be globally unique. For example, it 1676 * might be a timestamp (e.g. yyyymmdd) if a managed version is not 1677 * available. There is also no expectation that versions can be placed 1678 * in a lexicographical sequence. To provide a version consistent with 1679 * the Decision Support Service specification, use the format 1680 * Major.Minor.Revision (e.g. 1.0.0). For more information on versioning 1681 * knowledge assets, refer to the Decision Support Service 1682 * specification. Note that a version is required for non-experimental 1683 * active artifacts. 1684 */ 1685 public String getVersion() { 1686 return this.version == null ? null : this.version.getValue(); 1687 } 1688 1689 /** 1690 * @param value The identifier that is used to identify this version of the 1691 * evidence variable when it is referenced in a specification, 1692 * model, design or instance. This is an arbitrary value managed by 1693 * the evidence variable author and is not expected to be globally 1694 * unique. For example, it might be a timestamp (e.g. yyyymmdd) if 1695 * a managed version is not available. There is also no expectation 1696 * that versions can be placed in a lexicographical sequence. To 1697 * provide a version consistent with the Decision Support Service 1698 * specification, use the format Major.Minor.Revision (e.g. 1.0.0). 1699 * For more information on versioning knowledge assets, refer to 1700 * the Decision Support Service specification. Note that a version 1701 * is required for non-experimental active artifacts. 1702 */ 1703 public EvidenceVariable setVersion(String value) { 1704 if (Utilities.noString(value)) 1705 this.version = null; 1706 else { 1707 if (this.version == null) 1708 this.version = new StringType(); 1709 this.version.setValue(value); 1710 } 1711 return this; 1712 } 1713 1714 /** 1715 * @return {@link #name} (A natural language name identifying the evidence 1716 * variable. This name should be usable as an identifier for the module 1717 * by machine processing applications such as code generation.). This is 1718 * the underlying object with id, value and extensions. The accessor 1719 * "getName" gives direct access to the value 1720 */ 1721 public StringType getNameElement() { 1722 if (this.name == null) 1723 if (Configuration.errorOnAutoCreate()) 1724 throw new Error("Attempt to auto-create EvidenceVariable.name"); 1725 else if (Configuration.doAutoCreate()) 1726 this.name = new StringType(); // bb 1727 return this.name; 1728 } 1729 1730 public boolean hasNameElement() { 1731 return this.name != null && !this.name.isEmpty(); 1732 } 1733 1734 public boolean hasName() { 1735 return this.name != null && !this.name.isEmpty(); 1736 } 1737 1738 /** 1739 * @param value {@link #name} (A natural language name identifying the evidence 1740 * variable. This name should be usable as an identifier for the 1741 * module by machine processing applications such as code 1742 * generation.). This is the underlying object with id, value and 1743 * extensions. The accessor "getName" gives direct access to the 1744 * value 1745 */ 1746 public EvidenceVariable setNameElement(StringType value) { 1747 this.name = value; 1748 return this; 1749 } 1750 1751 /** 1752 * @return A natural language name identifying the evidence variable. This name 1753 * should be usable as an identifier for the module by machine 1754 * processing applications such as code generation. 1755 */ 1756 public String getName() { 1757 return this.name == null ? null : this.name.getValue(); 1758 } 1759 1760 /** 1761 * @param value A natural language name identifying the evidence variable. This 1762 * name should be usable as an identifier for the module by machine 1763 * processing applications such as code generation. 1764 */ 1765 public EvidenceVariable setName(String value) { 1766 if (Utilities.noString(value)) 1767 this.name = null; 1768 else { 1769 if (this.name == null) 1770 this.name = new StringType(); 1771 this.name.setValue(value); 1772 } 1773 return this; 1774 } 1775 1776 /** 1777 * @return {@link #title} (A short, descriptive, user-friendly title for the 1778 * evidence variable.). This is the underlying object with id, value and 1779 * extensions. The accessor "getTitle" gives direct access to the value 1780 */ 1781 public StringType getTitleElement() { 1782 if (this.title == null) 1783 if (Configuration.errorOnAutoCreate()) 1784 throw new Error("Attempt to auto-create EvidenceVariable.title"); 1785 else if (Configuration.doAutoCreate()) 1786 this.title = new StringType(); // bb 1787 return this.title; 1788 } 1789 1790 public boolean hasTitleElement() { 1791 return this.title != null && !this.title.isEmpty(); 1792 } 1793 1794 public boolean hasTitle() { 1795 return this.title != null && !this.title.isEmpty(); 1796 } 1797 1798 /** 1799 * @param value {@link #title} (A short, descriptive, user-friendly title for 1800 * the evidence variable.). This is the underlying object with id, 1801 * value and extensions. The accessor "getTitle" gives direct 1802 * access to the value 1803 */ 1804 public EvidenceVariable setTitleElement(StringType value) { 1805 this.title = value; 1806 return this; 1807 } 1808 1809 /** 1810 * @return A short, descriptive, user-friendly title for the evidence variable. 1811 */ 1812 public String getTitle() { 1813 return this.title == null ? null : this.title.getValue(); 1814 } 1815 1816 /** 1817 * @param value A short, descriptive, user-friendly title for the evidence 1818 * variable. 1819 */ 1820 public EvidenceVariable setTitle(String value) { 1821 if (Utilities.noString(value)) 1822 this.title = null; 1823 else { 1824 if (this.title == null) 1825 this.title = new StringType(); 1826 this.title.setValue(value); 1827 } 1828 return this; 1829 } 1830 1831 /** 1832 * @return {@link #shortTitle} (The short title provides an alternate title for 1833 * use in informal descriptive contexts where the full, formal title is 1834 * not necessary.). This is the underlying object with id, value and 1835 * extensions. The accessor "getShortTitle" gives direct access to the 1836 * value 1837 */ 1838 public StringType getShortTitleElement() { 1839 if (this.shortTitle == null) 1840 if (Configuration.errorOnAutoCreate()) 1841 throw new Error("Attempt to auto-create EvidenceVariable.shortTitle"); 1842 else if (Configuration.doAutoCreate()) 1843 this.shortTitle = new StringType(); // bb 1844 return this.shortTitle; 1845 } 1846 1847 public boolean hasShortTitleElement() { 1848 return this.shortTitle != null && !this.shortTitle.isEmpty(); 1849 } 1850 1851 public boolean hasShortTitle() { 1852 return this.shortTitle != null && !this.shortTitle.isEmpty(); 1853 } 1854 1855 /** 1856 * @param value {@link #shortTitle} (The short title provides an alternate title 1857 * for use in informal descriptive contexts where the full, formal 1858 * title is not necessary.). This is the underlying object with id, 1859 * value and extensions. The accessor "getShortTitle" gives direct 1860 * access to the value 1861 */ 1862 public EvidenceVariable setShortTitleElement(StringType value) { 1863 this.shortTitle = value; 1864 return this; 1865 } 1866 1867 /** 1868 * @return The short title provides an alternate title for use in informal 1869 * descriptive contexts where the full, formal title is not necessary. 1870 */ 1871 public String getShortTitle() { 1872 return this.shortTitle == null ? null : this.shortTitle.getValue(); 1873 } 1874 1875 /** 1876 * @param value The short title provides an alternate title for use in informal 1877 * descriptive contexts where the full, formal title is not 1878 * necessary. 1879 */ 1880 public EvidenceVariable setShortTitle(String value) { 1881 if (Utilities.noString(value)) 1882 this.shortTitle = null; 1883 else { 1884 if (this.shortTitle == null) 1885 this.shortTitle = new StringType(); 1886 this.shortTitle.setValue(value); 1887 } 1888 return this; 1889 } 1890 1891 /** 1892 * @return {@link #subtitle} (An explanatory or alternate title for the 1893 * EvidenceVariable giving additional information about its content.). 1894 * This is the underlying object with id, value and extensions. The 1895 * accessor "getSubtitle" gives direct access to the value 1896 */ 1897 public StringType getSubtitleElement() { 1898 if (this.subtitle == null) 1899 if (Configuration.errorOnAutoCreate()) 1900 throw new Error("Attempt to auto-create EvidenceVariable.subtitle"); 1901 else if (Configuration.doAutoCreate()) 1902 this.subtitle = new StringType(); // bb 1903 return this.subtitle; 1904 } 1905 1906 public boolean hasSubtitleElement() { 1907 return this.subtitle != null && !this.subtitle.isEmpty(); 1908 } 1909 1910 public boolean hasSubtitle() { 1911 return this.subtitle != null && !this.subtitle.isEmpty(); 1912 } 1913 1914 /** 1915 * @param value {@link #subtitle} (An explanatory or alternate title for the 1916 * EvidenceVariable giving additional information about its 1917 * content.). This is the underlying object with id, value and 1918 * extensions. The accessor "getSubtitle" gives direct access to 1919 * the value 1920 */ 1921 public EvidenceVariable setSubtitleElement(StringType value) { 1922 this.subtitle = value; 1923 return this; 1924 } 1925 1926 /** 1927 * @return An explanatory or alternate title for the EvidenceVariable giving 1928 * additional information about its content. 1929 */ 1930 public String getSubtitle() { 1931 return this.subtitle == null ? null : this.subtitle.getValue(); 1932 } 1933 1934 /** 1935 * @param value An explanatory or alternate title for the EvidenceVariable 1936 * giving additional information about its content. 1937 */ 1938 public EvidenceVariable setSubtitle(String value) { 1939 if (Utilities.noString(value)) 1940 this.subtitle = null; 1941 else { 1942 if (this.subtitle == null) 1943 this.subtitle = new StringType(); 1944 this.subtitle.setValue(value); 1945 } 1946 return this; 1947 } 1948 1949 /** 1950 * @return {@link #status} (The status of this evidence variable. Enables 1951 * tracking the life-cycle of the content.). This is the underlying 1952 * object with id, value and extensions. The accessor "getStatus" gives 1953 * direct access to the value 1954 */ 1955 public Enumeration<PublicationStatus> getStatusElement() { 1956 if (this.status == null) 1957 if (Configuration.errorOnAutoCreate()) 1958 throw new Error("Attempt to auto-create EvidenceVariable.status"); 1959 else if (Configuration.doAutoCreate()) 1960 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 1961 return this.status; 1962 } 1963 1964 public boolean hasStatusElement() { 1965 return this.status != null && !this.status.isEmpty(); 1966 } 1967 1968 public boolean hasStatus() { 1969 return this.status != null && !this.status.isEmpty(); 1970 } 1971 1972 /** 1973 * @param value {@link #status} (The status of this evidence variable. Enables 1974 * tracking the life-cycle of the content.). This is the underlying 1975 * object with id, value and extensions. The accessor "getStatus" 1976 * gives direct access to the value 1977 */ 1978 public EvidenceVariable setStatusElement(Enumeration<PublicationStatus> value) { 1979 this.status = value; 1980 return this; 1981 } 1982 1983 /** 1984 * @return The status of this evidence variable. Enables tracking the life-cycle 1985 * of the content. 1986 */ 1987 public PublicationStatus getStatus() { 1988 return this.status == null ? null : this.status.getValue(); 1989 } 1990 1991 /** 1992 * @param value The status of this evidence variable. Enables tracking the 1993 * life-cycle of the content. 1994 */ 1995 public EvidenceVariable setStatus(PublicationStatus value) { 1996 if (this.status == null) 1997 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 1998 this.status.setValue(value); 1999 return this; 2000 } 2001 2002 /** 2003 * @return {@link #date} (The date (and optionally time) when the evidence 2004 * variable was published. The date must change when the business 2005 * version changes and it must change if the status code changes. In 2006 * addition, it should change when the substantive content of the 2007 * evidence variable changes.). This is the underlying object with id, 2008 * value and extensions. The accessor "getDate" gives direct access to 2009 * the value 2010 */ 2011 public DateTimeType getDateElement() { 2012 if (this.date == null) 2013 if (Configuration.errorOnAutoCreate()) 2014 throw new Error("Attempt to auto-create EvidenceVariable.date"); 2015 else if (Configuration.doAutoCreate()) 2016 this.date = new DateTimeType(); // bb 2017 return this.date; 2018 } 2019 2020 public boolean hasDateElement() { 2021 return this.date != null && !this.date.isEmpty(); 2022 } 2023 2024 public boolean hasDate() { 2025 return this.date != null && !this.date.isEmpty(); 2026 } 2027 2028 /** 2029 * @param value {@link #date} (The date (and optionally time) when the evidence 2030 * variable was published. The date must change when the business 2031 * version changes and it must change if the status code changes. 2032 * In addition, it should change when the substantive content of 2033 * the evidence variable changes.). This is the underlying object 2034 * with id, value and extensions. The accessor "getDate" gives 2035 * direct access to the value 2036 */ 2037 public EvidenceVariable setDateElement(DateTimeType value) { 2038 this.date = value; 2039 return this; 2040 } 2041 2042 /** 2043 * @return The date (and optionally time) when the evidence variable was 2044 * published. The date must change when the business version changes and 2045 * it must change if the status code changes. In addition, it should 2046 * change when the substantive content of the evidence variable changes. 2047 */ 2048 public Date getDate() { 2049 return this.date == null ? null : this.date.getValue(); 2050 } 2051 2052 /** 2053 * @param value The date (and optionally time) when the evidence variable was 2054 * published. The date must change when the business version 2055 * changes and it must change if the status code changes. In 2056 * addition, it should change when the substantive content of the 2057 * evidence variable changes. 2058 */ 2059 public EvidenceVariable setDate(Date value) { 2060 if (value == null) 2061 this.date = null; 2062 else { 2063 if (this.date == null) 2064 this.date = new DateTimeType(); 2065 this.date.setValue(value); 2066 } 2067 return this; 2068 } 2069 2070 /** 2071 * @return {@link #publisher} (The name of the organization or individual that 2072 * published the evidence variable.). This is the underlying object with 2073 * id, value and extensions. The accessor "getPublisher" gives direct 2074 * access to the value 2075 */ 2076 public StringType getPublisherElement() { 2077 if (this.publisher == null) 2078 if (Configuration.errorOnAutoCreate()) 2079 throw new Error("Attempt to auto-create EvidenceVariable.publisher"); 2080 else if (Configuration.doAutoCreate()) 2081 this.publisher = new StringType(); // bb 2082 return this.publisher; 2083 } 2084 2085 public boolean hasPublisherElement() { 2086 return this.publisher != null && !this.publisher.isEmpty(); 2087 } 2088 2089 public boolean hasPublisher() { 2090 return this.publisher != null && !this.publisher.isEmpty(); 2091 } 2092 2093 /** 2094 * @param value {@link #publisher} (The name of the organization or individual 2095 * that published the evidence variable.). This is the underlying 2096 * object with id, value and extensions. The accessor 2097 * "getPublisher" gives direct access to the value 2098 */ 2099 public EvidenceVariable setPublisherElement(StringType value) { 2100 this.publisher = value; 2101 return this; 2102 } 2103 2104 /** 2105 * @return The name of the organization or individual that published the 2106 * evidence variable. 2107 */ 2108 public String getPublisher() { 2109 return this.publisher == null ? null : this.publisher.getValue(); 2110 } 2111 2112 /** 2113 * @param value The name of the organization or individual that published the 2114 * evidence variable. 2115 */ 2116 public EvidenceVariable setPublisher(String value) { 2117 if (Utilities.noString(value)) 2118 this.publisher = null; 2119 else { 2120 if (this.publisher == null) 2121 this.publisher = new StringType(); 2122 this.publisher.setValue(value); 2123 } 2124 return this; 2125 } 2126 2127 /** 2128 * @return {@link #contact} (Contact details to assist a user in finding and 2129 * communicating with the publisher.) 2130 */ 2131 public List<ContactDetail> getContact() { 2132 if (this.contact == null) 2133 this.contact = new ArrayList<ContactDetail>(); 2134 return this.contact; 2135 } 2136 2137 /** 2138 * @return Returns a reference to <code>this</code> for easy method chaining 2139 */ 2140 public EvidenceVariable setContact(List<ContactDetail> theContact) { 2141 this.contact = theContact; 2142 return this; 2143 } 2144 2145 public boolean hasContact() { 2146 if (this.contact == null) 2147 return false; 2148 for (ContactDetail item : this.contact) 2149 if (!item.isEmpty()) 2150 return true; 2151 return false; 2152 } 2153 2154 public ContactDetail addContact() { // 3 2155 ContactDetail t = new ContactDetail(); 2156 if (this.contact == null) 2157 this.contact = new ArrayList<ContactDetail>(); 2158 this.contact.add(t); 2159 return t; 2160 } 2161 2162 public EvidenceVariable addContact(ContactDetail t) { // 3 2163 if (t == null) 2164 return this; 2165 if (this.contact == null) 2166 this.contact = new ArrayList<ContactDetail>(); 2167 this.contact.add(t); 2168 return this; 2169 } 2170 2171 /** 2172 * @return The first repetition of repeating field {@link #contact}, creating it 2173 * if it does not already exist 2174 */ 2175 public ContactDetail getContactFirstRep() { 2176 if (getContact().isEmpty()) { 2177 addContact(); 2178 } 2179 return getContact().get(0); 2180 } 2181 2182 /** 2183 * @return {@link #description} (A free text natural language description of the 2184 * evidence variable from a consumer's perspective.). This is the 2185 * underlying object with id, value and extensions. The accessor 2186 * "getDescription" gives direct access to the value 2187 */ 2188 public MarkdownType getDescriptionElement() { 2189 if (this.description == null) 2190 if (Configuration.errorOnAutoCreate()) 2191 throw new Error("Attempt to auto-create EvidenceVariable.description"); 2192 else if (Configuration.doAutoCreate()) 2193 this.description = new MarkdownType(); // bb 2194 return this.description; 2195 } 2196 2197 public boolean hasDescriptionElement() { 2198 return this.description != null && !this.description.isEmpty(); 2199 } 2200 2201 public boolean hasDescription() { 2202 return this.description != null && !this.description.isEmpty(); 2203 } 2204 2205 /** 2206 * @param value {@link #description} (A free text natural language description 2207 * of the evidence variable from a consumer's perspective.). This 2208 * is the underlying object with id, value and extensions. The 2209 * accessor "getDescription" gives direct access to the value 2210 */ 2211 public EvidenceVariable setDescriptionElement(MarkdownType value) { 2212 this.description = value; 2213 return this; 2214 } 2215 2216 /** 2217 * @return A free text natural language description of the evidence variable 2218 * from a consumer's perspective. 2219 */ 2220 public String getDescription() { 2221 return this.description == null ? null : this.description.getValue(); 2222 } 2223 2224 /** 2225 * @param value A free text natural language description of the evidence 2226 * variable from a consumer's perspective. 2227 */ 2228 public EvidenceVariable setDescription(String value) { 2229 if (value == null) 2230 this.description = null; 2231 else { 2232 if (this.description == null) 2233 this.description = new MarkdownType(); 2234 this.description.setValue(value); 2235 } 2236 return this; 2237 } 2238 2239 /** 2240 * @return {@link #note} (A human-readable string to clarify or explain concepts 2241 * about the resource.) 2242 */ 2243 public List<Annotation> getNote() { 2244 if (this.note == null) 2245 this.note = new ArrayList<Annotation>(); 2246 return this.note; 2247 } 2248 2249 /** 2250 * @return Returns a reference to <code>this</code> for easy method chaining 2251 */ 2252 public EvidenceVariable setNote(List<Annotation> theNote) { 2253 this.note = theNote; 2254 return this; 2255 } 2256 2257 public boolean hasNote() { 2258 if (this.note == null) 2259 return false; 2260 for (Annotation item : this.note) 2261 if (!item.isEmpty()) 2262 return true; 2263 return false; 2264 } 2265 2266 public Annotation addNote() { // 3 2267 Annotation t = new Annotation(); 2268 if (this.note == null) 2269 this.note = new ArrayList<Annotation>(); 2270 this.note.add(t); 2271 return t; 2272 } 2273 2274 public EvidenceVariable addNote(Annotation t) { // 3 2275 if (t == null) 2276 return this; 2277 if (this.note == null) 2278 this.note = new ArrayList<Annotation>(); 2279 this.note.add(t); 2280 return this; 2281 } 2282 2283 /** 2284 * @return The first repetition of repeating field {@link #note}, creating it if 2285 * it does not already exist 2286 */ 2287 public Annotation getNoteFirstRep() { 2288 if (getNote().isEmpty()) { 2289 addNote(); 2290 } 2291 return getNote().get(0); 2292 } 2293 2294 /** 2295 * @return {@link #useContext} (The content was developed with a focus and 2296 * intent of supporting the contexts that are listed. These contexts may 2297 * be general categories (gender, age, ...) or may be references to 2298 * specific programs (insurance plans, studies, ...) and may be used to 2299 * assist with indexing and searching for appropriate evidence variable 2300 * instances.) 2301 */ 2302 public List<UsageContext> getUseContext() { 2303 if (this.useContext == null) 2304 this.useContext = new ArrayList<UsageContext>(); 2305 return this.useContext; 2306 } 2307 2308 /** 2309 * @return Returns a reference to <code>this</code> for easy method chaining 2310 */ 2311 public EvidenceVariable setUseContext(List<UsageContext> theUseContext) { 2312 this.useContext = theUseContext; 2313 return this; 2314 } 2315 2316 public boolean hasUseContext() { 2317 if (this.useContext == null) 2318 return false; 2319 for (UsageContext item : this.useContext) 2320 if (!item.isEmpty()) 2321 return true; 2322 return false; 2323 } 2324 2325 public UsageContext addUseContext() { // 3 2326 UsageContext t = new UsageContext(); 2327 if (this.useContext == null) 2328 this.useContext = new ArrayList<UsageContext>(); 2329 this.useContext.add(t); 2330 return t; 2331 } 2332 2333 public EvidenceVariable addUseContext(UsageContext t) { // 3 2334 if (t == null) 2335 return this; 2336 if (this.useContext == null) 2337 this.useContext = new ArrayList<UsageContext>(); 2338 this.useContext.add(t); 2339 return this; 2340 } 2341 2342 /** 2343 * @return The first repetition of repeating field {@link #useContext}, creating 2344 * it if it does not already exist 2345 */ 2346 public UsageContext getUseContextFirstRep() { 2347 if (getUseContext().isEmpty()) { 2348 addUseContext(); 2349 } 2350 return getUseContext().get(0); 2351 } 2352 2353 /** 2354 * @return {@link #jurisdiction} (A legal or geographic region in which the 2355 * evidence variable is intended to be used.) 2356 */ 2357 public List<CodeableConcept> getJurisdiction() { 2358 if (this.jurisdiction == null) 2359 this.jurisdiction = new ArrayList<CodeableConcept>(); 2360 return this.jurisdiction; 2361 } 2362 2363 /** 2364 * @return Returns a reference to <code>this</code> for easy method chaining 2365 */ 2366 public EvidenceVariable setJurisdiction(List<CodeableConcept> theJurisdiction) { 2367 this.jurisdiction = theJurisdiction; 2368 return this; 2369 } 2370 2371 public boolean hasJurisdiction() { 2372 if (this.jurisdiction == null) 2373 return false; 2374 for (CodeableConcept item : this.jurisdiction) 2375 if (!item.isEmpty()) 2376 return true; 2377 return false; 2378 } 2379 2380 public CodeableConcept addJurisdiction() { // 3 2381 CodeableConcept t = new CodeableConcept(); 2382 if (this.jurisdiction == null) 2383 this.jurisdiction = new ArrayList<CodeableConcept>(); 2384 this.jurisdiction.add(t); 2385 return t; 2386 } 2387 2388 public EvidenceVariable addJurisdiction(CodeableConcept t) { // 3 2389 if (t == null) 2390 return this; 2391 if (this.jurisdiction == null) 2392 this.jurisdiction = new ArrayList<CodeableConcept>(); 2393 this.jurisdiction.add(t); 2394 return this; 2395 } 2396 2397 /** 2398 * @return The first repetition of repeating field {@link #jurisdiction}, 2399 * creating it if it does not already exist 2400 */ 2401 public CodeableConcept getJurisdictionFirstRep() { 2402 if (getJurisdiction().isEmpty()) { 2403 addJurisdiction(); 2404 } 2405 return getJurisdiction().get(0); 2406 } 2407 2408 /** 2409 * @return {@link #copyright} (A copyright statement relating to the evidence 2410 * variable and/or its contents. Copyright statements are generally 2411 * legal restrictions on the use and publishing of the evidence 2412 * variable.). This is the underlying object with id, value and 2413 * extensions. The accessor "getCopyright" gives direct access to the 2414 * value 2415 */ 2416 public MarkdownType getCopyrightElement() { 2417 if (this.copyright == null) 2418 if (Configuration.errorOnAutoCreate()) 2419 throw new Error("Attempt to auto-create EvidenceVariable.copyright"); 2420 else if (Configuration.doAutoCreate()) 2421 this.copyright = new MarkdownType(); // bb 2422 return this.copyright; 2423 } 2424 2425 public boolean hasCopyrightElement() { 2426 return this.copyright != null && !this.copyright.isEmpty(); 2427 } 2428 2429 public boolean hasCopyright() { 2430 return this.copyright != null && !this.copyright.isEmpty(); 2431 } 2432 2433 /** 2434 * @param value {@link #copyright} (A copyright statement relating to the 2435 * evidence variable and/or its contents. Copyright statements are 2436 * generally legal restrictions on the use and publishing of the 2437 * evidence variable.). This is the underlying object with id, 2438 * value and extensions. The accessor "getCopyright" gives direct 2439 * access to the value 2440 */ 2441 public EvidenceVariable setCopyrightElement(MarkdownType value) { 2442 this.copyright = value; 2443 return this; 2444 } 2445 2446 /** 2447 * @return A copyright statement relating to the evidence variable and/or its 2448 * contents. Copyright statements are generally legal restrictions on 2449 * the use and publishing of the evidence variable. 2450 */ 2451 public String getCopyright() { 2452 return this.copyright == null ? null : this.copyright.getValue(); 2453 } 2454 2455 /** 2456 * @param value A copyright statement relating to the evidence variable and/or 2457 * its contents. Copyright statements are generally legal 2458 * restrictions on the use and publishing of the evidence variable. 2459 */ 2460 public EvidenceVariable setCopyright(String value) { 2461 if (value == null) 2462 this.copyright = null; 2463 else { 2464 if (this.copyright == null) 2465 this.copyright = new MarkdownType(); 2466 this.copyright.setValue(value); 2467 } 2468 return this; 2469 } 2470 2471 /** 2472 * @return {@link #approvalDate} (The date on which the resource content was 2473 * approved by the publisher. Approval happens once when the content is 2474 * officially approved for usage.). This is the underlying object with 2475 * id, value and extensions. The accessor "getApprovalDate" gives direct 2476 * access to the value 2477 */ 2478 public DateType getApprovalDateElement() { 2479 if (this.approvalDate == null) 2480 if (Configuration.errorOnAutoCreate()) 2481 throw new Error("Attempt to auto-create EvidenceVariable.approvalDate"); 2482 else if (Configuration.doAutoCreate()) 2483 this.approvalDate = new DateType(); // bb 2484 return this.approvalDate; 2485 } 2486 2487 public boolean hasApprovalDateElement() { 2488 return this.approvalDate != null && !this.approvalDate.isEmpty(); 2489 } 2490 2491 public boolean hasApprovalDate() { 2492 return this.approvalDate != null && !this.approvalDate.isEmpty(); 2493 } 2494 2495 /** 2496 * @param value {@link #approvalDate} (The date on which the resource content 2497 * was approved by the publisher. Approval happens once when the 2498 * content is officially approved for usage.). This is the 2499 * underlying object with id, value and extensions. The accessor 2500 * "getApprovalDate" gives direct access to the value 2501 */ 2502 public EvidenceVariable setApprovalDateElement(DateType value) { 2503 this.approvalDate = value; 2504 return this; 2505 } 2506 2507 /** 2508 * @return The date on which the resource content was approved by the publisher. 2509 * Approval happens once when the content is officially approved for 2510 * usage. 2511 */ 2512 public Date getApprovalDate() { 2513 return this.approvalDate == null ? null : this.approvalDate.getValue(); 2514 } 2515 2516 /** 2517 * @param value The date on which the resource content was approved by the 2518 * publisher. Approval happens once when the content is officially 2519 * approved for usage. 2520 */ 2521 public EvidenceVariable setApprovalDate(Date value) { 2522 if (value == null) 2523 this.approvalDate = null; 2524 else { 2525 if (this.approvalDate == null) 2526 this.approvalDate = new DateType(); 2527 this.approvalDate.setValue(value); 2528 } 2529 return this; 2530 } 2531 2532 /** 2533 * @return {@link #lastReviewDate} (The date on which the resource content was 2534 * last reviewed. Review happens periodically after approval but does 2535 * not change the original approval date.). This is the underlying 2536 * object with id, value and extensions. The accessor 2537 * "getLastReviewDate" gives direct access to the value 2538 */ 2539 public DateType getLastReviewDateElement() { 2540 if (this.lastReviewDate == null) 2541 if (Configuration.errorOnAutoCreate()) 2542 throw new Error("Attempt to auto-create EvidenceVariable.lastReviewDate"); 2543 else if (Configuration.doAutoCreate()) 2544 this.lastReviewDate = new DateType(); // bb 2545 return this.lastReviewDate; 2546 } 2547 2548 public boolean hasLastReviewDateElement() { 2549 return this.lastReviewDate != null && !this.lastReviewDate.isEmpty(); 2550 } 2551 2552 public boolean hasLastReviewDate() { 2553 return this.lastReviewDate != null && !this.lastReviewDate.isEmpty(); 2554 } 2555 2556 /** 2557 * @param value {@link #lastReviewDate} (The date on which the resource content 2558 * was last reviewed. Review happens periodically after approval 2559 * but does not change the original approval date.). This is the 2560 * underlying object with id, value and extensions. The accessor 2561 * "getLastReviewDate" gives direct access to the value 2562 */ 2563 public EvidenceVariable setLastReviewDateElement(DateType value) { 2564 this.lastReviewDate = value; 2565 return this; 2566 } 2567 2568 /** 2569 * @return The date on which the resource content was last reviewed. Review 2570 * happens periodically after approval but does not change the original 2571 * approval date. 2572 */ 2573 public Date getLastReviewDate() { 2574 return this.lastReviewDate == null ? null : this.lastReviewDate.getValue(); 2575 } 2576 2577 /** 2578 * @param value The date on which the resource content was last reviewed. Review 2579 * happens periodically after approval but does not change the 2580 * original approval date. 2581 */ 2582 public EvidenceVariable setLastReviewDate(Date value) { 2583 if (value == null) 2584 this.lastReviewDate = null; 2585 else { 2586 if (this.lastReviewDate == null) 2587 this.lastReviewDate = new DateType(); 2588 this.lastReviewDate.setValue(value); 2589 } 2590 return this; 2591 } 2592 2593 /** 2594 * @return {@link #effectivePeriod} (The period during which the evidence 2595 * variable content was or is planned to be in active use.) 2596 */ 2597 public Period getEffectivePeriod() { 2598 if (this.effectivePeriod == null) 2599 if (Configuration.errorOnAutoCreate()) 2600 throw new Error("Attempt to auto-create EvidenceVariable.effectivePeriod"); 2601 else if (Configuration.doAutoCreate()) 2602 this.effectivePeriod = new Period(); // cc 2603 return this.effectivePeriod; 2604 } 2605 2606 public boolean hasEffectivePeriod() { 2607 return this.effectivePeriod != null && !this.effectivePeriod.isEmpty(); 2608 } 2609 2610 /** 2611 * @param value {@link #effectivePeriod} (The period during which the evidence 2612 * variable content was or is planned to be in active use.) 2613 */ 2614 public EvidenceVariable setEffectivePeriod(Period value) { 2615 this.effectivePeriod = value; 2616 return this; 2617 } 2618 2619 /** 2620 * @return {@link #topic} (Descriptive topics related to the content of the 2621 * EvidenceVariable. Topics provide a high-level categorization grouping 2622 * types of EvidenceVariables that can be useful for filtering and 2623 * searching.) 2624 */ 2625 public List<CodeableConcept> getTopic() { 2626 if (this.topic == null) 2627 this.topic = new ArrayList<CodeableConcept>(); 2628 return this.topic; 2629 } 2630 2631 /** 2632 * @return Returns a reference to <code>this</code> for easy method chaining 2633 */ 2634 public EvidenceVariable setTopic(List<CodeableConcept> theTopic) { 2635 this.topic = theTopic; 2636 return this; 2637 } 2638 2639 public boolean hasTopic() { 2640 if (this.topic == null) 2641 return false; 2642 for (CodeableConcept item : this.topic) 2643 if (!item.isEmpty()) 2644 return true; 2645 return false; 2646 } 2647 2648 public CodeableConcept addTopic() { // 3 2649 CodeableConcept t = new CodeableConcept(); 2650 if (this.topic == null) 2651 this.topic = new ArrayList<CodeableConcept>(); 2652 this.topic.add(t); 2653 return t; 2654 } 2655 2656 public EvidenceVariable addTopic(CodeableConcept t) { // 3 2657 if (t == null) 2658 return this; 2659 if (this.topic == null) 2660 this.topic = new ArrayList<CodeableConcept>(); 2661 this.topic.add(t); 2662 return this; 2663 } 2664 2665 /** 2666 * @return The first repetition of repeating field {@link #topic}, creating it 2667 * if it does not already exist 2668 */ 2669 public CodeableConcept getTopicFirstRep() { 2670 if (getTopic().isEmpty()) { 2671 addTopic(); 2672 } 2673 return getTopic().get(0); 2674 } 2675 2676 /** 2677 * @return {@link #author} (An individiual or organization primarily involved in 2678 * the creation and maintenance of the content.) 2679 */ 2680 public List<ContactDetail> getAuthor() { 2681 if (this.author == null) 2682 this.author = new ArrayList<ContactDetail>(); 2683 return this.author; 2684 } 2685 2686 /** 2687 * @return Returns a reference to <code>this</code> for easy method chaining 2688 */ 2689 public EvidenceVariable setAuthor(List<ContactDetail> theAuthor) { 2690 this.author = theAuthor; 2691 return this; 2692 } 2693 2694 public boolean hasAuthor() { 2695 if (this.author == null) 2696 return false; 2697 for (ContactDetail item : this.author) 2698 if (!item.isEmpty()) 2699 return true; 2700 return false; 2701 } 2702 2703 public ContactDetail addAuthor() { // 3 2704 ContactDetail t = new ContactDetail(); 2705 if (this.author == null) 2706 this.author = new ArrayList<ContactDetail>(); 2707 this.author.add(t); 2708 return t; 2709 } 2710 2711 public EvidenceVariable addAuthor(ContactDetail t) { // 3 2712 if (t == null) 2713 return this; 2714 if (this.author == null) 2715 this.author = new ArrayList<ContactDetail>(); 2716 this.author.add(t); 2717 return this; 2718 } 2719 2720 /** 2721 * @return The first repetition of repeating field {@link #author}, creating it 2722 * if it does not already exist 2723 */ 2724 public ContactDetail getAuthorFirstRep() { 2725 if (getAuthor().isEmpty()) { 2726 addAuthor(); 2727 } 2728 return getAuthor().get(0); 2729 } 2730 2731 /** 2732 * @return {@link #editor} (An individual or organization primarily responsible 2733 * for internal coherence of the content.) 2734 */ 2735 public List<ContactDetail> getEditor() { 2736 if (this.editor == null) 2737 this.editor = new ArrayList<ContactDetail>(); 2738 return this.editor; 2739 } 2740 2741 /** 2742 * @return Returns a reference to <code>this</code> for easy method chaining 2743 */ 2744 public EvidenceVariable setEditor(List<ContactDetail> theEditor) { 2745 this.editor = theEditor; 2746 return this; 2747 } 2748 2749 public boolean hasEditor() { 2750 if (this.editor == null) 2751 return false; 2752 for (ContactDetail item : this.editor) 2753 if (!item.isEmpty()) 2754 return true; 2755 return false; 2756 } 2757 2758 public ContactDetail addEditor() { // 3 2759 ContactDetail t = new ContactDetail(); 2760 if (this.editor == null) 2761 this.editor = new ArrayList<ContactDetail>(); 2762 this.editor.add(t); 2763 return t; 2764 } 2765 2766 public EvidenceVariable addEditor(ContactDetail t) { // 3 2767 if (t == null) 2768 return this; 2769 if (this.editor == null) 2770 this.editor = new ArrayList<ContactDetail>(); 2771 this.editor.add(t); 2772 return this; 2773 } 2774 2775 /** 2776 * @return The first repetition of repeating field {@link #editor}, creating it 2777 * if it does not already exist 2778 */ 2779 public ContactDetail getEditorFirstRep() { 2780 if (getEditor().isEmpty()) { 2781 addEditor(); 2782 } 2783 return getEditor().get(0); 2784 } 2785 2786 /** 2787 * @return {@link #reviewer} (An individual or organization primarily 2788 * responsible for review of some aspect of the content.) 2789 */ 2790 public List<ContactDetail> getReviewer() { 2791 if (this.reviewer == null) 2792 this.reviewer = new ArrayList<ContactDetail>(); 2793 return this.reviewer; 2794 } 2795 2796 /** 2797 * @return Returns a reference to <code>this</code> for easy method chaining 2798 */ 2799 public EvidenceVariable setReviewer(List<ContactDetail> theReviewer) { 2800 this.reviewer = theReviewer; 2801 return this; 2802 } 2803 2804 public boolean hasReviewer() { 2805 if (this.reviewer == null) 2806 return false; 2807 for (ContactDetail item : this.reviewer) 2808 if (!item.isEmpty()) 2809 return true; 2810 return false; 2811 } 2812 2813 public ContactDetail addReviewer() { // 3 2814 ContactDetail t = new ContactDetail(); 2815 if (this.reviewer == null) 2816 this.reviewer = new ArrayList<ContactDetail>(); 2817 this.reviewer.add(t); 2818 return t; 2819 } 2820 2821 public EvidenceVariable addReviewer(ContactDetail t) { // 3 2822 if (t == null) 2823 return this; 2824 if (this.reviewer == null) 2825 this.reviewer = new ArrayList<ContactDetail>(); 2826 this.reviewer.add(t); 2827 return this; 2828 } 2829 2830 /** 2831 * @return The first repetition of repeating field {@link #reviewer}, creating 2832 * it if it does not already exist 2833 */ 2834 public ContactDetail getReviewerFirstRep() { 2835 if (getReviewer().isEmpty()) { 2836 addReviewer(); 2837 } 2838 return getReviewer().get(0); 2839 } 2840 2841 /** 2842 * @return {@link #endorser} (An individual or organization responsible for 2843 * officially endorsing the content for use in some setting.) 2844 */ 2845 public List<ContactDetail> getEndorser() { 2846 if (this.endorser == null) 2847 this.endorser = new ArrayList<ContactDetail>(); 2848 return this.endorser; 2849 } 2850 2851 /** 2852 * @return Returns a reference to <code>this</code> for easy method chaining 2853 */ 2854 public EvidenceVariable setEndorser(List<ContactDetail> theEndorser) { 2855 this.endorser = theEndorser; 2856 return this; 2857 } 2858 2859 public boolean hasEndorser() { 2860 if (this.endorser == null) 2861 return false; 2862 for (ContactDetail item : this.endorser) 2863 if (!item.isEmpty()) 2864 return true; 2865 return false; 2866 } 2867 2868 public ContactDetail addEndorser() { // 3 2869 ContactDetail t = new ContactDetail(); 2870 if (this.endorser == null) 2871 this.endorser = new ArrayList<ContactDetail>(); 2872 this.endorser.add(t); 2873 return t; 2874 } 2875 2876 public EvidenceVariable addEndorser(ContactDetail t) { // 3 2877 if (t == null) 2878 return this; 2879 if (this.endorser == null) 2880 this.endorser = new ArrayList<ContactDetail>(); 2881 this.endorser.add(t); 2882 return this; 2883 } 2884 2885 /** 2886 * @return The first repetition of repeating field {@link #endorser}, creating 2887 * it if it does not already exist 2888 */ 2889 public ContactDetail getEndorserFirstRep() { 2890 if (getEndorser().isEmpty()) { 2891 addEndorser(); 2892 } 2893 return getEndorser().get(0); 2894 } 2895 2896 /** 2897 * @return {@link #relatedArtifact} (Related artifacts such as additional 2898 * documentation, justification, or bibliographic references.) 2899 */ 2900 public List<RelatedArtifact> getRelatedArtifact() { 2901 if (this.relatedArtifact == null) 2902 this.relatedArtifact = new ArrayList<RelatedArtifact>(); 2903 return this.relatedArtifact; 2904 } 2905 2906 /** 2907 * @return Returns a reference to <code>this</code> for easy method chaining 2908 */ 2909 public EvidenceVariable setRelatedArtifact(List<RelatedArtifact> theRelatedArtifact) { 2910 this.relatedArtifact = theRelatedArtifact; 2911 return this; 2912 } 2913 2914 public boolean hasRelatedArtifact() { 2915 if (this.relatedArtifact == null) 2916 return false; 2917 for (RelatedArtifact item : this.relatedArtifact) 2918 if (!item.isEmpty()) 2919 return true; 2920 return false; 2921 } 2922 2923 public RelatedArtifact addRelatedArtifact() { // 3 2924 RelatedArtifact t = new RelatedArtifact(); 2925 if (this.relatedArtifact == null) 2926 this.relatedArtifact = new ArrayList<RelatedArtifact>(); 2927 this.relatedArtifact.add(t); 2928 return t; 2929 } 2930 2931 public EvidenceVariable addRelatedArtifact(RelatedArtifact t) { // 3 2932 if (t == null) 2933 return this; 2934 if (this.relatedArtifact == null) 2935 this.relatedArtifact = new ArrayList<RelatedArtifact>(); 2936 this.relatedArtifact.add(t); 2937 return this; 2938 } 2939 2940 /** 2941 * @return The first repetition of repeating field {@link #relatedArtifact}, 2942 * creating it if it does not already exist 2943 */ 2944 public RelatedArtifact getRelatedArtifactFirstRep() { 2945 if (getRelatedArtifact().isEmpty()) { 2946 addRelatedArtifact(); 2947 } 2948 return getRelatedArtifact().get(0); 2949 } 2950 2951 /** 2952 * @return {@link #type} (The type of evidence element, a population, an 2953 * exposure, or an outcome.). This is the underlying object with id, 2954 * value and extensions. The accessor "getType" gives direct access to 2955 * the value 2956 */ 2957 public Enumeration<EvidenceVariableType> getTypeElement() { 2958 if (this.type == null) 2959 if (Configuration.errorOnAutoCreate()) 2960 throw new Error("Attempt to auto-create EvidenceVariable.type"); 2961 else if (Configuration.doAutoCreate()) 2962 this.type = new Enumeration<EvidenceVariableType>(new EvidenceVariableTypeEnumFactory()); // bb 2963 return this.type; 2964 } 2965 2966 public boolean hasTypeElement() { 2967 return this.type != null && !this.type.isEmpty(); 2968 } 2969 2970 public boolean hasType() { 2971 return this.type != null && !this.type.isEmpty(); 2972 } 2973 2974 /** 2975 * @param value {@link #type} (The type of evidence element, a population, an 2976 * exposure, or an outcome.). This is the underlying object with 2977 * id, value and extensions. The accessor "getType" gives direct 2978 * access to the value 2979 */ 2980 public EvidenceVariable setTypeElement(Enumeration<EvidenceVariableType> value) { 2981 this.type = value; 2982 return this; 2983 } 2984 2985 /** 2986 * @return The type of evidence element, a population, an exposure, or an 2987 * outcome. 2988 */ 2989 public EvidenceVariableType getType() { 2990 return this.type == null ? null : this.type.getValue(); 2991 } 2992 2993 /** 2994 * @param value The type of evidence element, a population, an exposure, or an 2995 * outcome. 2996 */ 2997 public EvidenceVariable setType(EvidenceVariableType value) { 2998 if (value == null) 2999 this.type = null; 3000 else { 3001 if (this.type == null) 3002 this.type = new Enumeration<EvidenceVariableType>(new EvidenceVariableTypeEnumFactory()); 3003 this.type.setValue(value); 3004 } 3005 return this; 3006 } 3007 3008 /** 3009 * @return {@link #characteristic} (A characteristic that defines the members of 3010 * the evidence element. Multiple characteristics are applied with "and" 3011 * semantics.) 3012 */ 3013 public List<EvidenceVariableCharacteristicComponent> getCharacteristic() { 3014 if (this.characteristic == null) 3015 this.characteristic = new ArrayList<EvidenceVariableCharacteristicComponent>(); 3016 return this.characteristic; 3017 } 3018 3019 /** 3020 * @return Returns a reference to <code>this</code> for easy method chaining 3021 */ 3022 public EvidenceVariable setCharacteristic(List<EvidenceVariableCharacteristicComponent> theCharacteristic) { 3023 this.characteristic = theCharacteristic; 3024 return this; 3025 } 3026 3027 public boolean hasCharacteristic() { 3028 if (this.characteristic == null) 3029 return false; 3030 for (EvidenceVariableCharacteristicComponent item : this.characteristic) 3031 if (!item.isEmpty()) 3032 return true; 3033 return false; 3034 } 3035 3036 public EvidenceVariableCharacteristicComponent addCharacteristic() { // 3 3037 EvidenceVariableCharacteristicComponent t = new EvidenceVariableCharacteristicComponent(); 3038 if (this.characteristic == null) 3039 this.characteristic = new ArrayList<EvidenceVariableCharacteristicComponent>(); 3040 this.characteristic.add(t); 3041 return t; 3042 } 3043 3044 public EvidenceVariable addCharacteristic(EvidenceVariableCharacteristicComponent t) { // 3 3045 if (t == null) 3046 return this; 3047 if (this.characteristic == null) 3048 this.characteristic = new ArrayList<EvidenceVariableCharacteristicComponent>(); 3049 this.characteristic.add(t); 3050 return this; 3051 } 3052 3053 /** 3054 * @return The first repetition of repeating field {@link #characteristic}, 3055 * creating it if it does not already exist 3056 */ 3057 public EvidenceVariableCharacteristicComponent getCharacteristicFirstRep() { 3058 if (getCharacteristic().isEmpty()) { 3059 addCharacteristic(); 3060 } 3061 return getCharacteristic().get(0); 3062 } 3063 3064 protected void listChildren(List<Property> children) { 3065 super.listChildren(children); 3066 children.add(new Property("url", "uri", 3067 "An absolute URI that is used to identify this evidence variable when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this evidence variable is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the evidence variable is stored on different servers.", 3068 0, 1, url)); 3069 children.add(new Property("identifier", "Identifier", 3070 "A formal identifier that is used to identify this evidence variable when it is represented in other formats, or referenced in a specification, model, design or an instance.", 3071 0, java.lang.Integer.MAX_VALUE, identifier)); 3072 children.add(new Property("version", "string", 3073 "The identifier that is used to identify this version of the evidence variable when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the evidence variable author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge assets, refer to the Decision Support Service specification. Note that a version is required for non-experimental active artifacts.", 3074 0, 1, version)); 3075 children.add(new Property("name", "string", 3076 "A natural language name identifying the evidence variable. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 3077 0, 1, name)); 3078 children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the evidence variable.", 3079 0, 1, title)); 3080 children.add(new Property("shortTitle", "string", 3081 "The short title provides an alternate title for use in informal descriptive contexts where the full, formal title is not necessary.", 3082 0, 1, shortTitle)); 3083 children.add(new Property("subtitle", "string", 3084 "An explanatory or alternate title for the EvidenceVariable giving additional information about its content.", 3085 0, 1, subtitle)); 3086 children.add(new Property("status", "code", 3087 "The status of this evidence variable. Enables tracking the life-cycle of the content.", 0, 1, status)); 3088 children.add(new Property("date", "dateTime", 3089 "The date (and optionally time) when the evidence variable was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the evidence variable changes.", 3090 0, 1, date)); 3091 children.add(new Property("publisher", "string", 3092 "The name of the organization or individual that published the evidence variable.", 0, 1, publisher)); 3093 children.add(new Property("contact", "ContactDetail", 3094 "Contact details to assist a user in finding and communicating with the publisher.", 0, 3095 java.lang.Integer.MAX_VALUE, contact)); 3096 children.add(new Property("description", "markdown", 3097 "A free text natural language description of the evidence variable from a consumer's perspective.", 0, 1, 3098 description)); 3099 children.add( 3100 new Property("note", "Annotation", "A human-readable string to clarify or explain concepts about the resource.", 3101 0, java.lang.Integer.MAX_VALUE, note)); 3102 children.add(new Property("useContext", "UsageContext", 3103 "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate evidence variable instances.", 3104 0, java.lang.Integer.MAX_VALUE, useContext)); 3105 children.add(new Property("jurisdiction", "CodeableConcept", 3106 "A legal or geographic region in which the evidence variable is intended to be used.", 0, 3107 java.lang.Integer.MAX_VALUE, jurisdiction)); 3108 children.add(new Property("copyright", "markdown", 3109 "A copyright statement relating to the evidence variable and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the evidence variable.", 3110 0, 1, copyright)); 3111 children.add(new Property("approvalDate", "date", 3112 "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.", 3113 0, 1, approvalDate)); 3114 children.add(new Property("lastReviewDate", "date", 3115 "The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date.", 3116 0, 1, lastReviewDate)); 3117 children.add(new Property("effectivePeriod", "Period", 3118 "The period during which the evidence variable content was or is planned to be in active use.", 0, 1, 3119 effectivePeriod)); 3120 children.add(new Property("topic", "CodeableConcept", 3121 "Descriptive topics related to the content of the EvidenceVariable. Topics provide a high-level categorization grouping types of EvidenceVariables that can be useful for filtering and searching.", 3122 0, java.lang.Integer.MAX_VALUE, topic)); 3123 children.add(new Property("author", "ContactDetail", 3124 "An individiual or organization primarily involved in the creation and maintenance of the content.", 0, 3125 java.lang.Integer.MAX_VALUE, author)); 3126 children.add(new Property("editor", "ContactDetail", 3127 "An individual or organization primarily responsible for internal coherence of the content.", 0, 3128 java.lang.Integer.MAX_VALUE, editor)); 3129 children.add(new Property("reviewer", "ContactDetail", 3130 "An individual or organization primarily responsible for review of some aspect of the content.", 0, 3131 java.lang.Integer.MAX_VALUE, reviewer)); 3132 children.add(new Property("endorser", "ContactDetail", 3133 "An individual or organization responsible for officially endorsing the content for use in some setting.", 0, 3134 java.lang.Integer.MAX_VALUE, endorser)); 3135 children.add(new Property("relatedArtifact", "RelatedArtifact", 3136 "Related artifacts such as additional documentation, justification, or bibliographic references.", 0, 3137 java.lang.Integer.MAX_VALUE, relatedArtifact)); 3138 children.add(new Property("type", "code", "The type of evidence element, a population, an exposure, or an outcome.", 3139 0, 1, type)); 3140 children.add(new Property("characteristic", "", 3141 "A characteristic that defines the members of the evidence element. Multiple characteristics are applied with \"and\" semantics.", 3142 0, java.lang.Integer.MAX_VALUE, characteristic)); 3143 } 3144 3145 @Override 3146 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3147 switch (_hash) { 3148 case 116079: 3149 /* url */ return new Property("url", "uri", 3150 "An absolute URI that is used to identify this evidence variable when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this evidence variable is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the evidence variable is stored on different servers.", 3151 0, 1, url); 3152 case -1618432855: 3153 /* identifier */ return new Property("identifier", "Identifier", 3154 "A formal identifier that is used to identify this evidence variable when it is represented in other formats, or referenced in a specification, model, design or an instance.", 3155 0, java.lang.Integer.MAX_VALUE, identifier); 3156 case 351608024: 3157 /* version */ return new Property("version", "string", 3158 "The identifier that is used to identify this version of the evidence variable when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the evidence variable author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge assets, refer to the Decision Support Service specification. Note that a version is required for non-experimental active artifacts.", 3159 0, 1, version); 3160 case 3373707: 3161 /* name */ return new Property("name", "string", 3162 "A natural language name identifying the evidence variable. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 3163 0, 1, name); 3164 case 110371416: 3165 /* title */ return new Property("title", "string", 3166 "A short, descriptive, user-friendly title for the evidence variable.", 0, 1, title); 3167 case 1555503932: 3168 /* shortTitle */ return new Property("shortTitle", "string", 3169 "The short title provides an alternate title for use in informal descriptive contexts where the full, formal title is not necessary.", 3170 0, 1, shortTitle); 3171 case -2060497896: 3172 /* subtitle */ return new Property("subtitle", "string", 3173 "An explanatory or alternate title for the EvidenceVariable giving additional information about its content.", 3174 0, 1, subtitle); 3175 case -892481550: 3176 /* status */ return new Property("status", "code", 3177 "The status of this evidence variable. Enables tracking the life-cycle of the content.", 0, 1, status); 3178 case 3076014: 3179 /* date */ return new Property("date", "dateTime", 3180 "The date (and optionally time) when the evidence variable was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the evidence variable changes.", 3181 0, 1, date); 3182 case 1447404028: 3183 /* publisher */ return new Property("publisher", "string", 3184 "The name of the organization or individual that published the evidence variable.", 0, 1, publisher); 3185 case 951526432: 3186 /* contact */ return new Property("contact", "ContactDetail", 3187 "Contact details to assist a user in finding and communicating with the publisher.", 0, 3188 java.lang.Integer.MAX_VALUE, contact); 3189 case -1724546052: 3190 /* description */ return new Property("description", "markdown", 3191 "A free text natural language description of the evidence variable from a consumer's perspective.", 0, 1, 3192 description); 3193 case 3387378: 3194 /* note */ return new Property("note", "Annotation", 3195 "A human-readable string to clarify or explain concepts about the resource.", 0, java.lang.Integer.MAX_VALUE, 3196 note); 3197 case -669707736: 3198 /* useContext */ return new Property("useContext", "UsageContext", 3199 "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate evidence variable instances.", 3200 0, java.lang.Integer.MAX_VALUE, useContext); 3201 case -507075711: 3202 /* jurisdiction */ return new Property("jurisdiction", "CodeableConcept", 3203 "A legal or geographic region in which the evidence variable is intended to be used.", 0, 3204 java.lang.Integer.MAX_VALUE, jurisdiction); 3205 case 1522889671: 3206 /* copyright */ return new Property("copyright", "markdown", 3207 "A copyright statement relating to the evidence variable and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the evidence variable.", 3208 0, 1, copyright); 3209 case 223539345: 3210 /* approvalDate */ return new Property("approvalDate", "date", 3211 "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.", 3212 0, 1, approvalDate); 3213 case -1687512484: 3214 /* lastReviewDate */ return new Property("lastReviewDate", "date", 3215 "The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date.", 3216 0, 1, lastReviewDate); 3217 case -403934648: 3218 /* effectivePeriod */ return new Property("effectivePeriod", "Period", 3219 "The period during which the evidence variable content was or is planned to be in active use.", 0, 1, 3220 effectivePeriod); 3221 case 110546223: 3222 /* topic */ return new Property("topic", "CodeableConcept", 3223 "Descriptive topics related to the content of the EvidenceVariable. Topics provide a high-level categorization grouping types of EvidenceVariables that can be useful for filtering and searching.", 3224 0, java.lang.Integer.MAX_VALUE, topic); 3225 case -1406328437: 3226 /* author */ return new Property("author", "ContactDetail", 3227 "An individiual or organization primarily involved in the creation and maintenance of the content.", 0, 3228 java.lang.Integer.MAX_VALUE, author); 3229 case -1307827859: 3230 /* editor */ return new Property("editor", "ContactDetail", 3231 "An individual or organization primarily responsible for internal coherence of the content.", 0, 3232 java.lang.Integer.MAX_VALUE, editor); 3233 case -261190139: 3234 /* reviewer */ return new Property("reviewer", "ContactDetail", 3235 "An individual or organization primarily responsible for review of some aspect of the content.", 0, 3236 java.lang.Integer.MAX_VALUE, reviewer); 3237 case 1740277666: 3238 /* endorser */ return new Property("endorser", "ContactDetail", 3239 "An individual or organization responsible for officially endorsing the content for use in some setting.", 0, 3240 java.lang.Integer.MAX_VALUE, endorser); 3241 case 666807069: 3242 /* relatedArtifact */ return new Property("relatedArtifact", "RelatedArtifact", 3243 "Related artifacts such as additional documentation, justification, or bibliographic references.", 0, 3244 java.lang.Integer.MAX_VALUE, relatedArtifact); 3245 case 3575610: 3246 /* type */ return new Property("type", "code", 3247 "The type of evidence element, a population, an exposure, or an outcome.", 0, 1, type); 3248 case 366313883: 3249 /* characteristic */ return new Property("characteristic", "", 3250 "A characteristic that defines the members of the evidence element. Multiple characteristics are applied with \"and\" semantics.", 3251 0, java.lang.Integer.MAX_VALUE, characteristic); 3252 default: 3253 return super.getNamedProperty(_hash, _name, _checkValid); 3254 } 3255 3256 } 3257 3258 @Override 3259 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3260 switch (hash) { 3261 case 116079: 3262 /* url */ return this.url == null ? new Base[0] : new Base[] { this.url }; // UriType 3263 case -1618432855: 3264 /* identifier */ return this.identifier == null ? new Base[0] 3265 : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 3266 case 351608024: 3267 /* version */ return this.version == null ? new Base[0] : new Base[] { this.version }; // StringType 3268 case 3373707: 3269 /* name */ return this.name == null ? new Base[0] : new Base[] { this.name }; // StringType 3270 case 110371416: 3271 /* title */ return this.title == null ? new Base[0] : new Base[] { this.title }; // StringType 3272 case 1555503932: 3273 /* shortTitle */ return this.shortTitle == null ? new Base[0] : new Base[] { this.shortTitle }; // StringType 3274 case -2060497896: 3275 /* subtitle */ return this.subtitle == null ? new Base[0] : new Base[] { this.subtitle }; // StringType 3276 case -892481550: 3277 /* status */ return this.status == null ? new Base[0] : new Base[] { this.status }; // Enumeration<PublicationStatus> 3278 case 3076014: 3279 /* date */ return this.date == null ? new Base[0] : new Base[] { this.date }; // DateTimeType 3280 case 1447404028: 3281 /* publisher */ return this.publisher == null ? new Base[0] : new Base[] { this.publisher }; // StringType 3282 case 951526432: 3283 /* contact */ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 3284 case -1724546052: 3285 /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // MarkdownType 3286 case 3387378: 3287 /* note */ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation 3288 case -669707736: 3289 /* useContext */ return this.useContext == null ? new Base[0] 3290 : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 3291 case -507075711: 3292 /* jurisdiction */ return this.jurisdiction == null ? new Base[0] 3293 : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 3294 case 1522889671: 3295 /* copyright */ return this.copyright == null ? new Base[0] : new Base[] { this.copyright }; // MarkdownType 3296 case 223539345: 3297 /* approvalDate */ return this.approvalDate == null ? new Base[0] : new Base[] { this.approvalDate }; // DateType 3298 case -1687512484: 3299 /* lastReviewDate */ return this.lastReviewDate == null ? new Base[0] : new Base[] { this.lastReviewDate }; // DateType 3300 case -403934648: 3301 /* effectivePeriod */ return this.effectivePeriod == null ? new Base[0] : new Base[] { this.effectivePeriod }; // Period 3302 case 110546223: 3303 /* topic */ return this.topic == null ? new Base[0] : this.topic.toArray(new Base[this.topic.size()]); // CodeableConcept 3304 case -1406328437: 3305 /* author */ return this.author == null ? new Base[0] : this.author.toArray(new Base[this.author.size()]); // ContactDetail 3306 case -1307827859: 3307 /* editor */ return this.editor == null ? new Base[0] : this.editor.toArray(new Base[this.editor.size()]); // ContactDetail 3308 case -261190139: 3309 /* reviewer */ return this.reviewer == null ? new Base[0] : this.reviewer.toArray(new Base[this.reviewer.size()]); // ContactDetail 3310 case 1740277666: 3311 /* endorser */ return this.endorser == null ? new Base[0] : this.endorser.toArray(new Base[this.endorser.size()]); // ContactDetail 3312 case 666807069: 3313 /* relatedArtifact */ return this.relatedArtifact == null ? new Base[0] 3314 : this.relatedArtifact.toArray(new Base[this.relatedArtifact.size()]); // RelatedArtifact 3315 case 3575610: 3316 /* type */ return this.type == null ? new Base[0] : new Base[] { this.type }; // Enumeration<EvidenceVariableType> 3317 case 366313883: 3318 /* characteristic */ return this.characteristic == null ? new Base[0] 3319 : this.characteristic.toArray(new Base[this.characteristic.size()]); // EvidenceVariableCharacteristicComponent 3320 default: 3321 return super.getProperty(hash, name, checkValid); 3322 } 3323 3324 } 3325 3326 @Override 3327 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3328 switch (hash) { 3329 case 116079: // url 3330 this.url = castToUri(value); // UriType 3331 return value; 3332 case -1618432855: // identifier 3333 this.getIdentifier().add(castToIdentifier(value)); // Identifier 3334 return value; 3335 case 351608024: // version 3336 this.version = castToString(value); // StringType 3337 return value; 3338 case 3373707: // name 3339 this.name = castToString(value); // StringType 3340 return value; 3341 case 110371416: // title 3342 this.title = castToString(value); // StringType 3343 return value; 3344 case 1555503932: // shortTitle 3345 this.shortTitle = castToString(value); // StringType 3346 return value; 3347 case -2060497896: // subtitle 3348 this.subtitle = castToString(value); // StringType 3349 return value; 3350 case -892481550: // status 3351 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 3352 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 3353 return value; 3354 case 3076014: // date 3355 this.date = castToDateTime(value); // DateTimeType 3356 return value; 3357 case 1447404028: // publisher 3358 this.publisher = castToString(value); // StringType 3359 return value; 3360 case 951526432: // contact 3361 this.getContact().add(castToContactDetail(value)); // ContactDetail 3362 return value; 3363 case -1724546052: // description 3364 this.description = castToMarkdown(value); // MarkdownType 3365 return value; 3366 case 3387378: // note 3367 this.getNote().add(castToAnnotation(value)); // Annotation 3368 return value; 3369 case -669707736: // useContext 3370 this.getUseContext().add(castToUsageContext(value)); // UsageContext 3371 return value; 3372 case -507075711: // jurisdiction 3373 this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept 3374 return value; 3375 case 1522889671: // copyright 3376 this.copyright = castToMarkdown(value); // MarkdownType 3377 return value; 3378 case 223539345: // approvalDate 3379 this.approvalDate = castToDate(value); // DateType 3380 return value; 3381 case -1687512484: // lastReviewDate 3382 this.lastReviewDate = castToDate(value); // DateType 3383 return value; 3384 case -403934648: // effectivePeriod 3385 this.effectivePeriod = castToPeriod(value); // Period 3386 return value; 3387 case 110546223: // topic 3388 this.getTopic().add(castToCodeableConcept(value)); // CodeableConcept 3389 return value; 3390 case -1406328437: // author 3391 this.getAuthor().add(castToContactDetail(value)); // ContactDetail 3392 return value; 3393 case -1307827859: // editor 3394 this.getEditor().add(castToContactDetail(value)); // ContactDetail 3395 return value; 3396 case -261190139: // reviewer 3397 this.getReviewer().add(castToContactDetail(value)); // ContactDetail 3398 return value; 3399 case 1740277666: // endorser 3400 this.getEndorser().add(castToContactDetail(value)); // ContactDetail 3401 return value; 3402 case 666807069: // relatedArtifact 3403 this.getRelatedArtifact().add(castToRelatedArtifact(value)); // RelatedArtifact 3404 return value; 3405 case 3575610: // type 3406 value = new EvidenceVariableTypeEnumFactory().fromType(castToCode(value)); 3407 this.type = (Enumeration) value; // Enumeration<EvidenceVariableType> 3408 return value; 3409 case 366313883: // characteristic 3410 this.getCharacteristic().add((EvidenceVariableCharacteristicComponent) value); // EvidenceVariableCharacteristicComponent 3411 return value; 3412 default: 3413 return super.setProperty(hash, name, value); 3414 } 3415 3416 } 3417 3418 @Override 3419 public Base setProperty(String name, Base value) throws FHIRException { 3420 if (name.equals("url")) { 3421 this.url = castToUri(value); // UriType 3422 } else if (name.equals("identifier")) { 3423 this.getIdentifier().add(castToIdentifier(value)); 3424 } else if (name.equals("version")) { 3425 this.version = castToString(value); // StringType 3426 } else if (name.equals("name")) { 3427 this.name = castToString(value); // StringType 3428 } else if (name.equals("title")) { 3429 this.title = castToString(value); // StringType 3430 } else if (name.equals("shortTitle")) { 3431 this.shortTitle = castToString(value); // StringType 3432 } else if (name.equals("subtitle")) { 3433 this.subtitle = castToString(value); // StringType 3434 } else if (name.equals("status")) { 3435 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 3436 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 3437 } else if (name.equals("date")) { 3438 this.date = castToDateTime(value); // DateTimeType 3439 } else if (name.equals("publisher")) { 3440 this.publisher = castToString(value); // StringType 3441 } else if (name.equals("contact")) { 3442 this.getContact().add(castToContactDetail(value)); 3443 } else if (name.equals("description")) { 3444 this.description = castToMarkdown(value); // MarkdownType 3445 } else if (name.equals("note")) { 3446 this.getNote().add(castToAnnotation(value)); 3447 } else if (name.equals("useContext")) { 3448 this.getUseContext().add(castToUsageContext(value)); 3449 } else if (name.equals("jurisdiction")) { 3450 this.getJurisdiction().add(castToCodeableConcept(value)); 3451 } else if (name.equals("copyright")) { 3452 this.copyright = castToMarkdown(value); // MarkdownType 3453 } else if (name.equals("approvalDate")) { 3454 this.approvalDate = castToDate(value); // DateType 3455 } else if (name.equals("lastReviewDate")) { 3456 this.lastReviewDate = castToDate(value); // DateType 3457 } else if (name.equals("effectivePeriod")) { 3458 this.effectivePeriod = castToPeriod(value); // Period 3459 } else if (name.equals("topic")) { 3460 this.getTopic().add(castToCodeableConcept(value)); 3461 } else if (name.equals("author")) { 3462 this.getAuthor().add(castToContactDetail(value)); 3463 } else if (name.equals("editor")) { 3464 this.getEditor().add(castToContactDetail(value)); 3465 } else if (name.equals("reviewer")) { 3466 this.getReviewer().add(castToContactDetail(value)); 3467 } else if (name.equals("endorser")) { 3468 this.getEndorser().add(castToContactDetail(value)); 3469 } else if (name.equals("relatedArtifact")) { 3470 this.getRelatedArtifact().add(castToRelatedArtifact(value)); 3471 } else if (name.equals("type")) { 3472 value = new EvidenceVariableTypeEnumFactory().fromType(castToCode(value)); 3473 this.type = (Enumeration) value; // Enumeration<EvidenceVariableType> 3474 } else if (name.equals("characteristic")) { 3475 this.getCharacteristic().add((EvidenceVariableCharacteristicComponent) value); 3476 } else 3477 return super.setProperty(name, value); 3478 return value; 3479 } 3480 3481 @Override 3482 public Base makeProperty(int hash, String name) throws FHIRException { 3483 switch (hash) { 3484 case 116079: 3485 return getUrlElement(); 3486 case -1618432855: 3487 return addIdentifier(); 3488 case 351608024: 3489 return getVersionElement(); 3490 case 3373707: 3491 return getNameElement(); 3492 case 110371416: 3493 return getTitleElement(); 3494 case 1555503932: 3495 return getShortTitleElement(); 3496 case -2060497896: 3497 return getSubtitleElement(); 3498 case -892481550: 3499 return getStatusElement(); 3500 case 3076014: 3501 return getDateElement(); 3502 case 1447404028: 3503 return getPublisherElement(); 3504 case 951526432: 3505 return addContact(); 3506 case -1724546052: 3507 return getDescriptionElement(); 3508 case 3387378: 3509 return addNote(); 3510 case -669707736: 3511 return addUseContext(); 3512 case -507075711: 3513 return addJurisdiction(); 3514 case 1522889671: 3515 return getCopyrightElement(); 3516 case 223539345: 3517 return getApprovalDateElement(); 3518 case -1687512484: 3519 return getLastReviewDateElement(); 3520 case -403934648: 3521 return getEffectivePeriod(); 3522 case 110546223: 3523 return addTopic(); 3524 case -1406328437: 3525 return addAuthor(); 3526 case -1307827859: 3527 return addEditor(); 3528 case -261190139: 3529 return addReviewer(); 3530 case 1740277666: 3531 return addEndorser(); 3532 case 666807069: 3533 return addRelatedArtifact(); 3534 case 3575610: 3535 return getTypeElement(); 3536 case 366313883: 3537 return addCharacteristic(); 3538 default: 3539 return super.makeProperty(hash, name); 3540 } 3541 3542 } 3543 3544 @Override 3545 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3546 switch (hash) { 3547 case 116079: 3548 /* url */ return new String[] { "uri" }; 3549 case -1618432855: 3550 /* identifier */ return new String[] { "Identifier" }; 3551 case 351608024: 3552 /* version */ return new String[] { "string" }; 3553 case 3373707: 3554 /* name */ return new String[] { "string" }; 3555 case 110371416: 3556 /* title */ return new String[] { "string" }; 3557 case 1555503932: 3558 /* shortTitle */ return new String[] { "string" }; 3559 case -2060497896: 3560 /* subtitle */ return new String[] { "string" }; 3561 case -892481550: 3562 /* status */ return new String[] { "code" }; 3563 case 3076014: 3564 /* date */ return new String[] { "dateTime" }; 3565 case 1447404028: 3566 /* publisher */ return new String[] { "string" }; 3567 case 951526432: 3568 /* contact */ return new String[] { "ContactDetail" }; 3569 case -1724546052: 3570 /* description */ return new String[] { "markdown" }; 3571 case 3387378: 3572 /* note */ return new String[] { "Annotation" }; 3573 case -669707736: 3574 /* useContext */ return new String[] { "UsageContext" }; 3575 case -507075711: 3576 /* jurisdiction */ return new String[] { "CodeableConcept" }; 3577 case 1522889671: 3578 /* copyright */ return new String[] { "markdown" }; 3579 case 223539345: 3580 /* approvalDate */ return new String[] { "date" }; 3581 case -1687512484: 3582 /* lastReviewDate */ return new String[] { "date" }; 3583 case -403934648: 3584 /* effectivePeriod */ return new String[] { "Period" }; 3585 case 110546223: 3586 /* topic */ return new String[] { "CodeableConcept" }; 3587 case -1406328437: 3588 /* author */ return new String[] { "ContactDetail" }; 3589 case -1307827859: 3590 /* editor */ return new String[] { "ContactDetail" }; 3591 case -261190139: 3592 /* reviewer */ return new String[] { "ContactDetail" }; 3593 case 1740277666: 3594 /* endorser */ return new String[] { "ContactDetail" }; 3595 case 666807069: 3596 /* relatedArtifact */ return new String[] { "RelatedArtifact" }; 3597 case 3575610: 3598 /* type */ return new String[] { "code" }; 3599 case 366313883: 3600 /* characteristic */ return new String[] {}; 3601 default: 3602 return super.getTypesForProperty(hash, name); 3603 } 3604 3605 } 3606 3607 @Override 3608 public Base addChild(String name) throws FHIRException { 3609 if (name.equals("url")) { 3610 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.url"); 3611 } else if (name.equals("identifier")) { 3612 return addIdentifier(); 3613 } else if (name.equals("version")) { 3614 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.version"); 3615 } else if (name.equals("name")) { 3616 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.name"); 3617 } else if (name.equals("title")) { 3618 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.title"); 3619 } else if (name.equals("shortTitle")) { 3620 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.shortTitle"); 3621 } else if (name.equals("subtitle")) { 3622 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.subtitle"); 3623 } else if (name.equals("status")) { 3624 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.status"); 3625 } else if (name.equals("date")) { 3626 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.date"); 3627 } else if (name.equals("publisher")) { 3628 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.publisher"); 3629 } else if (name.equals("contact")) { 3630 return addContact(); 3631 } else if (name.equals("description")) { 3632 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.description"); 3633 } else if (name.equals("note")) { 3634 return addNote(); 3635 } else if (name.equals("useContext")) { 3636 return addUseContext(); 3637 } else if (name.equals("jurisdiction")) { 3638 return addJurisdiction(); 3639 } else if (name.equals("copyright")) { 3640 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.copyright"); 3641 } else if (name.equals("approvalDate")) { 3642 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.approvalDate"); 3643 } else if (name.equals("lastReviewDate")) { 3644 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.lastReviewDate"); 3645 } else if (name.equals("effectivePeriod")) { 3646 this.effectivePeriod = new Period(); 3647 return this.effectivePeriod; 3648 } else if (name.equals("topic")) { 3649 return addTopic(); 3650 } else if (name.equals("author")) { 3651 return addAuthor(); 3652 } else if (name.equals("editor")) { 3653 return addEditor(); 3654 } else if (name.equals("reviewer")) { 3655 return addReviewer(); 3656 } else if (name.equals("endorser")) { 3657 return addEndorser(); 3658 } else if (name.equals("relatedArtifact")) { 3659 return addRelatedArtifact(); 3660 } else if (name.equals("type")) { 3661 throw new FHIRException("Cannot call addChild on a singleton property EvidenceVariable.type"); 3662 } else if (name.equals("characteristic")) { 3663 return addCharacteristic(); 3664 } else 3665 return super.addChild(name); 3666 } 3667 3668 public String fhirType() { 3669 return "EvidenceVariable"; 3670 3671 } 3672 3673 public EvidenceVariable copy() { 3674 EvidenceVariable dst = new EvidenceVariable(); 3675 copyValues(dst); 3676 return dst; 3677 } 3678 3679 public void copyValues(EvidenceVariable dst) { 3680 super.copyValues(dst); 3681 dst.url = url == null ? null : url.copy(); 3682 if (identifier != null) { 3683 dst.identifier = new ArrayList<Identifier>(); 3684 for (Identifier i : identifier) 3685 dst.identifier.add(i.copy()); 3686 } 3687 ; 3688 dst.version = version == null ? null : version.copy(); 3689 dst.name = name == null ? null : name.copy(); 3690 dst.title = title == null ? null : title.copy(); 3691 dst.shortTitle = shortTitle == null ? null : shortTitle.copy(); 3692 dst.subtitle = subtitle == null ? null : subtitle.copy(); 3693 dst.status = status == null ? null : status.copy(); 3694 dst.date = date == null ? null : date.copy(); 3695 dst.publisher = publisher == null ? null : publisher.copy(); 3696 if (contact != null) { 3697 dst.contact = new ArrayList<ContactDetail>(); 3698 for (ContactDetail i : contact) 3699 dst.contact.add(i.copy()); 3700 } 3701 ; 3702 dst.description = description == null ? null : description.copy(); 3703 if (note != null) { 3704 dst.note = new ArrayList<Annotation>(); 3705 for (Annotation i : note) 3706 dst.note.add(i.copy()); 3707 } 3708 ; 3709 if (useContext != null) { 3710 dst.useContext = new ArrayList<UsageContext>(); 3711 for (UsageContext i : useContext) 3712 dst.useContext.add(i.copy()); 3713 } 3714 ; 3715 if (jurisdiction != null) { 3716 dst.jurisdiction = new ArrayList<CodeableConcept>(); 3717 for (CodeableConcept i : jurisdiction) 3718 dst.jurisdiction.add(i.copy()); 3719 } 3720 ; 3721 dst.copyright = copyright == null ? null : copyright.copy(); 3722 dst.approvalDate = approvalDate == null ? null : approvalDate.copy(); 3723 dst.lastReviewDate = lastReviewDate == null ? null : lastReviewDate.copy(); 3724 dst.effectivePeriod = effectivePeriod == null ? null : effectivePeriod.copy(); 3725 if (topic != null) { 3726 dst.topic = new ArrayList<CodeableConcept>(); 3727 for (CodeableConcept i : topic) 3728 dst.topic.add(i.copy()); 3729 } 3730 ; 3731 if (author != null) { 3732 dst.author = new ArrayList<ContactDetail>(); 3733 for (ContactDetail i : author) 3734 dst.author.add(i.copy()); 3735 } 3736 ; 3737 if (editor != null) { 3738 dst.editor = new ArrayList<ContactDetail>(); 3739 for (ContactDetail i : editor) 3740 dst.editor.add(i.copy()); 3741 } 3742 ; 3743 if (reviewer != null) { 3744 dst.reviewer = new ArrayList<ContactDetail>(); 3745 for (ContactDetail i : reviewer) 3746 dst.reviewer.add(i.copy()); 3747 } 3748 ; 3749 if (endorser != null) { 3750 dst.endorser = new ArrayList<ContactDetail>(); 3751 for (ContactDetail i : endorser) 3752 dst.endorser.add(i.copy()); 3753 } 3754 ; 3755 if (relatedArtifact != null) { 3756 dst.relatedArtifact = new ArrayList<RelatedArtifact>(); 3757 for (RelatedArtifact i : relatedArtifact) 3758 dst.relatedArtifact.add(i.copy()); 3759 } 3760 ; 3761 dst.type = type == null ? null : type.copy(); 3762 if (characteristic != null) { 3763 dst.characteristic = new ArrayList<EvidenceVariableCharacteristicComponent>(); 3764 for (EvidenceVariableCharacteristicComponent i : characteristic) 3765 dst.characteristic.add(i.copy()); 3766 } 3767 ; 3768 } 3769 3770 protected EvidenceVariable typedCopy() { 3771 return copy(); 3772 } 3773 3774 @Override 3775 public boolean equalsDeep(Base other_) { 3776 if (!super.equalsDeep(other_)) 3777 return false; 3778 if (!(other_ instanceof EvidenceVariable)) 3779 return false; 3780 EvidenceVariable o = (EvidenceVariable) other_; 3781 return compareDeep(identifier, o.identifier, true) && compareDeep(shortTitle, o.shortTitle, true) 3782 && compareDeep(subtitle, o.subtitle, true) && compareDeep(note, o.note, true) 3783 && compareDeep(copyright, o.copyright, true) && compareDeep(approvalDate, o.approvalDate, true) 3784 && compareDeep(lastReviewDate, o.lastReviewDate, true) && compareDeep(effectivePeriod, o.effectivePeriod, true) 3785 && compareDeep(topic, o.topic, true) && compareDeep(author, o.author, true) 3786 && compareDeep(editor, o.editor, true) && compareDeep(reviewer, o.reviewer, true) 3787 && compareDeep(endorser, o.endorser, true) && compareDeep(relatedArtifact, o.relatedArtifact, true) 3788 && compareDeep(type, o.type, true) && compareDeep(characteristic, o.characteristic, true); 3789 } 3790 3791 @Override 3792 public boolean equalsShallow(Base other_) { 3793 if (!super.equalsShallow(other_)) 3794 return false; 3795 if (!(other_ instanceof EvidenceVariable)) 3796 return false; 3797 EvidenceVariable o = (EvidenceVariable) other_; 3798 return compareValues(shortTitle, o.shortTitle, true) && compareValues(subtitle, o.subtitle, true) 3799 && compareValues(copyright, o.copyright, true) && compareValues(approvalDate, o.approvalDate, true) 3800 && compareValues(lastReviewDate, o.lastReviewDate, true) && compareValues(type, o.type, true); 3801 } 3802 3803 public boolean isEmpty() { 3804 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, shortTitle, subtitle, note, copyright, 3805 approvalDate, lastReviewDate, effectivePeriod, topic, author, editor, reviewer, endorser, relatedArtifact, type, 3806 characteristic); 3807 } 3808 3809 @Override 3810 public ResourceType getResourceType() { 3811 return ResourceType.EvidenceVariable; 3812 } 3813 3814 /** 3815 * Search parameter: <b>date</b> 3816 * <p> 3817 * Description: <b>The evidence variable publication date</b><br> 3818 * Type: <b>date</b><br> 3819 * Path: <b>EvidenceVariable.date</b><br> 3820 * </p> 3821 */ 3822 @SearchParamDefinition(name = "date", path = "EvidenceVariable.date", description = "The evidence variable publication date", type = "date") 3823 public static final String SP_DATE = "date"; 3824 /** 3825 * <b>Fluent Client</b> search parameter constant for <b>date</b> 3826 * <p> 3827 * Description: <b>The evidence variable publication date</b><br> 3828 * Type: <b>date</b><br> 3829 * Path: <b>EvidenceVariable.date</b><br> 3830 * </p> 3831 */ 3832 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam( 3833 SP_DATE); 3834 3835 /** 3836 * Search parameter: <b>identifier</b> 3837 * <p> 3838 * Description: <b>External identifier for the evidence variable</b><br> 3839 * Type: <b>token</b><br> 3840 * Path: <b>EvidenceVariable.identifier</b><br> 3841 * </p> 3842 */ 3843 @SearchParamDefinition(name = "identifier", path = "EvidenceVariable.identifier", description = "External identifier for the evidence variable", type = "token") 3844 public static final String SP_IDENTIFIER = "identifier"; 3845 /** 3846 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 3847 * <p> 3848 * Description: <b>External identifier for the evidence variable</b><br> 3849 * Type: <b>token</b><br> 3850 * Path: <b>EvidenceVariable.identifier</b><br> 3851 * </p> 3852 */ 3853 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam( 3854 SP_IDENTIFIER); 3855 3856 /** 3857 * Search parameter: <b>successor</b> 3858 * <p> 3859 * Description: <b>What resource is being referenced</b><br> 3860 * Type: <b>reference</b><br> 3861 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 3862 * </p> 3863 */ 3864 @SearchParamDefinition(name = "successor", path = "EvidenceVariable.relatedArtifact.where(type='successor').resource", description = "What resource is being referenced", type = "reference") 3865 public static final String SP_SUCCESSOR = "successor"; 3866 /** 3867 * <b>Fluent Client</b> search parameter constant for <b>successor</b> 3868 * <p> 3869 * Description: <b>What resource is being referenced</b><br> 3870 * Type: <b>reference</b><br> 3871 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 3872 * </p> 3873 */ 3874 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUCCESSOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 3875 SP_SUCCESSOR); 3876 3877 /** 3878 * Constant for fluent queries to be used to add include statements. Specifies 3879 * the path value of "<b>EvidenceVariable:successor</b>". 3880 */ 3881 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUCCESSOR = new ca.uhn.fhir.model.api.Include( 3882 "EvidenceVariable:successor").toLocked(); 3883 3884 /** 3885 * Search parameter: <b>context-type-value</b> 3886 * <p> 3887 * Description: <b>A use context type and value assigned to the evidence 3888 * variable</b><br> 3889 * Type: <b>composite</b><br> 3890 * Path: <b></b><br> 3891 * </p> 3892 */ 3893 @SearchParamDefinition(name = "context-type-value", path = "EvidenceVariable.useContext", description = "A use context type and value assigned to the evidence variable", type = "composite", compositeOf = { 3894 "context-type", "context" }) 3895 public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value"; 3896 /** 3897 * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b> 3898 * <p> 3899 * Description: <b>A use context type and value assigned to the evidence 3900 * variable</b><br> 3901 * Type: <b>composite</b><br> 3902 * Path: <b></b><br> 3903 * </p> 3904 */ 3905 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CONTEXT_TYPE_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>( 3906 SP_CONTEXT_TYPE_VALUE); 3907 3908 /** 3909 * Search parameter: <b>jurisdiction</b> 3910 * <p> 3911 * Description: <b>Intended jurisdiction for the evidence variable</b><br> 3912 * Type: <b>token</b><br> 3913 * Path: <b>EvidenceVariable.jurisdiction</b><br> 3914 * </p> 3915 */ 3916 @SearchParamDefinition(name = "jurisdiction", path = "EvidenceVariable.jurisdiction", description = "Intended jurisdiction for the evidence variable", type = "token") 3917 public static final String SP_JURISDICTION = "jurisdiction"; 3918 /** 3919 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 3920 * <p> 3921 * Description: <b>Intended jurisdiction for the evidence variable</b><br> 3922 * Type: <b>token</b><br> 3923 * Path: <b>EvidenceVariable.jurisdiction</b><br> 3924 * </p> 3925 */ 3926 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam( 3927 SP_JURISDICTION); 3928 3929 /** 3930 * Search parameter: <b>description</b> 3931 * <p> 3932 * Description: <b>The description of the evidence variable</b><br> 3933 * Type: <b>string</b><br> 3934 * Path: <b>EvidenceVariable.description</b><br> 3935 * </p> 3936 */ 3937 @SearchParamDefinition(name = "description", path = "EvidenceVariable.description", description = "The description of the evidence variable", type = "string") 3938 public static final String SP_DESCRIPTION = "description"; 3939 /** 3940 * <b>Fluent Client</b> search parameter constant for <b>description</b> 3941 * <p> 3942 * Description: <b>The description of the evidence variable</b><br> 3943 * Type: <b>string</b><br> 3944 * Path: <b>EvidenceVariable.description</b><br> 3945 * </p> 3946 */ 3947 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam( 3948 SP_DESCRIPTION); 3949 3950 /** 3951 * Search parameter: <b>derived-from</b> 3952 * <p> 3953 * Description: <b>What resource is being referenced</b><br> 3954 * Type: <b>reference</b><br> 3955 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 3956 * </p> 3957 */ 3958 @SearchParamDefinition(name = "derived-from", path = "EvidenceVariable.relatedArtifact.where(type='derived-from').resource", description = "What resource is being referenced", type = "reference") 3959 public static final String SP_DERIVED_FROM = "derived-from"; 3960 /** 3961 * <b>Fluent Client</b> search parameter constant for <b>derived-from</b> 3962 * <p> 3963 * Description: <b>What resource is being referenced</b><br> 3964 * Type: <b>reference</b><br> 3965 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 3966 * </p> 3967 */ 3968 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam DERIVED_FROM = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 3969 SP_DERIVED_FROM); 3970 3971 /** 3972 * Constant for fluent queries to be used to add include statements. Specifies 3973 * the path value of "<b>EvidenceVariable:derived-from</b>". 3974 */ 3975 public static final ca.uhn.fhir.model.api.Include INCLUDE_DERIVED_FROM = new ca.uhn.fhir.model.api.Include( 3976 "EvidenceVariable:derived-from").toLocked(); 3977 3978 /** 3979 * Search parameter: <b>context-type</b> 3980 * <p> 3981 * Description: <b>A type of use context assigned to the evidence 3982 * variable</b><br> 3983 * Type: <b>token</b><br> 3984 * Path: <b>EvidenceVariable.useContext.code</b><br> 3985 * </p> 3986 */ 3987 @SearchParamDefinition(name = "context-type", path = "EvidenceVariable.useContext.code", description = "A type of use context assigned to the evidence variable", type = "token") 3988 public static final String SP_CONTEXT_TYPE = "context-type"; 3989 /** 3990 * <b>Fluent Client</b> search parameter constant for <b>context-type</b> 3991 * <p> 3992 * Description: <b>A type of use context assigned to the evidence 3993 * variable</b><br> 3994 * Type: <b>token</b><br> 3995 * Path: <b>EvidenceVariable.useContext.code</b><br> 3996 * </p> 3997 */ 3998 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam( 3999 SP_CONTEXT_TYPE); 4000 4001 /** 4002 * Search parameter: <b>predecessor</b> 4003 * <p> 4004 * Description: <b>What resource is being referenced</b><br> 4005 * Type: <b>reference</b><br> 4006 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 4007 * </p> 4008 */ 4009 @SearchParamDefinition(name = "predecessor", path = "EvidenceVariable.relatedArtifact.where(type='predecessor').resource", description = "What resource is being referenced", type = "reference") 4010 public static final String SP_PREDECESSOR = "predecessor"; 4011 /** 4012 * <b>Fluent Client</b> search parameter constant for <b>predecessor</b> 4013 * <p> 4014 * Description: <b>What resource is being referenced</b><br> 4015 * Type: <b>reference</b><br> 4016 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 4017 * </p> 4018 */ 4019 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PREDECESSOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 4020 SP_PREDECESSOR); 4021 4022 /** 4023 * Constant for fluent queries to be used to add include statements. Specifies 4024 * the path value of "<b>EvidenceVariable:predecessor</b>". 4025 */ 4026 public static final ca.uhn.fhir.model.api.Include INCLUDE_PREDECESSOR = new ca.uhn.fhir.model.api.Include( 4027 "EvidenceVariable:predecessor").toLocked(); 4028 4029 /** 4030 * Search parameter: <b>title</b> 4031 * <p> 4032 * Description: <b>The human-friendly name of the evidence variable</b><br> 4033 * Type: <b>string</b><br> 4034 * Path: <b>EvidenceVariable.title</b><br> 4035 * </p> 4036 */ 4037 @SearchParamDefinition(name = "title", path = "EvidenceVariable.title", description = "The human-friendly name of the evidence variable", type = "string") 4038 public static final String SP_TITLE = "title"; 4039 /** 4040 * <b>Fluent Client</b> search parameter constant for <b>title</b> 4041 * <p> 4042 * Description: <b>The human-friendly name of the evidence variable</b><br> 4043 * Type: <b>string</b><br> 4044 * Path: <b>EvidenceVariable.title</b><br> 4045 * </p> 4046 */ 4047 public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam( 4048 SP_TITLE); 4049 4050 /** 4051 * Search parameter: <b>composed-of</b> 4052 * <p> 4053 * Description: <b>What resource is being referenced</b><br> 4054 * Type: <b>reference</b><br> 4055 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 4056 * </p> 4057 */ 4058 @SearchParamDefinition(name = "composed-of", path = "EvidenceVariable.relatedArtifact.where(type='composed-of').resource", description = "What resource is being referenced", type = "reference") 4059 public static final String SP_COMPOSED_OF = "composed-of"; 4060 /** 4061 * <b>Fluent Client</b> search parameter constant for <b>composed-of</b> 4062 * <p> 4063 * Description: <b>What resource is being referenced</b><br> 4064 * Type: <b>reference</b><br> 4065 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 4066 * </p> 4067 */ 4068 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam COMPOSED_OF = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 4069 SP_COMPOSED_OF); 4070 4071 /** 4072 * Constant for fluent queries to be used to add include statements. Specifies 4073 * the path value of "<b>EvidenceVariable:composed-of</b>". 4074 */ 4075 public static final ca.uhn.fhir.model.api.Include INCLUDE_COMPOSED_OF = new ca.uhn.fhir.model.api.Include( 4076 "EvidenceVariable:composed-of").toLocked(); 4077 4078 /** 4079 * Search parameter: <b>version</b> 4080 * <p> 4081 * Description: <b>The business version of the evidence variable</b><br> 4082 * Type: <b>token</b><br> 4083 * Path: <b>EvidenceVariable.version</b><br> 4084 * </p> 4085 */ 4086 @SearchParamDefinition(name = "version", path = "EvidenceVariable.version", description = "The business version of the evidence variable", type = "token") 4087 public static final String SP_VERSION = "version"; 4088 /** 4089 * <b>Fluent Client</b> search parameter constant for <b>version</b> 4090 * <p> 4091 * Description: <b>The business version of the evidence variable</b><br> 4092 * Type: <b>token</b><br> 4093 * Path: <b>EvidenceVariable.version</b><br> 4094 * </p> 4095 */ 4096 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam( 4097 SP_VERSION); 4098 4099 /** 4100 * Search parameter: <b>url</b> 4101 * <p> 4102 * Description: <b>The uri that identifies the evidence variable</b><br> 4103 * Type: <b>uri</b><br> 4104 * Path: <b>EvidenceVariable.url</b><br> 4105 * </p> 4106 */ 4107 @SearchParamDefinition(name = "url", path = "EvidenceVariable.url", description = "The uri that identifies the evidence variable", type = "uri") 4108 public static final String SP_URL = "url"; 4109 /** 4110 * <b>Fluent Client</b> search parameter constant for <b>url</b> 4111 * <p> 4112 * Description: <b>The uri that identifies the evidence variable</b><br> 4113 * Type: <b>uri</b><br> 4114 * Path: <b>EvidenceVariable.url</b><br> 4115 * </p> 4116 */ 4117 public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL); 4118 4119 /** 4120 * Search parameter: <b>context-quantity</b> 4121 * <p> 4122 * Description: <b>A quantity- or range-valued use context assigned to the 4123 * evidence variable</b><br> 4124 * Type: <b>quantity</b><br> 4125 * Path: <b>EvidenceVariable.useContext.valueQuantity, 4126 * EvidenceVariable.useContext.valueRange</b><br> 4127 * </p> 4128 */ 4129 @SearchParamDefinition(name = "context-quantity", path = "(EvidenceVariable.useContext.value as Quantity) | (EvidenceVariable.useContext.value as Range)", description = "A quantity- or range-valued use context assigned to the evidence variable", type = "quantity") 4130 public static final String SP_CONTEXT_QUANTITY = "context-quantity"; 4131 /** 4132 * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b> 4133 * <p> 4134 * Description: <b>A quantity- or range-valued use context assigned to the 4135 * evidence variable</b><br> 4136 * Type: <b>quantity</b><br> 4137 * Path: <b>EvidenceVariable.useContext.valueQuantity, 4138 * EvidenceVariable.useContext.valueRange</b><br> 4139 * </p> 4140 */ 4141 public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam( 4142 SP_CONTEXT_QUANTITY); 4143 4144 /** 4145 * Search parameter: <b>effective</b> 4146 * <p> 4147 * Description: <b>The time during which the evidence variable is intended to be 4148 * in use</b><br> 4149 * Type: <b>date</b><br> 4150 * Path: <b>EvidenceVariable.effectivePeriod</b><br> 4151 * </p> 4152 */ 4153 @SearchParamDefinition(name = "effective", path = "EvidenceVariable.effectivePeriod", description = "The time during which the evidence variable is intended to be in use", type = "date") 4154 public static final String SP_EFFECTIVE = "effective"; 4155 /** 4156 * <b>Fluent Client</b> search parameter constant for <b>effective</b> 4157 * <p> 4158 * Description: <b>The time during which the evidence variable is intended to be 4159 * in use</b><br> 4160 * Type: <b>date</b><br> 4161 * Path: <b>EvidenceVariable.effectivePeriod</b><br> 4162 * </p> 4163 */ 4164 public static final ca.uhn.fhir.rest.gclient.DateClientParam EFFECTIVE = new ca.uhn.fhir.rest.gclient.DateClientParam( 4165 SP_EFFECTIVE); 4166 4167 /** 4168 * Search parameter: <b>depends-on</b> 4169 * <p> 4170 * Description: <b>What resource is being referenced</b><br> 4171 * Type: <b>reference</b><br> 4172 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 4173 * </p> 4174 */ 4175 @SearchParamDefinition(name = "depends-on", path = "EvidenceVariable.relatedArtifact.where(type='depends-on').resource", description = "What resource is being referenced", type = "reference") 4176 public static final String SP_DEPENDS_ON = "depends-on"; 4177 /** 4178 * <b>Fluent Client</b> search parameter constant for <b>depends-on</b> 4179 * <p> 4180 * Description: <b>What resource is being referenced</b><br> 4181 * Type: <b>reference</b><br> 4182 * Path: <b>EvidenceVariable.relatedArtifact.resource</b><br> 4183 * </p> 4184 */ 4185 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam DEPENDS_ON = new ca.uhn.fhir.rest.gclient.ReferenceClientParam( 4186 SP_DEPENDS_ON); 4187 4188 /** 4189 * Constant for fluent queries to be used to add include statements. Specifies 4190 * the path value of "<b>EvidenceVariable:depends-on</b>". 4191 */ 4192 public static final ca.uhn.fhir.model.api.Include INCLUDE_DEPENDS_ON = new ca.uhn.fhir.model.api.Include( 4193 "EvidenceVariable:depends-on").toLocked(); 4194 4195 /** 4196 * Search parameter: <b>name</b> 4197 * <p> 4198 * Description: <b>Computationally friendly name of the evidence 4199 * variable</b><br> 4200 * Type: <b>string</b><br> 4201 * Path: <b>EvidenceVariable.name</b><br> 4202 * </p> 4203 */ 4204 @SearchParamDefinition(name = "name", path = "EvidenceVariable.name", description = "Computationally friendly name of the evidence variable", type = "string") 4205 public static final String SP_NAME = "name"; 4206 /** 4207 * <b>Fluent Client</b> search parameter constant for <b>name</b> 4208 * <p> 4209 * Description: <b>Computationally friendly name of the evidence 4210 * variable</b><br> 4211 * Type: <b>string</b><br> 4212 * Path: <b>EvidenceVariable.name</b><br> 4213 * </p> 4214 */ 4215 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam( 4216 SP_NAME); 4217 4218 /** 4219 * Search parameter: <b>context</b> 4220 * <p> 4221 * Description: <b>A use context assigned to the evidence variable</b><br> 4222 * Type: <b>token</b><br> 4223 * Path: <b>EvidenceVariable.useContext.valueCodeableConcept</b><br> 4224 * </p> 4225 */ 4226 @SearchParamDefinition(name = "context", path = "(EvidenceVariable.useContext.value as CodeableConcept)", description = "A use context assigned to the evidence variable", type = "token") 4227 public static final String SP_CONTEXT = "context"; 4228 /** 4229 * <b>Fluent Client</b> search parameter constant for <b>context</b> 4230 * <p> 4231 * Description: <b>A use context assigned to the evidence variable</b><br> 4232 * Type: <b>token</b><br> 4233 * Path: <b>EvidenceVariable.useContext.valueCodeableConcept</b><br> 4234 * </p> 4235 */ 4236 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam( 4237 SP_CONTEXT); 4238 4239 /** 4240 * Search parameter: <b>publisher</b> 4241 * <p> 4242 * Description: <b>Name of the publisher of the evidence variable</b><br> 4243 * Type: <b>string</b><br> 4244 * Path: <b>EvidenceVariable.publisher</b><br> 4245 * </p> 4246 */ 4247 @SearchParamDefinition(name = "publisher", path = "EvidenceVariable.publisher", description = "Name of the publisher of the evidence variable", type = "string") 4248 public static final String SP_PUBLISHER = "publisher"; 4249 /** 4250 * <b>Fluent Client</b> search parameter constant for <b>publisher</b> 4251 * <p> 4252 * Description: <b>Name of the publisher of the evidence variable</b><br> 4253 * Type: <b>string</b><br> 4254 * Path: <b>EvidenceVariable.publisher</b><br> 4255 * </p> 4256 */ 4257 public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam( 4258 SP_PUBLISHER); 4259 4260 /** 4261 * Search parameter: <b>topic</b> 4262 * <p> 4263 * Description: <b>Topics associated with the EvidenceVariable</b><br> 4264 * Type: <b>token</b><br> 4265 * Path: <b>EvidenceVariable.topic</b><br> 4266 * </p> 4267 */ 4268 @SearchParamDefinition(name = "topic", path = "EvidenceVariable.topic", description = "Topics associated with the EvidenceVariable", type = "token") 4269 public static final String SP_TOPIC = "topic"; 4270 /** 4271 * <b>Fluent Client</b> search parameter constant for <b>topic</b> 4272 * <p> 4273 * Description: <b>Topics associated with the EvidenceVariable</b><br> 4274 * Type: <b>token</b><br> 4275 * Path: <b>EvidenceVariable.topic</b><br> 4276 * </p> 4277 */ 4278 public static final ca.uhn.fhir.rest.gclient.TokenClientParam TOPIC = new ca.uhn.fhir.rest.gclient.TokenClientParam( 4279 SP_TOPIC); 4280 4281 /** 4282 * Search parameter: <b>context-type-quantity</b> 4283 * <p> 4284 * Description: <b>A use context type and quantity- or range-based value 4285 * assigned to the evidence variable</b><br> 4286 * Type: <b>composite</b><br> 4287 * Path: <b></b><br> 4288 * </p> 4289 */ 4290 @SearchParamDefinition(name = "context-type-quantity", path = "EvidenceVariable.useContext", description = "A use context type and quantity- or range-based value assigned to the evidence variable", type = "composite", compositeOf = { 4291 "context-type", "context-quantity" }) 4292 public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity"; 4293 /** 4294 * <b>Fluent Client</b> search parameter constant for 4295 * <b>context-type-quantity</b> 4296 * <p> 4297 * Description: <b>A use context type and quantity- or range-based value 4298 * assigned to the evidence variable</b><br> 4299 * Type: <b>composite</b><br> 4300 * Path: <b></b><br> 4301 * </p> 4302 */ 4303 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam> CONTEXT_TYPE_QUANTITY = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam>( 4304 SP_CONTEXT_TYPE_QUANTITY); 4305 4306 /** 4307 * Search parameter: <b>status</b> 4308 * <p> 4309 * Description: <b>The current status of the evidence variable</b><br> 4310 * Type: <b>token</b><br> 4311 * Path: <b>EvidenceVariable.status</b><br> 4312 * </p> 4313 */ 4314 @SearchParamDefinition(name = "status", path = "EvidenceVariable.status", description = "The current status of the evidence variable", type = "token") 4315 public static final String SP_STATUS = "status"; 4316 /** 4317 * <b>Fluent Client</b> search parameter constant for <b>status</b> 4318 * <p> 4319 * Description: <b>The current status of the evidence variable</b><br> 4320 * Type: <b>token</b><br> 4321 * Path: <b>EvidenceVariable.status</b><br> 4322 * </p> 4323 */ 4324 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam( 4325 SP_STATUS); 4326 4327}