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