001package org.hl7.fhir.r5.model; 002 003 004 005 006/* 007 Copyright (c) 2011+, HL7, Inc. 008 All rights reserved. 009 010 Redistribution and use in source and binary forms, with or without modification, \ 011 are permitted provided that the following conditions are met: 012 013 * Redistributions of source code must retain the above copyright notice, this \ 014 list of conditions and the following disclaimer. 015 * Redistributions in binary form must reproduce the above copyright notice, \ 016 this list of conditions and the following disclaimer in the documentation \ 017 and/or other materials provided with the distribution. 018 * Neither the name of HL7 nor the names of its contributors may be used to 019 endorse or promote products derived from this software without specific 020 prior written permission. 021 022 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 023 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 024 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 025 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 026 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 027 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 028 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 029 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 030 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 031 POSSIBILITY OF SUCH DAMAGE. 032 */ 033 034// Generated on Mon, May 11, 2020 09:58+1000 for FHIR vcurrent 035 036import java.util.ArrayList; 037import java.util.Date; 038import java.util.List; 039import org.hl7.fhir.utilities.Utilities; 040import org.hl7.fhir.r5.model.Enumerations.*; 041import org.hl7.fhir.instance.model.api.IBaseDatatypeElement; 042import org.hl7.fhir.exceptions.FHIRException; 043import org.hl7.fhir.instance.model.api.ICompositeType; 044import ca.uhn.fhir.model.api.annotation.Child; 045import ca.uhn.fhir.model.api.annotation.ChildOrder; 046import ca.uhn.fhir.model.api.annotation.DatatypeDef; 047import ca.uhn.fhir.model.api.annotation.Description; 048import ca.uhn.fhir.model.api.annotation.Block; 049 050import org.hl7.fhir.instance.model.api.ICompositeType; 051import org.hl7.fhir.r5.model.Enumerations.BindingStrength; 052import org.hl7.fhir.r5.model.Enumerations.BindingStrengthEnumFactory; 053import org.hl7.fhir.r5.utils.ToolingExtensions; 054import org.hl7.fhir.instance.model.api.IBaseDatatypeElement; 055import org.hl7.fhir.utilities.CommaSeparatedStringBuilder; 056/** 057 * Base StructureDefinition for ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension. 058 */ 059@DatatypeDef(name="ElementDefinition") 060public class ElementDefinition extends BackboneType implements ICompositeType { 061 062 public enum AggregationMode { 063 /** 064 * The reference is a local reference to a contained resource. 065 */ 066 CONTAINED, 067 /** 068 * The reference to a resource that has to be resolved externally to the resource that includes the reference. 069 */ 070 REFERENCED, 071 /** 072 * The resource the reference points to will be found in the same bundle as the resource that includes the reference. 073 */ 074 BUNDLED, 075 /** 076 * added to help the parsers with the generic types 077 */ 078 NULL; 079 public static AggregationMode fromCode(String codeString) throws FHIRException { 080 if (codeString == null || "".equals(codeString)) 081 return null; 082 if ("contained".equals(codeString)) 083 return CONTAINED; 084 if ("referenced".equals(codeString)) 085 return REFERENCED; 086 if ("bundled".equals(codeString)) 087 return BUNDLED; 088 if (Configuration.isAcceptInvalidEnums()) 089 return null; 090 else 091 throw new FHIRException("Unknown AggregationMode code '"+codeString+"'"); 092 } 093 public String toCode() { 094 switch (this) { 095 case CONTAINED: return "contained"; 096 case REFERENCED: return "referenced"; 097 case BUNDLED: return "bundled"; 098 default: return "?"; 099 } 100 } 101 public String getSystem() { 102 switch (this) { 103 case CONTAINED: return "http://hl7.org/fhir/resource-aggregation-mode"; 104 case REFERENCED: return "http://hl7.org/fhir/resource-aggregation-mode"; 105 case BUNDLED: return "http://hl7.org/fhir/resource-aggregation-mode"; 106 default: return "?"; 107 } 108 } 109 public String getDefinition() { 110 switch (this) { 111 case CONTAINED: return "The reference is a local reference to a contained resource."; 112 case REFERENCED: return "The reference to a resource that has to be resolved externally to the resource that includes the reference."; 113 case BUNDLED: return "The resource the reference points to will be found in the same bundle as the resource that includes the reference."; 114 default: return "?"; 115 } 116 } 117 public String getDisplay() { 118 switch (this) { 119 case CONTAINED: return "Contained"; 120 case REFERENCED: return "Referenced"; 121 case BUNDLED: return "Bundled"; 122 default: return "?"; 123 } 124 } 125 } 126 127 public static class AggregationModeEnumFactory implements EnumFactory<AggregationMode> { 128 public AggregationMode fromCode(String codeString) throws IllegalArgumentException { 129 if (codeString == null || "".equals(codeString)) 130 if (codeString == null || "".equals(codeString)) 131 return null; 132 if ("contained".equals(codeString)) 133 return AggregationMode.CONTAINED; 134 if ("referenced".equals(codeString)) 135 return AggregationMode.REFERENCED; 136 if ("bundled".equals(codeString)) 137 return AggregationMode.BUNDLED; 138 throw new IllegalArgumentException("Unknown AggregationMode code '"+codeString+"'"); 139 } 140 public Enumeration<AggregationMode> fromType(Base code) throws FHIRException { 141 if (code == null) 142 return null; 143 if (code.isEmpty()) 144 return new Enumeration<AggregationMode>(this); 145 String codeString = ((PrimitiveType) code).asStringValue(); 146 if (codeString == null || "".equals(codeString)) 147 return null; 148 if ("contained".equals(codeString)) 149 return new Enumeration<AggregationMode>(this, AggregationMode.CONTAINED); 150 if ("referenced".equals(codeString)) 151 return new Enumeration<AggregationMode>(this, AggregationMode.REFERENCED); 152 if ("bundled".equals(codeString)) 153 return new Enumeration<AggregationMode>(this, AggregationMode.BUNDLED); 154 throw new FHIRException("Unknown AggregationMode code '"+codeString+"'"); 155 } 156 public String toCode(AggregationMode code) { 157 if (code == AggregationMode.CONTAINED) 158 return "contained"; 159 if (code == AggregationMode.REFERENCED) 160 return "referenced"; 161 if (code == AggregationMode.BUNDLED) 162 return "bundled"; 163 return "?"; 164 } 165 public String toSystem(AggregationMode code) { 166 return code.getSystem(); 167 } 168 } 169 170 public enum ConstraintSeverity { 171 /** 172 * If the constraint is violated, the resource is not conformant. 173 */ 174 ERROR, 175 /** 176 * If the constraint is violated, the resource is conformant, but it is not necessarily following best practice. 177 */ 178 WARNING, 179 /** 180 * added to help the parsers with the generic types 181 */ 182 NULL; 183 public static ConstraintSeverity fromCode(String codeString) throws FHIRException { 184 if (codeString == null || "".equals(codeString)) 185 return null; 186 if ("error".equals(codeString)) 187 return ERROR; 188 if ("warning".equals(codeString)) 189 return WARNING; 190 if (Configuration.isAcceptInvalidEnums()) 191 return null; 192 else 193 throw new FHIRException("Unknown ConstraintSeverity code '"+codeString+"'"); 194 } 195 public String toCode() { 196 switch (this) { 197 case ERROR: return "error"; 198 case WARNING: return "warning"; 199 default: return "?"; 200 } 201 } 202 public String getSystem() { 203 switch (this) { 204 case ERROR: return "http://hl7.org/fhir/constraint-severity"; 205 case WARNING: return "http://hl7.org/fhir/constraint-severity"; 206 default: return "?"; 207 } 208 } 209 public String getDefinition() { 210 switch (this) { 211 case ERROR: return "If the constraint is violated, the resource is not conformant."; 212 case WARNING: return "If the constraint is violated, the resource is conformant, but it is not necessarily following best practice."; 213 default: return "?"; 214 } 215 } 216 public String getDisplay() { 217 switch (this) { 218 case ERROR: return "Error"; 219 case WARNING: return "Warning"; 220 default: return "?"; 221 } 222 } 223 } 224 225 public static class ConstraintSeverityEnumFactory implements EnumFactory<ConstraintSeverity> { 226 public ConstraintSeverity fromCode(String codeString) throws IllegalArgumentException { 227 if (codeString == null || "".equals(codeString)) 228 if (codeString == null || "".equals(codeString)) 229 return null; 230 if ("error".equals(codeString)) 231 return ConstraintSeverity.ERROR; 232 if ("warning".equals(codeString)) 233 return ConstraintSeverity.WARNING; 234 throw new IllegalArgumentException("Unknown ConstraintSeverity code '"+codeString+"'"); 235 } 236 public Enumeration<ConstraintSeverity> fromType(Base code) throws FHIRException { 237 if (code == null) 238 return null; 239 if (code.isEmpty()) 240 return new Enumeration<ConstraintSeverity>(this); 241 String codeString = ((PrimitiveType) code).asStringValue(); 242 if (codeString == null || "".equals(codeString)) 243 return null; 244 if ("error".equals(codeString)) 245 return new Enumeration<ConstraintSeverity>(this, ConstraintSeverity.ERROR); 246 if ("warning".equals(codeString)) 247 return new Enumeration<ConstraintSeverity>(this, ConstraintSeverity.WARNING); 248 throw new FHIRException("Unknown ConstraintSeverity code '"+codeString+"'"); 249 } 250 public String toCode(ConstraintSeverity code) { 251 if (code == ConstraintSeverity.ERROR) 252 return "error"; 253 if (code == ConstraintSeverity.WARNING) 254 return "warning"; 255 return "?"; 256 } 257 public String toSystem(ConstraintSeverity code) { 258 return code.getSystem(); 259 } 260 } 261 262 public enum DiscriminatorType { 263 /** 264 * The slices have different values in the nominated element. 265 */ 266 VALUE, 267 /** 268 * The slices are differentiated by the presence or absence of the nominated element. 269 */ 270 EXISTS, 271 /** 272 * The slices have different values in the nominated element, as determined by testing them against the applicable ElementDefinition.pattern[x]. 273 */ 274 PATTERN, 275 /** 276 * The slices are differentiated by type of the nominated element. 277 */ 278 TYPE, 279 /** 280 * The slices are differentiated by conformance of the nominated element to a specified profile. Note that if the path specifies .resolve() then the profile is the target profile on the reference. In this case, validation by the possible profiles is required to differentiate the slices. 281 */ 282 PROFILE, 283 /** 284 * added to help the parsers with the generic types 285 */ 286 NULL; 287 public static DiscriminatorType fromCode(String codeString) throws FHIRException { 288 if (codeString == null || "".equals(codeString)) 289 return null; 290 if ("value".equals(codeString)) 291 return VALUE; 292 if ("exists".equals(codeString)) 293 return EXISTS; 294 if ("pattern".equals(codeString)) 295 return PATTERN; 296 if ("type".equals(codeString)) 297 return TYPE; 298 if ("profile".equals(codeString)) 299 return PROFILE; 300 if (Configuration.isAcceptInvalidEnums()) 301 return null; 302 else 303 throw new FHIRException("Unknown DiscriminatorType code '"+codeString+"'"); 304 } 305 public String toCode() { 306 switch (this) { 307 case VALUE: return "value"; 308 case EXISTS: return "exists"; 309 case PATTERN: return "pattern"; 310 case TYPE: return "type"; 311 case PROFILE: return "profile"; 312 default: return "?"; 313 } 314 } 315 public String getSystem() { 316 switch (this) { 317 case VALUE: return "http://hl7.org/fhir/discriminator-type"; 318 case EXISTS: return "http://hl7.org/fhir/discriminator-type"; 319 case PATTERN: return "http://hl7.org/fhir/discriminator-type"; 320 case TYPE: return "http://hl7.org/fhir/discriminator-type"; 321 case PROFILE: return "http://hl7.org/fhir/discriminator-type"; 322 default: return "?"; 323 } 324 } 325 public String getDefinition() { 326 switch (this) { 327 case VALUE: return "The slices have different values in the nominated element."; 328 case EXISTS: return "The slices are differentiated by the presence or absence of the nominated element."; 329 case PATTERN: return "The slices have different values in the nominated element, as determined by testing them against the applicable ElementDefinition.pattern[x]."; 330 case TYPE: return "The slices are differentiated by type of the nominated element."; 331 case PROFILE: return "The slices are differentiated by conformance of the nominated element to a specified profile. Note that if the path specifies .resolve() then the profile is the target profile on the reference. In this case, validation by the possible profiles is required to differentiate the slices."; 332 default: return "?"; 333 } 334 } 335 public String getDisplay() { 336 switch (this) { 337 case VALUE: return "Value"; 338 case EXISTS: return "Exists"; 339 case PATTERN: return "Pattern"; 340 case TYPE: return "Type"; 341 case PROFILE: return "Profile"; 342 default: return "?"; 343 } 344 } 345 } 346 347 public static class DiscriminatorTypeEnumFactory implements EnumFactory<DiscriminatorType> { 348 public DiscriminatorType fromCode(String codeString) throws IllegalArgumentException { 349 if (codeString == null || "".equals(codeString)) 350 if (codeString == null || "".equals(codeString)) 351 return null; 352 if ("value".equals(codeString)) 353 return DiscriminatorType.VALUE; 354 if ("exists".equals(codeString)) 355 return DiscriminatorType.EXISTS; 356 if ("pattern".equals(codeString)) 357 return DiscriminatorType.PATTERN; 358 if ("type".equals(codeString)) 359 return DiscriminatorType.TYPE; 360 if ("profile".equals(codeString)) 361 return DiscriminatorType.PROFILE; 362 throw new IllegalArgumentException("Unknown DiscriminatorType code '"+codeString+"'"); 363 } 364 public Enumeration<DiscriminatorType> fromType(Base code) throws FHIRException { 365 if (code == null) 366 return null; 367 if (code.isEmpty()) 368 return new Enumeration<DiscriminatorType>(this); 369 String codeString = ((PrimitiveType) code).asStringValue(); 370 if (codeString == null || "".equals(codeString)) 371 return null; 372 if ("value".equals(codeString)) 373 return new Enumeration<DiscriminatorType>(this, DiscriminatorType.VALUE); 374 if ("exists".equals(codeString)) 375 return new Enumeration<DiscriminatorType>(this, DiscriminatorType.EXISTS); 376 if ("pattern".equals(codeString)) 377 return new Enumeration<DiscriminatorType>(this, DiscriminatorType.PATTERN); 378 if ("type".equals(codeString)) 379 return new Enumeration<DiscriminatorType>(this, DiscriminatorType.TYPE); 380 if ("profile".equals(codeString)) 381 return new Enumeration<DiscriminatorType>(this, DiscriminatorType.PROFILE); 382 throw new FHIRException("Unknown DiscriminatorType code '"+codeString+"'"); 383 } 384 public String toCode(DiscriminatorType code) { 385 if (code == DiscriminatorType.VALUE) 386 return "value"; 387 if (code == DiscriminatorType.EXISTS) 388 return "exists"; 389 if (code == DiscriminatorType.PATTERN) 390 return "pattern"; 391 if (code == DiscriminatorType.TYPE) 392 return "type"; 393 if (code == DiscriminatorType.PROFILE) 394 return "profile"; 395 return "?"; 396 } 397 public String toSystem(DiscriminatorType code) { 398 return code.getSystem(); 399 } 400 } 401 402 public enum PropertyRepresentation { 403 /** 404 * In XML, this property is represented as an attribute not an element. 405 */ 406 XMLATTR, 407 /** 408 * This element is represented using the XML text attribute (primitives only). 409 */ 410 XMLTEXT, 411 /** 412 * The type of this element is indicated using xsi:type. 413 */ 414 TYPEATTR, 415 /** 416 * Use CDA narrative instead of XHTML. 417 */ 418 CDATEXT, 419 /** 420 * The property is represented using XHTML. 421 */ 422 XHTML, 423 /** 424 * added to help the parsers with the generic types 425 */ 426 NULL; 427 public static PropertyRepresentation fromCode(String codeString) throws FHIRException { 428 if (codeString == null || "".equals(codeString)) 429 return null; 430 if ("xmlAttr".equals(codeString)) 431 return XMLATTR; 432 if ("xmlText".equals(codeString)) 433 return XMLTEXT; 434 if ("typeAttr".equals(codeString)) 435 return TYPEATTR; 436 if ("cdaText".equals(codeString)) 437 return CDATEXT; 438 if ("xhtml".equals(codeString)) 439 return XHTML; 440 if (Configuration.isAcceptInvalidEnums()) 441 return null; 442 else 443 throw new FHIRException("Unknown PropertyRepresentation code '"+codeString+"'"); 444 } 445 public String toCode() { 446 switch (this) { 447 case XMLATTR: return "xmlAttr"; 448 case XMLTEXT: return "xmlText"; 449 case TYPEATTR: return "typeAttr"; 450 case CDATEXT: return "cdaText"; 451 case XHTML: return "xhtml"; 452 default: return "?"; 453 } 454 } 455 public String getSystem() { 456 switch (this) { 457 case XMLATTR: return "http://hl7.org/fhir/property-representation"; 458 case XMLTEXT: return "http://hl7.org/fhir/property-representation"; 459 case TYPEATTR: return "http://hl7.org/fhir/property-representation"; 460 case CDATEXT: return "http://hl7.org/fhir/property-representation"; 461 case XHTML: return "http://hl7.org/fhir/property-representation"; 462 default: return "?"; 463 } 464 } 465 public String getDefinition() { 466 switch (this) { 467 case XMLATTR: return "In XML, this property is represented as an attribute not an element."; 468 case XMLTEXT: return "This element is represented using the XML text attribute (primitives only)."; 469 case TYPEATTR: return "The type of this element is indicated using xsi:type."; 470 case CDATEXT: return "Use CDA narrative instead of XHTML."; 471 case XHTML: return "The property is represented using XHTML."; 472 default: return "?"; 473 } 474 } 475 public String getDisplay() { 476 switch (this) { 477 case XMLATTR: return "XML Attribute"; 478 case XMLTEXT: return "XML Text"; 479 case TYPEATTR: return "Type Attribute"; 480 case CDATEXT: return "CDA Text Format"; 481 case XHTML: return "XHTML"; 482 default: return "?"; 483 } 484 } 485 } 486 487 public static class PropertyRepresentationEnumFactory implements EnumFactory<PropertyRepresentation> { 488 public PropertyRepresentation fromCode(String codeString) throws IllegalArgumentException { 489 if (codeString == null || "".equals(codeString)) 490 if (codeString == null || "".equals(codeString)) 491 return null; 492 if ("xmlAttr".equals(codeString)) 493 return PropertyRepresentation.XMLATTR; 494 if ("xmlText".equals(codeString)) 495 return PropertyRepresentation.XMLTEXT; 496 if ("typeAttr".equals(codeString)) 497 return PropertyRepresentation.TYPEATTR; 498 if ("cdaText".equals(codeString)) 499 return PropertyRepresentation.CDATEXT; 500 if ("xhtml".equals(codeString)) 501 return PropertyRepresentation.XHTML; 502 throw new IllegalArgumentException("Unknown PropertyRepresentation code '"+codeString+"'"); 503 } 504 public Enumeration<PropertyRepresentation> fromType(Base code) throws FHIRException { 505 if (code == null) 506 return null; 507 if (code.isEmpty()) 508 return new Enumeration<PropertyRepresentation>(this); 509 String codeString = ((PrimitiveType) code).asStringValue(); 510 if (codeString == null || "".equals(codeString)) 511 return null; 512 if ("xmlAttr".equals(codeString)) 513 return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.XMLATTR); 514 if ("xmlText".equals(codeString)) 515 return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.XMLTEXT); 516 if ("typeAttr".equals(codeString)) 517 return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.TYPEATTR); 518 if ("cdaText".equals(codeString)) 519 return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.CDATEXT); 520 if ("xhtml".equals(codeString)) 521 return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.XHTML); 522 throw new FHIRException("Unknown PropertyRepresentation code '"+codeString+"'"); 523 } 524 public String toCode(PropertyRepresentation code) { 525 if (code == PropertyRepresentation.XMLATTR) 526 return "xmlAttr"; 527 if (code == PropertyRepresentation.XMLTEXT) 528 return "xmlText"; 529 if (code == PropertyRepresentation.TYPEATTR) 530 return "typeAttr"; 531 if (code == PropertyRepresentation.CDATEXT) 532 return "cdaText"; 533 if (code == PropertyRepresentation.XHTML) 534 return "xhtml"; 535 return "?"; 536 } 537 public String toSystem(PropertyRepresentation code) { 538 return code.getSystem(); 539 } 540 } 541 542 public enum ReferenceVersionRules { 543 /** 544 * The reference may be either version independent or version specific. 545 */ 546 EITHER, 547 /** 548 * The reference must be version independent. 549 */ 550 INDEPENDENT, 551 /** 552 * The reference must be version specific. 553 */ 554 SPECIFIC, 555 /** 556 * added to help the parsers with the generic types 557 */ 558 NULL; 559 public static ReferenceVersionRules fromCode(String codeString) throws FHIRException { 560 if (codeString == null || "".equals(codeString)) 561 return null; 562 if ("either".equals(codeString)) 563 return EITHER; 564 if ("independent".equals(codeString)) 565 return INDEPENDENT; 566 if ("specific".equals(codeString)) 567 return SPECIFIC; 568 if (Configuration.isAcceptInvalidEnums()) 569 return null; 570 else 571 throw new FHIRException("Unknown ReferenceVersionRules code '"+codeString+"'"); 572 } 573 public String toCode() { 574 switch (this) { 575 case EITHER: return "either"; 576 case INDEPENDENT: return "independent"; 577 case SPECIFIC: return "specific"; 578 default: return "?"; 579 } 580 } 581 public String getSystem() { 582 switch (this) { 583 case EITHER: return "http://hl7.org/fhir/reference-version-rules"; 584 case INDEPENDENT: return "http://hl7.org/fhir/reference-version-rules"; 585 case SPECIFIC: return "http://hl7.org/fhir/reference-version-rules"; 586 default: return "?"; 587 } 588 } 589 public String getDefinition() { 590 switch (this) { 591 case EITHER: return "The reference may be either version independent or version specific."; 592 case INDEPENDENT: return "The reference must be version independent."; 593 case SPECIFIC: return "The reference must be version specific."; 594 default: return "?"; 595 } 596 } 597 public String getDisplay() { 598 switch (this) { 599 case EITHER: return "Either Specific or independent"; 600 case INDEPENDENT: return "Version independent"; 601 case SPECIFIC: return "Version Specific"; 602 default: return "?"; 603 } 604 } 605 } 606 607 public static class ReferenceVersionRulesEnumFactory implements EnumFactory<ReferenceVersionRules> { 608 public ReferenceVersionRules fromCode(String codeString) throws IllegalArgumentException { 609 if (codeString == null || "".equals(codeString)) 610 if (codeString == null || "".equals(codeString)) 611 return null; 612 if ("either".equals(codeString)) 613 return ReferenceVersionRules.EITHER; 614 if ("independent".equals(codeString)) 615 return ReferenceVersionRules.INDEPENDENT; 616 if ("specific".equals(codeString)) 617 return ReferenceVersionRules.SPECIFIC; 618 throw new IllegalArgumentException("Unknown ReferenceVersionRules code '"+codeString+"'"); 619 } 620 public Enumeration<ReferenceVersionRules> fromType(Base code) throws FHIRException { 621 if (code == null) 622 return null; 623 if (code.isEmpty()) 624 return new Enumeration<ReferenceVersionRules>(this); 625 String codeString = ((PrimitiveType) code).asStringValue(); 626 if (codeString == null || "".equals(codeString)) 627 return null; 628 if ("either".equals(codeString)) 629 return new Enumeration<ReferenceVersionRules>(this, ReferenceVersionRules.EITHER); 630 if ("independent".equals(codeString)) 631 return new Enumeration<ReferenceVersionRules>(this, ReferenceVersionRules.INDEPENDENT); 632 if ("specific".equals(codeString)) 633 return new Enumeration<ReferenceVersionRules>(this, ReferenceVersionRules.SPECIFIC); 634 throw new FHIRException("Unknown ReferenceVersionRules code '"+codeString+"'"); 635 } 636 public String toCode(ReferenceVersionRules code) { 637 if (code == ReferenceVersionRules.EITHER) 638 return "either"; 639 if (code == ReferenceVersionRules.INDEPENDENT) 640 return "independent"; 641 if (code == ReferenceVersionRules.SPECIFIC) 642 return "specific"; 643 return "?"; 644 } 645 public String toSystem(ReferenceVersionRules code) { 646 return code.getSystem(); 647 } 648 } 649 650 public enum SlicingRules { 651 /** 652 * No additional content is allowed other than that described by the slices in this profile. 653 */ 654 CLOSED, 655 /** 656 * Additional content is allowed anywhere in the list. 657 */ 658 OPEN, 659 /** 660 * Additional content is allowed, but only at the end of the list. Note that using this requires that the slices be ordered, which makes it hard to share uses. This should only be done where absolutely required. 661 */ 662 OPENATEND, 663 /** 664 * added to help the parsers with the generic types 665 */ 666 NULL; 667 public static SlicingRules fromCode(String codeString) throws FHIRException { 668 if (codeString == null || "".equals(codeString)) 669 return null; 670 if ("closed".equals(codeString)) 671 return CLOSED; 672 if ("open".equals(codeString)) 673 return OPEN; 674 if ("openAtEnd".equals(codeString)) 675 return OPENATEND; 676 if (Configuration.isAcceptInvalidEnums()) 677 return null; 678 else 679 throw new FHIRException("Unknown SlicingRules code '"+codeString+"'"); 680 } 681 public String toCode() { 682 switch (this) { 683 case CLOSED: return "closed"; 684 case OPEN: return "open"; 685 case OPENATEND: return "openAtEnd"; 686 default: return "?"; 687 } 688 } 689 public String getSystem() { 690 switch (this) { 691 case CLOSED: return "http://hl7.org/fhir/resource-slicing-rules"; 692 case OPEN: return "http://hl7.org/fhir/resource-slicing-rules"; 693 case OPENATEND: return "http://hl7.org/fhir/resource-slicing-rules"; 694 default: return "?"; 695 } 696 } 697 public String getDefinition() { 698 switch (this) { 699 case CLOSED: return "No additional content is allowed other than that described by the slices in this profile."; 700 case OPEN: return "Additional content is allowed anywhere in the list."; 701 case OPENATEND: return "Additional content is allowed, but only at the end of the list. Note that using this requires that the slices be ordered, which makes it hard to share uses. This should only be done where absolutely required."; 702 default: return "?"; 703 } 704 } 705 public String getDisplay() { 706 switch (this) { 707 case CLOSED: return "Closed"; 708 case OPEN: return "Open"; 709 case OPENATEND: return "Open at End"; 710 default: return "?"; 711 } 712 } 713 } 714 715 public static class SlicingRulesEnumFactory implements EnumFactory<SlicingRules> { 716 public SlicingRules fromCode(String codeString) throws IllegalArgumentException { 717 if (codeString == null || "".equals(codeString)) 718 if (codeString == null || "".equals(codeString)) 719 return null; 720 if ("closed".equals(codeString)) 721 return SlicingRules.CLOSED; 722 if ("open".equals(codeString)) 723 return SlicingRules.OPEN; 724 if ("openAtEnd".equals(codeString)) 725 return SlicingRules.OPENATEND; 726 throw new IllegalArgumentException("Unknown SlicingRules code '"+codeString+"'"); 727 } 728 public Enumeration<SlicingRules> fromType(Base code) throws FHIRException { 729 if (code == null) 730 return null; 731 if (code.isEmpty()) 732 return new Enumeration<SlicingRules>(this); 733 String codeString = ((PrimitiveType) code).asStringValue(); 734 if (codeString == null || "".equals(codeString)) 735 return null; 736 if ("closed".equals(codeString)) 737 return new Enumeration<SlicingRules>(this, SlicingRules.CLOSED); 738 if ("open".equals(codeString)) 739 return new Enumeration<SlicingRules>(this, SlicingRules.OPEN); 740 if ("openAtEnd".equals(codeString)) 741 return new Enumeration<SlicingRules>(this, SlicingRules.OPENATEND); 742 throw new FHIRException("Unknown SlicingRules code '"+codeString+"'"); 743 } 744 public String toCode(SlicingRules code) { 745 if (code == SlicingRules.CLOSED) 746 return "closed"; 747 if (code == SlicingRules.OPEN) 748 return "open"; 749 if (code == SlicingRules.OPENATEND) 750 return "openAtEnd"; 751 return "?"; 752 } 753 public String toSystem(SlicingRules code) { 754 return code.getSystem(); 755 } 756 } 757 758 @Block() 759 public static class ElementDefinitionSlicingComponent extends Element implements IBaseDatatypeElement { 760 /** 761 * Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices. 762 */ 763 @Child(name = "discriminator", type = {}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 764 @Description(shortDefinition="Element values that are used to distinguish the slices", formalDefinition="Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices." ) 765 protected List<ElementDefinitionSlicingDiscriminatorComponent> discriminator; 766 767 /** 768 * A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated. 769 */ 770 @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 771 @Description(shortDefinition="Text description of how slicing works (or not)", formalDefinition="A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated." ) 772 protected StringType description; 773 774 /** 775 * If the matching elements have to occur in the same order as defined in the profile. 776 */ 777 @Child(name = "ordered", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=true) 778 @Description(shortDefinition="If elements must be in same order as slices", formalDefinition="If the matching elements have to occur in the same order as defined in the profile." ) 779 protected BooleanType ordered; 780 781 /** 782 * Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end. 783 */ 784 @Child(name = "rules", type = {CodeType.class}, order=4, min=1, max=1, modifier=false, summary=true) 785 @Description(shortDefinition="closed | open | openAtEnd", formalDefinition="Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end." ) 786 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-slicing-rules") 787 protected Enumeration<SlicingRules> rules; 788 789 private static final long serialVersionUID = -311635839L; 790 791 /** 792 * Constructor 793 */ 794 public ElementDefinitionSlicingComponent() { 795 super(); 796 } 797 798 /** 799 * Constructor 800 */ 801 public ElementDefinitionSlicingComponent(SlicingRules rules) { 802 super(); 803 this.setRules(rules); 804 } 805 806 /** 807 * @return {@link #discriminator} (Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.) 808 */ 809 public List<ElementDefinitionSlicingDiscriminatorComponent> getDiscriminator() { 810 if (this.discriminator == null) 811 this.discriminator = new ArrayList<ElementDefinitionSlicingDiscriminatorComponent>(); 812 return this.discriminator; 813 } 814 815 /** 816 * @return Returns a reference to <code>this</code> for easy method chaining 817 */ 818 public ElementDefinitionSlicingComponent setDiscriminator(List<ElementDefinitionSlicingDiscriminatorComponent> theDiscriminator) { 819 this.discriminator = theDiscriminator; 820 return this; 821 } 822 823 public boolean hasDiscriminator() { 824 if (this.discriminator == null) 825 return false; 826 for (ElementDefinitionSlicingDiscriminatorComponent item : this.discriminator) 827 if (!item.isEmpty()) 828 return true; 829 return false; 830 } 831 832 public ElementDefinitionSlicingDiscriminatorComponent addDiscriminator() { //3 833 ElementDefinitionSlicingDiscriminatorComponent t = new ElementDefinitionSlicingDiscriminatorComponent(); 834 if (this.discriminator == null) 835 this.discriminator = new ArrayList<ElementDefinitionSlicingDiscriminatorComponent>(); 836 this.discriminator.add(t); 837 return t; 838 } 839 840 public ElementDefinitionSlicingComponent addDiscriminator(ElementDefinitionSlicingDiscriminatorComponent t) { //3 841 if (t == null) 842 return this; 843 if (this.discriminator == null) 844 this.discriminator = new ArrayList<ElementDefinitionSlicingDiscriminatorComponent>(); 845 this.discriminator.add(t); 846 return this; 847 } 848 849 /** 850 * @return The first repetition of repeating field {@link #discriminator}, creating it if it does not already exist {3} 851 */ 852 public ElementDefinitionSlicingDiscriminatorComponent getDiscriminatorFirstRep() { 853 if (getDiscriminator().isEmpty()) { 854 addDiscriminator(); 855 } 856 return getDiscriminator().get(0); 857 } 858 859 /** 860 * @return {@link #description} (A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 861 */ 862 public StringType getDescriptionElement() { 863 if (this.description == null) 864 if (Configuration.errorOnAutoCreate()) 865 throw new Error("Attempt to auto-create ElementDefinitionSlicingComponent.description"); 866 else if (Configuration.doAutoCreate()) 867 this.description = new StringType(); // bb 868 return this.description; 869 } 870 871 public boolean hasDescriptionElement() { 872 return this.description != null && !this.description.isEmpty(); 873 } 874 875 public boolean hasDescription() { 876 return this.description != null && !this.description.isEmpty(); 877 } 878 879 /** 880 * @param value {@link #description} (A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 881 */ 882 public ElementDefinitionSlicingComponent setDescriptionElement(StringType value) { 883 this.description = value; 884 return this; 885 } 886 887 /** 888 * @return A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated. 889 */ 890 public String getDescription() { 891 return this.description == null ? null : this.description.getValue(); 892 } 893 894 /** 895 * @param value A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated. 896 */ 897 public ElementDefinitionSlicingComponent setDescription(String value) { 898 if (Utilities.noString(value)) 899 this.description = null; 900 else { 901 if (this.description == null) 902 this.description = new StringType(); 903 this.description.setValue(value); 904 } 905 return this; 906 } 907 908 /** 909 * @return {@link #ordered} (If the matching elements have to occur in the same order as defined in the profile.). This is the underlying object with id, value and extensions. The accessor "getOrdered" gives direct access to the value 910 */ 911 public BooleanType getOrderedElement() { 912 if (this.ordered == null) 913 if (Configuration.errorOnAutoCreate()) 914 throw new Error("Attempt to auto-create ElementDefinitionSlicingComponent.ordered"); 915 else if (Configuration.doAutoCreate()) 916 this.ordered = new BooleanType(); // bb 917 return this.ordered; 918 } 919 920 public boolean hasOrderedElement() { 921 return this.ordered != null && !this.ordered.isEmpty(); 922 } 923 924 public boolean hasOrdered() { 925 return this.ordered != null && !this.ordered.isEmpty(); 926 } 927 928 /** 929 * @param value {@link #ordered} (If the matching elements have to occur in the same order as defined in the profile.). This is the underlying object with id, value and extensions. The accessor "getOrdered" gives direct access to the value 930 */ 931 public ElementDefinitionSlicingComponent setOrderedElement(BooleanType value) { 932 this.ordered = value; 933 return this; 934 } 935 936 /** 937 * @return If the matching elements have to occur in the same order as defined in the profile. 938 */ 939 public boolean getOrdered() { 940 return this.ordered == null || this.ordered.isEmpty() ? false : this.ordered.getValue(); 941 } 942 943 /** 944 * @param value If the matching elements have to occur in the same order as defined in the profile. 945 */ 946 public ElementDefinitionSlicingComponent setOrdered(boolean value) { 947 if (this.ordered == null) 948 this.ordered = new BooleanType(); 949 this.ordered.setValue(value); 950 return this; 951 } 952 953 /** 954 * @return {@link #rules} (Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.). This is the underlying object with id, value and extensions. The accessor "getRules" gives direct access to the value 955 */ 956 public Enumeration<SlicingRules> getRulesElement() { 957 if (this.rules == null) 958 if (Configuration.errorOnAutoCreate()) 959 throw new Error("Attempt to auto-create ElementDefinitionSlicingComponent.rules"); 960 else if (Configuration.doAutoCreate()) 961 this.rules = new Enumeration<SlicingRules>(new SlicingRulesEnumFactory()); // bb 962 return this.rules; 963 } 964 965 public boolean hasRulesElement() { 966 return this.rules != null && !this.rules.isEmpty(); 967 } 968 969 public boolean hasRules() { 970 return this.rules != null && !this.rules.isEmpty(); 971 } 972 973 /** 974 * @param value {@link #rules} (Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.). This is the underlying object with id, value and extensions. The accessor "getRules" gives direct access to the value 975 */ 976 public ElementDefinitionSlicingComponent setRulesElement(Enumeration<SlicingRules> value) { 977 this.rules = value; 978 return this; 979 } 980 981 /** 982 * @return Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end. 983 */ 984 public SlicingRules getRules() { 985 return this.rules == null ? null : this.rules.getValue(); 986 } 987 988 /** 989 * @param value Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end. 990 */ 991 public ElementDefinitionSlicingComponent setRules(SlicingRules value) { 992 if (this.rules == null) 993 this.rules = new Enumeration<SlicingRules>(new SlicingRulesEnumFactory()); 994 this.rules.setValue(value); 995 return this; 996 } 997 998 protected void listChildren(List<Property> children) { 999 super.listChildren(children); 1000 children.add(new Property("discriminator", "", "Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.", 0, java.lang.Integer.MAX_VALUE, discriminator)); 1001 children.add(new Property("description", "string", "A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.", 0, 1, description)); 1002 children.add(new Property("ordered", "boolean", "If the matching elements have to occur in the same order as defined in the profile.", 0, 1, ordered)); 1003 children.add(new Property("rules", "code", "Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.", 0, 1, rules)); 1004 } 1005 1006 @Override 1007 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1008 switch (_hash) { 1009 case -1888270692: /*discriminator*/ return new Property("discriminator", "", "Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.", 0, java.lang.Integer.MAX_VALUE, discriminator); 1010 case -1724546052: /*description*/ return new Property("description", "string", "A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.", 0, 1, description); 1011 case -1207109523: /*ordered*/ return new Property("ordered", "boolean", "If the matching elements have to occur in the same order as defined in the profile.", 0, 1, ordered); 1012 case 108873975: /*rules*/ return new Property("rules", "code", "Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.", 0, 1, rules); 1013 default: return super.getNamedProperty(_hash, _name, _checkValid); 1014 } 1015 1016 } 1017 1018 @Override 1019 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1020 switch (hash) { 1021 case -1888270692: /*discriminator*/ return this.discriminator == null ? new Base[0] : this.discriminator.toArray(new Base[this.discriminator.size()]); // ElementDefinitionSlicingDiscriminatorComponent 1022 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 1023 case -1207109523: /*ordered*/ return this.ordered == null ? new Base[0] : new Base[] {this.ordered}; // BooleanType 1024 case 108873975: /*rules*/ return this.rules == null ? new Base[0] : new Base[] {this.rules}; // Enumeration<SlicingRules> 1025 default: return super.getProperty(hash, name, checkValid); 1026 } 1027 1028 } 1029 1030 @Override 1031 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1032 switch (hash) { 1033 case -1888270692: // discriminator 1034 this.getDiscriminator().add((ElementDefinitionSlicingDiscriminatorComponent) value); // ElementDefinitionSlicingDiscriminatorComponent 1035 return value; 1036 case -1724546052: // description 1037 this.description = TypeConvertor.castToString(value); // StringType 1038 return value; 1039 case -1207109523: // ordered 1040 this.ordered = TypeConvertor.castToBoolean(value); // BooleanType 1041 return value; 1042 case 108873975: // rules 1043 value = new SlicingRulesEnumFactory().fromType(TypeConvertor.castToCode(value)); 1044 this.rules = (Enumeration) value; // Enumeration<SlicingRules> 1045 return value; 1046 default: return super.setProperty(hash, name, value); 1047 } 1048 1049 } 1050 1051 @Override 1052 public Base setProperty(String name, Base value) throws FHIRException { 1053 if (name.equals("discriminator")) { 1054 this.getDiscriminator().add((ElementDefinitionSlicingDiscriminatorComponent) value); 1055 } else if (name.equals("description")) { 1056 this.description = TypeConvertor.castToString(value); // StringType 1057 } else if (name.equals("ordered")) { 1058 this.ordered = TypeConvertor.castToBoolean(value); // BooleanType 1059 } else if (name.equals("rules")) { 1060 value = new SlicingRulesEnumFactory().fromType(TypeConvertor.castToCode(value)); 1061 this.rules = (Enumeration) value; // Enumeration<SlicingRules> 1062 } else 1063 return super.setProperty(name, value); 1064 return value; 1065 } 1066 1067 @Override 1068 public Base makeProperty(int hash, String name) throws FHIRException { 1069 switch (hash) { 1070 case -1888270692: return addDiscriminator(); 1071 case -1724546052: return getDescriptionElement(); 1072 case -1207109523: return getOrderedElement(); 1073 case 108873975: return getRulesElement(); 1074 default: return super.makeProperty(hash, name); 1075 } 1076 1077 } 1078 1079 @Override 1080 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1081 switch (hash) { 1082 case -1888270692: /*discriminator*/ return new String[] {}; 1083 case -1724546052: /*description*/ return new String[] {"string"}; 1084 case -1207109523: /*ordered*/ return new String[] {"boolean"}; 1085 case 108873975: /*rules*/ return new String[] {"code"}; 1086 default: return super.getTypesForProperty(hash, name); 1087 } 1088 1089 } 1090 1091 @Override 1092 public Base addChild(String name) throws FHIRException { 1093 if (name.equals("discriminator")) { 1094 return addDiscriminator(); 1095 } 1096 else if (name.equals("description")) { 1097 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.slicing.description"); 1098 } 1099 else if (name.equals("ordered")) { 1100 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.slicing.ordered"); 1101 } 1102 else if (name.equals("rules")) { 1103 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.slicing.rules"); 1104 } 1105 else 1106 return super.addChild(name); 1107 } 1108 1109 public ElementDefinitionSlicingComponent copy() { 1110 ElementDefinitionSlicingComponent dst = new ElementDefinitionSlicingComponent(); 1111 copyValues(dst); 1112 return dst; 1113 } 1114 1115 public void copyValues(ElementDefinitionSlicingComponent dst) { 1116 super.copyValues(dst); 1117 if (discriminator != null) { 1118 dst.discriminator = new ArrayList<ElementDefinitionSlicingDiscriminatorComponent>(); 1119 for (ElementDefinitionSlicingDiscriminatorComponent i : discriminator) 1120 dst.discriminator.add(i.copy()); 1121 }; 1122 dst.description = description == null ? null : description.copy(); 1123 dst.ordered = ordered == null ? null : ordered.copy(); 1124 dst.rules = rules == null ? null : rules.copy(); 1125 } 1126 1127 @Override 1128 public boolean equalsDeep(Base other_) { 1129 if (!super.equalsDeep(other_)) 1130 return false; 1131 if (!(other_ instanceof ElementDefinitionSlicingComponent)) 1132 return false; 1133 ElementDefinitionSlicingComponent o = (ElementDefinitionSlicingComponent) other_; 1134 return compareDeep(discriminator, o.discriminator, true) && compareDeep(description, o.description, true) 1135 && compareDeep(ordered, o.ordered, true) && compareDeep(rules, o.rules, true); 1136 } 1137 1138 @Override 1139 public boolean equalsShallow(Base other_) { 1140 if (!super.equalsShallow(other_)) 1141 return false; 1142 if (!(other_ instanceof ElementDefinitionSlicingComponent)) 1143 return false; 1144 ElementDefinitionSlicingComponent o = (ElementDefinitionSlicingComponent) other_; 1145 return compareValues(description, o.description, true) && compareValues(ordered, o.ordered, true) && compareValues(rules, o.rules, true) 1146 ; 1147 } 1148 1149 public boolean isEmpty() { 1150 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(discriminator, description 1151 , ordered, rules); 1152 } 1153 1154 public String fhirType() { 1155 return "ElementDefinition.slicing"; 1156 1157 } 1158 1159 } 1160 1161 @Block() 1162 public static class ElementDefinitionSlicingDiscriminatorComponent extends Element implements IBaseDatatypeElement { 1163 /** 1164 * How the element value is interpreted when discrimination is evaluated. 1165 */ 1166 @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1167 @Description(shortDefinition="value | exists | pattern | type | profile", formalDefinition="How the element value is interpreted when discrimination is evaluated." ) 1168 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/discriminator-type") 1169 protected Enumeration<DiscriminatorType> type; 1170 1171 /** 1172 * A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based. 1173 */ 1174 @Child(name = "path", type = {StringType.class}, order=2, min=1, max=1, modifier=false, summary=true) 1175 @Description(shortDefinition="Path to element value", formalDefinition="A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based." ) 1176 protected StringType path; 1177 1178 private static final long serialVersionUID = 1151159293L; 1179 1180 /** 1181 * Constructor 1182 */ 1183 public ElementDefinitionSlicingDiscriminatorComponent() { 1184 super(); 1185 } 1186 1187 /** 1188 * Constructor 1189 */ 1190 public ElementDefinitionSlicingDiscriminatorComponent(DiscriminatorType type, String path) { 1191 super(); 1192 this.setType(type); 1193 this.setPath(path); 1194 } 1195 1196 /** 1197 * @return {@link #type} (How the element value is interpreted when discrimination is evaluated.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1198 */ 1199 public Enumeration<DiscriminatorType> getTypeElement() { 1200 if (this.type == null) 1201 if (Configuration.errorOnAutoCreate()) 1202 throw new Error("Attempt to auto-create ElementDefinitionSlicingDiscriminatorComponent.type"); 1203 else if (Configuration.doAutoCreate()) 1204 this.type = new Enumeration<DiscriminatorType>(new DiscriminatorTypeEnumFactory()); // bb 1205 return this.type; 1206 } 1207 1208 public boolean hasTypeElement() { 1209 return this.type != null && !this.type.isEmpty(); 1210 } 1211 1212 public boolean hasType() { 1213 return this.type != null && !this.type.isEmpty(); 1214 } 1215 1216 /** 1217 * @param value {@link #type} (How the element value is interpreted when discrimination is evaluated.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1218 */ 1219 public ElementDefinitionSlicingDiscriminatorComponent setTypeElement(Enumeration<DiscriminatorType> value) { 1220 this.type = value; 1221 return this; 1222 } 1223 1224 /** 1225 * @return How the element value is interpreted when discrimination is evaluated. 1226 */ 1227 public DiscriminatorType getType() { 1228 return this.type == null ? null : this.type.getValue(); 1229 } 1230 1231 /** 1232 * @param value How the element value is interpreted when discrimination is evaluated. 1233 */ 1234 public ElementDefinitionSlicingDiscriminatorComponent setType(DiscriminatorType value) { 1235 if (this.type == null) 1236 this.type = new Enumeration<DiscriminatorType>(new DiscriminatorTypeEnumFactory()); 1237 this.type.setValue(value); 1238 return this; 1239 } 1240 1241 /** 1242 * @return {@link #path} (A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value 1243 */ 1244 public StringType getPathElement() { 1245 if (this.path == null) 1246 if (Configuration.errorOnAutoCreate()) 1247 throw new Error("Attempt to auto-create ElementDefinitionSlicingDiscriminatorComponent.path"); 1248 else if (Configuration.doAutoCreate()) 1249 this.path = new StringType(); // bb 1250 return this.path; 1251 } 1252 1253 public boolean hasPathElement() { 1254 return this.path != null && !this.path.isEmpty(); 1255 } 1256 1257 public boolean hasPath() { 1258 return this.path != null && !this.path.isEmpty(); 1259 } 1260 1261 /** 1262 * @param value {@link #path} (A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value 1263 */ 1264 public ElementDefinitionSlicingDiscriminatorComponent setPathElement(StringType value) { 1265 this.path = value; 1266 return this; 1267 } 1268 1269 /** 1270 * @return A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based. 1271 */ 1272 public String getPath() { 1273 return this.path == null ? null : this.path.getValue(); 1274 } 1275 1276 /** 1277 * @param value A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based. 1278 */ 1279 public ElementDefinitionSlicingDiscriminatorComponent setPath(String value) { 1280 if (this.path == null) 1281 this.path = new StringType(); 1282 this.path.setValue(value); 1283 return this; 1284 } 1285 1286 protected void listChildren(List<Property> children) { 1287 super.listChildren(children); 1288 children.add(new Property("type", "code", "How the element value is interpreted when discrimination is evaluated.", 0, 1, type)); 1289 children.add(new Property("path", "string", "A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.", 0, 1, path)); 1290 } 1291 1292 @Override 1293 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1294 switch (_hash) { 1295 case 3575610: /*type*/ return new Property("type", "code", "How the element value is interpreted when discrimination is evaluated.", 0, 1, type); 1296 case 3433509: /*path*/ return new Property("path", "string", "A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.", 0, 1, path); 1297 default: return super.getNamedProperty(_hash, _name, _checkValid); 1298 } 1299 1300 } 1301 1302 @Override 1303 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1304 switch (hash) { 1305 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<DiscriminatorType> 1306 case 3433509: /*path*/ return this.path == null ? new Base[0] : new Base[] {this.path}; // StringType 1307 default: return super.getProperty(hash, name, checkValid); 1308 } 1309 1310 } 1311 1312 @Override 1313 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1314 switch (hash) { 1315 case 3575610: // type 1316 value = new DiscriminatorTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 1317 this.type = (Enumeration) value; // Enumeration<DiscriminatorType> 1318 return value; 1319 case 3433509: // path 1320 this.path = TypeConvertor.castToString(value); // StringType 1321 return value; 1322 default: return super.setProperty(hash, name, value); 1323 } 1324 1325 } 1326 1327 @Override 1328 public Base setProperty(String name, Base value) throws FHIRException { 1329 if (name.equals("type")) { 1330 value = new DiscriminatorTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 1331 this.type = (Enumeration) value; // Enumeration<DiscriminatorType> 1332 } else if (name.equals("path")) { 1333 this.path = TypeConvertor.castToString(value); // StringType 1334 } else 1335 return super.setProperty(name, value); 1336 return value; 1337 } 1338 1339 @Override 1340 public Base makeProperty(int hash, String name) throws FHIRException { 1341 switch (hash) { 1342 case 3575610: return getTypeElement(); 1343 case 3433509: return getPathElement(); 1344 default: return super.makeProperty(hash, name); 1345 } 1346 1347 } 1348 1349 @Override 1350 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1351 switch (hash) { 1352 case 3575610: /*type*/ return new String[] {"code"}; 1353 case 3433509: /*path*/ return new String[] {"string"}; 1354 default: return super.getTypesForProperty(hash, name); 1355 } 1356 1357 } 1358 1359 @Override 1360 public Base addChild(String name) throws FHIRException { 1361 if (name.equals("type")) { 1362 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.slicing.discriminator.type"); 1363 } 1364 else if (name.equals("path")) { 1365 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.slicing.discriminator.path"); 1366 } 1367 else 1368 return super.addChild(name); 1369 } 1370 1371 public ElementDefinitionSlicingDiscriminatorComponent copy() { 1372 ElementDefinitionSlicingDiscriminatorComponent dst = new ElementDefinitionSlicingDiscriminatorComponent(); 1373 copyValues(dst); 1374 return dst; 1375 } 1376 1377 public void copyValues(ElementDefinitionSlicingDiscriminatorComponent dst) { 1378 super.copyValues(dst); 1379 dst.type = type == null ? null : type.copy(); 1380 dst.path = path == null ? null : path.copy(); 1381 } 1382 1383 @Override 1384 public boolean equalsDeep(Base other_) { 1385 if (!super.equalsDeep(other_)) 1386 return false; 1387 if (!(other_ instanceof ElementDefinitionSlicingDiscriminatorComponent)) 1388 return false; 1389 ElementDefinitionSlicingDiscriminatorComponent o = (ElementDefinitionSlicingDiscriminatorComponent) other_; 1390 return compareDeep(type, o.type, true) && compareDeep(path, o.path, true); 1391 } 1392 1393 @Override 1394 public boolean equalsShallow(Base other_) { 1395 if (!super.equalsShallow(other_)) 1396 return false; 1397 if (!(other_ instanceof ElementDefinitionSlicingDiscriminatorComponent)) 1398 return false; 1399 ElementDefinitionSlicingDiscriminatorComponent o = (ElementDefinitionSlicingDiscriminatorComponent) other_; 1400 return compareValues(type, o.type, true) && compareValues(path, o.path, true); 1401 } 1402 1403 public boolean isEmpty() { 1404 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, path); 1405 } 1406 1407 public String fhirType() { 1408 return "ElementDefinition.slicing.discriminator"; 1409 1410 } 1411 1412 } 1413 1414 @Block() 1415 public static class ElementDefinitionBaseComponent extends Element implements IBaseDatatypeElement { 1416 /** 1417 * The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base. 1418 */ 1419 @Child(name = "path", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1420 @Description(shortDefinition="Path that identifies the base element", formalDefinition="The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base." ) 1421 protected StringType path; 1422 1423 /** 1424 * Minimum cardinality of the base element identified by the path. 1425 */ 1426 @Child(name = "min", type = {UnsignedIntType.class}, order=2, min=1, max=1, modifier=false, summary=true) 1427 @Description(shortDefinition="Min cardinality of the base element", formalDefinition="Minimum cardinality of the base element identified by the path." ) 1428 protected UnsignedIntType min; 1429 1430 /** 1431 * Maximum cardinality of the base element identified by the path. 1432 */ 1433 @Child(name = "max", type = {StringType.class}, order=3, min=1, max=1, modifier=false, summary=true) 1434 @Description(shortDefinition="Max cardinality of the base element", formalDefinition="Maximum cardinality of the base element identified by the path." ) 1435 protected StringType max; 1436 1437 private static final long serialVersionUID = -1412704221L; 1438 1439 /** 1440 * Constructor 1441 */ 1442 public ElementDefinitionBaseComponent() { 1443 super(); 1444 } 1445 1446 /** 1447 * Constructor 1448 */ 1449 public ElementDefinitionBaseComponent(String path, int min, String max) { 1450 super(); 1451 this.setPath(path); 1452 this.setMin(min); 1453 this.setMax(max); 1454 } 1455 1456 /** 1457 * @return {@link #path} (The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value 1458 */ 1459 public StringType getPathElement() { 1460 if (this.path == null) 1461 if (Configuration.errorOnAutoCreate()) 1462 throw new Error("Attempt to auto-create ElementDefinitionBaseComponent.path"); 1463 else if (Configuration.doAutoCreate()) 1464 this.path = new StringType(); // bb 1465 return this.path; 1466 } 1467 1468 public boolean hasPathElement() { 1469 return this.path != null && !this.path.isEmpty(); 1470 } 1471 1472 public boolean hasPath() { 1473 return this.path != null && !this.path.isEmpty(); 1474 } 1475 1476 /** 1477 * @param value {@link #path} (The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value 1478 */ 1479 public ElementDefinitionBaseComponent setPathElement(StringType value) { 1480 this.path = value; 1481 return this; 1482 } 1483 1484 /** 1485 * @return The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base. 1486 */ 1487 public String getPath() { 1488 return this.path == null ? null : this.path.getValue(); 1489 } 1490 1491 /** 1492 * @param value The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base. 1493 */ 1494 public ElementDefinitionBaseComponent setPath(String value) { 1495 if (this.path == null) 1496 this.path = new StringType(); 1497 this.path.setValue(value); 1498 return this; 1499 } 1500 1501 /** 1502 * @return {@link #min} (Minimum cardinality of the base element identified by the path.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value 1503 */ 1504 public UnsignedIntType getMinElement() { 1505 if (this.min == null) 1506 if (Configuration.errorOnAutoCreate()) 1507 throw new Error("Attempt to auto-create ElementDefinitionBaseComponent.min"); 1508 else if (Configuration.doAutoCreate()) 1509 this.min = new UnsignedIntType(); // bb 1510 return this.min; 1511 } 1512 1513 public boolean hasMinElement() { 1514 return this.min != null && !this.min.isEmpty(); 1515 } 1516 1517 public boolean hasMin() { 1518 return this.min != null && !this.min.isEmpty(); 1519 } 1520 1521 /** 1522 * @param value {@link #min} (Minimum cardinality of the base element identified by the path.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value 1523 */ 1524 public ElementDefinitionBaseComponent setMinElement(UnsignedIntType value) { 1525 this.min = value; 1526 return this; 1527 } 1528 1529 /** 1530 * @return Minimum cardinality of the base element identified by the path. 1531 */ 1532 public int getMin() { 1533 return this.min == null || this.min.isEmpty() ? 0 : this.min.getValue(); 1534 } 1535 1536 /** 1537 * @param value Minimum cardinality of the base element identified by the path. 1538 */ 1539 public ElementDefinitionBaseComponent setMin(int value) { 1540 if (this.min == null) 1541 this.min = new UnsignedIntType(); 1542 this.min.setValue(value); 1543 return this; 1544 } 1545 1546 /** 1547 * @return {@link #max} (Maximum cardinality of the base element identified by the path.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value 1548 */ 1549 public StringType getMaxElement() { 1550 if (this.max == null) 1551 if (Configuration.errorOnAutoCreate()) 1552 throw new Error("Attempt to auto-create ElementDefinitionBaseComponent.max"); 1553 else if (Configuration.doAutoCreate()) 1554 this.max = new StringType(); // bb 1555 return this.max; 1556 } 1557 1558 public boolean hasMaxElement() { 1559 return this.max != null && !this.max.isEmpty(); 1560 } 1561 1562 public boolean hasMax() { 1563 return this.max != null && !this.max.isEmpty(); 1564 } 1565 1566 /** 1567 * @param value {@link #max} (Maximum cardinality of the base element identified by the path.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value 1568 */ 1569 public ElementDefinitionBaseComponent setMaxElement(StringType value) { 1570 this.max = value; 1571 return this; 1572 } 1573 1574 /** 1575 * @return Maximum cardinality of the base element identified by the path. 1576 */ 1577 public String getMax() { 1578 return this.max == null ? null : this.max.getValue(); 1579 } 1580 1581 /** 1582 * @param value Maximum cardinality of the base element identified by the path. 1583 */ 1584 public ElementDefinitionBaseComponent setMax(String value) { 1585 if (this.max == null) 1586 this.max = new StringType(); 1587 this.max.setValue(value); 1588 return this; 1589 } 1590 1591 protected void listChildren(List<Property> children) { 1592 super.listChildren(children); 1593 children.add(new Property("path", "string", "The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.", 0, 1, path)); 1594 children.add(new Property("min", "unsignedInt", "Minimum cardinality of the base element identified by the path.", 0, 1, min)); 1595 children.add(new Property("max", "string", "Maximum cardinality of the base element identified by the path.", 0, 1, max)); 1596 } 1597 1598 @Override 1599 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1600 switch (_hash) { 1601 case 3433509: /*path*/ return new Property("path", "string", "The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.", 0, 1, path); 1602 case 108114: /*min*/ return new Property("min", "unsignedInt", "Minimum cardinality of the base element identified by the path.", 0, 1, min); 1603 case 107876: /*max*/ return new Property("max", "string", "Maximum cardinality of the base element identified by the path.", 0, 1, max); 1604 default: return super.getNamedProperty(_hash, _name, _checkValid); 1605 } 1606 1607 } 1608 1609 @Override 1610 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1611 switch (hash) { 1612 case 3433509: /*path*/ return this.path == null ? new Base[0] : new Base[] {this.path}; // StringType 1613 case 108114: /*min*/ return this.min == null ? new Base[0] : new Base[] {this.min}; // UnsignedIntType 1614 case 107876: /*max*/ return this.max == null ? new Base[0] : new Base[] {this.max}; // StringType 1615 default: return super.getProperty(hash, name, checkValid); 1616 } 1617 1618 } 1619 1620 @Override 1621 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1622 switch (hash) { 1623 case 3433509: // path 1624 this.path = TypeConvertor.castToString(value); // StringType 1625 return value; 1626 case 108114: // min 1627 this.min = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType 1628 return value; 1629 case 107876: // max 1630 this.max = TypeConvertor.castToString(value); // StringType 1631 return value; 1632 default: return super.setProperty(hash, name, value); 1633 } 1634 1635 } 1636 1637 @Override 1638 public Base setProperty(String name, Base value) throws FHIRException { 1639 if (name.equals("path")) { 1640 this.path = TypeConvertor.castToString(value); // StringType 1641 } else if (name.equals("min")) { 1642 this.min = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType 1643 } else if (name.equals("max")) { 1644 this.max = TypeConvertor.castToString(value); // StringType 1645 } else 1646 return super.setProperty(name, value); 1647 return value; 1648 } 1649 1650 @Override 1651 public Base makeProperty(int hash, String name) throws FHIRException { 1652 switch (hash) { 1653 case 3433509: return getPathElement(); 1654 case 108114: return getMinElement(); 1655 case 107876: return getMaxElement(); 1656 default: return super.makeProperty(hash, name); 1657 } 1658 1659 } 1660 1661 @Override 1662 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1663 switch (hash) { 1664 case 3433509: /*path*/ return new String[] {"string"}; 1665 case 108114: /*min*/ return new String[] {"unsignedInt"}; 1666 case 107876: /*max*/ return new String[] {"string"}; 1667 default: return super.getTypesForProperty(hash, name); 1668 } 1669 1670 } 1671 1672 @Override 1673 public Base addChild(String name) throws FHIRException { 1674 if (name.equals("path")) { 1675 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.base.path"); 1676 } 1677 else if (name.equals("min")) { 1678 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.base.min"); 1679 } 1680 else if (name.equals("max")) { 1681 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.base.max"); 1682 } 1683 else 1684 return super.addChild(name); 1685 } 1686 1687 public ElementDefinitionBaseComponent copy() { 1688 ElementDefinitionBaseComponent dst = new ElementDefinitionBaseComponent(); 1689 copyValues(dst); 1690 return dst; 1691 } 1692 1693 public void copyValues(ElementDefinitionBaseComponent dst) { 1694 super.copyValues(dst); 1695 dst.path = path == null ? null : path.copy(); 1696 dst.min = min == null ? null : min.copy(); 1697 dst.max = max == null ? null : max.copy(); 1698 } 1699 1700 @Override 1701 public boolean equalsDeep(Base other_) { 1702 if (!super.equalsDeep(other_)) 1703 return false; 1704 if (!(other_ instanceof ElementDefinitionBaseComponent)) 1705 return false; 1706 ElementDefinitionBaseComponent o = (ElementDefinitionBaseComponent) other_; 1707 return compareDeep(path, o.path, true) && compareDeep(min, o.min, true) && compareDeep(max, o.max, true) 1708 ; 1709 } 1710 1711 @Override 1712 public boolean equalsShallow(Base other_) { 1713 if (!super.equalsShallow(other_)) 1714 return false; 1715 if (!(other_ instanceof ElementDefinitionBaseComponent)) 1716 return false; 1717 ElementDefinitionBaseComponent o = (ElementDefinitionBaseComponent) other_; 1718 return compareValues(path, o.path, true) && compareValues(min, o.min, true) && compareValues(max, o.max, true) 1719 ; 1720 } 1721 1722 public boolean isEmpty() { 1723 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(path, min, max); 1724 } 1725 1726 public String fhirType() { 1727 return "ElementDefinition.base"; 1728 1729 } 1730 1731 } 1732 1733 @Block() 1734 public static class TypeRefComponent extends Element implements IBaseDatatypeElement { 1735 /** 1736 * URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models. 1737 */ 1738 @Child(name = "code", type = {UriType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1739 @Description(shortDefinition="Data type or Resource (reference to definition)", formalDefinition="URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models." ) 1740 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/defined-types") 1741 protected UriType code; 1742 1743 /** 1744 * Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide. 1745 */ 1746 @Child(name = "profile", type = {CanonicalType.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1747 @Description(shortDefinition="Profiles (StructureDefinition or IG) - one must apply", formalDefinition="Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide." ) 1748 protected List<CanonicalType> profile; 1749 1750 /** 1751 * Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide. 1752 */ 1753 @Child(name = "targetProfile", type = {CanonicalType.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1754 @Description(shortDefinition="Profile (StructureDefinition or IG) on the Reference/canonical target - one must apply", formalDefinition="Used when the type is \"Reference\" or \"canonical\", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide." ) 1755 protected List<CanonicalType> targetProfile; 1756 1757 /** 1758 * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle. 1759 */ 1760 @Child(name = "aggregation", type = {CodeType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1761 @Description(shortDefinition="contained | referenced | bundled - how aggregated", formalDefinition="If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle." ) 1762 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-aggregation-mode") 1763 protected List<Enumeration<AggregationMode>> aggregation; 1764 1765 /** 1766 * Whether this reference needs to be version specific or version independent, or whether either can be used. 1767 */ 1768 @Child(name = "versioning", type = {CodeType.class}, order=5, min=0, max=1, modifier=false, summary=true) 1769 @Description(shortDefinition="either | independent | specific", formalDefinition="Whether this reference needs to be version specific or version independent, or whether either can be used." ) 1770 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/reference-version-rules") 1771 protected Enumeration<ReferenceVersionRules> versioning; 1772 1773 private static final long serialVersionUID = 957891653L; 1774 1775 /** 1776 * Constructor 1777 */ 1778 public TypeRefComponent() { 1779 super(); 1780 } 1781 1782 /** 1783 * Constructor 1784 */ 1785 public TypeRefComponent(String code) { 1786 super(); 1787 this.setCode(code); 1788 } 1789 1790 /** 1791 * @return {@link #code} (URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 1792 */ 1793 public UriType getCodeElement() { 1794 if (this.code == null) 1795 if (Configuration.errorOnAutoCreate()) 1796 throw new Error("Attempt to auto-create TypeRefComponent.code"); 1797 else if (Configuration.doAutoCreate()) 1798 this.code = new UriType(); // bb 1799 return this.code; 1800 } 1801 1802 public boolean hasCodeElement() { 1803 return this.code != null && !this.code.isEmpty(); 1804 } 1805 1806 public boolean hasCode() { 1807 return this.code != null && !this.code.isEmpty(); 1808 } 1809 1810 /** 1811 * @param value {@link #code} (URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 1812 */ 1813 public TypeRefComponent setCodeElement(UriType value) { 1814 this.code = value; 1815 return this; 1816 } 1817 1818 /** 1819 * @return URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models. 1820 */ 1821 public String getCode() { 1822 return this.code == null ? null : this.code.getValue(); 1823 } 1824 1825 /** 1826 * @param value URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models. 1827 */ 1828 public TypeRefComponent setCode(String value) { 1829 if (this.code == null) 1830 this.code = new UriType(); 1831 this.code.setValue(value); 1832 return this; 1833 } 1834 1835 /** 1836 * @return {@link #profile} (Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.) 1837 */ 1838 public List<CanonicalType> getProfile() { 1839 if (this.profile == null) 1840 this.profile = new ArrayList<CanonicalType>(); 1841 return this.profile; 1842 } 1843 1844 /** 1845 * @return Returns a reference to <code>this</code> for easy method chaining 1846 */ 1847 public TypeRefComponent setProfile(List<CanonicalType> theProfile) { 1848 this.profile = theProfile; 1849 return this; 1850 } 1851 1852 public boolean hasProfile() { 1853 if (this.profile == null) 1854 return false; 1855 for (CanonicalType item : this.profile) 1856 if (!item.isEmpty()) 1857 return true; 1858 return false; 1859 } 1860 1861 /** 1862 * @return {@link #profile} (Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.) 1863 */ 1864 public CanonicalType addProfileElement() {//2 1865 CanonicalType t = new CanonicalType(); 1866 if (this.profile == null) 1867 this.profile = new ArrayList<CanonicalType>(); 1868 this.profile.add(t); 1869 return t; 1870 } 1871 1872 /** 1873 * @param value {@link #profile} (Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.) 1874 */ 1875 public TypeRefComponent addProfile(String value) { //1 1876 CanonicalType t = new CanonicalType(); 1877 t.setValue(value); 1878 if (this.profile == null) 1879 this.profile = new ArrayList<CanonicalType>(); 1880 this.profile.add(t); 1881 return this; 1882 } 1883 1884 /** 1885 * @param value {@link #profile} (Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.) 1886 */ 1887 public boolean hasProfile(String value) { 1888 if (this.profile == null) 1889 return false; 1890 for (CanonicalType v : this.profile) 1891 if (v.getValue().equals(value)) // canonical 1892 return true; 1893 return false; 1894 } 1895 1896 /** 1897 * @return {@link #targetProfile} (Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.) 1898 */ 1899 public List<CanonicalType> getTargetProfile() { 1900 if (this.targetProfile == null) 1901 this.targetProfile = new ArrayList<CanonicalType>(); 1902 return this.targetProfile; 1903 } 1904 1905 /** 1906 * @return Returns a reference to <code>this</code> for easy method chaining 1907 */ 1908 public TypeRefComponent setTargetProfile(List<CanonicalType> theTargetProfile) { 1909 this.targetProfile = theTargetProfile; 1910 return this; 1911 } 1912 1913 public boolean hasTargetProfile() { 1914 if (this.targetProfile == null) 1915 return false; 1916 for (CanonicalType item : this.targetProfile) 1917 if (!item.isEmpty()) 1918 return true; 1919 return false; 1920 } 1921 1922 /** 1923 * @return {@link #targetProfile} (Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.) 1924 */ 1925 public CanonicalType addTargetProfileElement() {//2 1926 CanonicalType t = new CanonicalType(); 1927 if (this.targetProfile == null) 1928 this.targetProfile = new ArrayList<CanonicalType>(); 1929 this.targetProfile.add(t); 1930 return t; 1931 } 1932 1933 /** 1934 * @param value {@link #targetProfile} (Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.) 1935 */ 1936 public TypeRefComponent addTargetProfile(String value) { //1 1937 CanonicalType t = new CanonicalType(); 1938 t.setValue(value); 1939 if (this.targetProfile == null) 1940 this.targetProfile = new ArrayList<CanonicalType>(); 1941 this.targetProfile.add(t); 1942 return this; 1943 } 1944 1945 /** 1946 * @param value {@link #targetProfile} (Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.) 1947 */ 1948 public boolean hasTargetProfile(String value) { 1949 if (this.targetProfile == null) 1950 return false; 1951 for (CanonicalType v : this.targetProfile) 1952 if (v.getValue().equals(value)) // canonical 1953 return true; 1954 return false; 1955 } 1956 1957 /** 1958 * @return {@link #aggregation} (If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.) 1959 */ 1960 public List<Enumeration<AggregationMode>> getAggregation() { 1961 if (this.aggregation == null) 1962 this.aggregation = new ArrayList<Enumeration<AggregationMode>>(); 1963 return this.aggregation; 1964 } 1965 1966 /** 1967 * @return Returns a reference to <code>this</code> for easy method chaining 1968 */ 1969 public TypeRefComponent setAggregation(List<Enumeration<AggregationMode>> theAggregation) { 1970 this.aggregation = theAggregation; 1971 return this; 1972 } 1973 1974 public boolean hasAggregation() { 1975 if (this.aggregation == null) 1976 return false; 1977 for (Enumeration<AggregationMode> item : this.aggregation) 1978 if (!item.isEmpty()) 1979 return true; 1980 return false; 1981 } 1982 1983 /** 1984 * @return {@link #aggregation} (If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.) 1985 */ 1986 public Enumeration<AggregationMode> addAggregationElement() {//2 1987 Enumeration<AggregationMode> t = new Enumeration<AggregationMode>(new AggregationModeEnumFactory()); 1988 if (this.aggregation == null) 1989 this.aggregation = new ArrayList<Enumeration<AggregationMode>>(); 1990 this.aggregation.add(t); 1991 return t; 1992 } 1993 1994 /** 1995 * @param value {@link #aggregation} (If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.) 1996 */ 1997 public TypeRefComponent addAggregation(AggregationMode value) { //1 1998 Enumeration<AggregationMode> t = new Enumeration<AggregationMode>(new AggregationModeEnumFactory()); 1999 t.setValue(value); 2000 if (this.aggregation == null) 2001 this.aggregation = new ArrayList<Enumeration<AggregationMode>>(); 2002 this.aggregation.add(t); 2003 return this; 2004 } 2005 2006 /** 2007 * @param value {@link #aggregation} (If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.) 2008 */ 2009 public boolean hasAggregation(AggregationMode value) { 2010 if (this.aggregation == null) 2011 return false; 2012 for (Enumeration<AggregationMode> v : this.aggregation) 2013 if (v.getValue().equals(value)) // code 2014 return true; 2015 return false; 2016 } 2017 2018 /** 2019 * @return {@link #versioning} (Whether this reference needs to be version specific or version independent, or whether either can be used.). This is the underlying object with id, value and extensions. The accessor "getVersioning" gives direct access to the value 2020 */ 2021 public Enumeration<ReferenceVersionRules> getVersioningElement() { 2022 if (this.versioning == null) 2023 if (Configuration.errorOnAutoCreate()) 2024 throw new Error("Attempt to auto-create TypeRefComponent.versioning"); 2025 else if (Configuration.doAutoCreate()) 2026 this.versioning = new Enumeration<ReferenceVersionRules>(new ReferenceVersionRulesEnumFactory()); // bb 2027 return this.versioning; 2028 } 2029 2030 public boolean hasVersioningElement() { 2031 return this.versioning != null && !this.versioning.isEmpty(); 2032 } 2033 2034 public boolean hasVersioning() { 2035 return this.versioning != null && !this.versioning.isEmpty(); 2036 } 2037 2038 /** 2039 * @param value {@link #versioning} (Whether this reference needs to be version specific or version independent, or whether either can be used.). This is the underlying object with id, value and extensions. The accessor "getVersioning" gives direct access to the value 2040 */ 2041 public TypeRefComponent setVersioningElement(Enumeration<ReferenceVersionRules> value) { 2042 this.versioning = value; 2043 return this; 2044 } 2045 2046 /** 2047 * @return Whether this reference needs to be version specific or version independent, or whether either can be used. 2048 */ 2049 public ReferenceVersionRules getVersioning() { 2050 return this.versioning == null ? null : this.versioning.getValue(); 2051 } 2052 2053 /** 2054 * @param value Whether this reference needs to be version specific or version independent, or whether either can be used. 2055 */ 2056 public TypeRefComponent setVersioning(ReferenceVersionRules value) { 2057 if (value == null) 2058 this.versioning = null; 2059 else { 2060 if (this.versioning == null) 2061 this.versioning = new Enumeration<ReferenceVersionRules>(new ReferenceVersionRulesEnumFactory()); 2062 this.versioning.setValue(value); 2063 } 2064 return this; 2065 } 2066 2067 protected void listChildren(List<Property> children) { 2068 super.listChildren(children); 2069 children.add(new Property("code", "uri", "URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.", 0, 1, code)); 2070 children.add(new Property("profile", "canonical(StructureDefinition|ImplementationGuide)", "Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.", 0, java.lang.Integer.MAX_VALUE, profile)); 2071 children.add(new Property("targetProfile", "canonical(StructureDefinition|ImplementationGuide)", "Used when the type is \"Reference\" or \"canonical\", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.", 0, java.lang.Integer.MAX_VALUE, targetProfile)); 2072 children.add(new Property("aggregation", "code", "If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.", 0, java.lang.Integer.MAX_VALUE, aggregation)); 2073 children.add(new Property("versioning", "code", "Whether this reference needs to be version specific or version independent, or whether either can be used.", 0, 1, versioning)); 2074 } 2075 2076 @Override 2077 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2078 switch (_hash) { 2079 case 3059181: /*code*/ return new Property("code", "uri", "URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.", 0, 1, code); 2080 case -309425751: /*profile*/ return new Property("profile", "canonical(StructureDefinition|ImplementationGuide)", "Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.", 0, java.lang.Integer.MAX_VALUE, profile); 2081 case 1994521304: /*targetProfile*/ return new Property("targetProfile", "canonical(StructureDefinition|ImplementationGuide)", "Used when the type is \"Reference\" or \"canonical\", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.", 0, java.lang.Integer.MAX_VALUE, targetProfile); 2082 case 841524962: /*aggregation*/ return new Property("aggregation", "code", "If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.", 0, java.lang.Integer.MAX_VALUE, aggregation); 2083 case -670487542: /*versioning*/ return new Property("versioning", "code", "Whether this reference needs to be version specific or version independent, or whether either can be used.", 0, 1, versioning); 2084 default: return super.getNamedProperty(_hash, _name, _checkValid); 2085 } 2086 2087 } 2088 2089 @Override 2090 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2091 switch (hash) { 2092 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // UriType 2093 case -309425751: /*profile*/ return this.profile == null ? new Base[0] : this.profile.toArray(new Base[this.profile.size()]); // CanonicalType 2094 case 1994521304: /*targetProfile*/ return this.targetProfile == null ? new Base[0] : this.targetProfile.toArray(new Base[this.targetProfile.size()]); // CanonicalType 2095 case 841524962: /*aggregation*/ return this.aggregation == null ? new Base[0] : this.aggregation.toArray(new Base[this.aggregation.size()]); // Enumeration<AggregationMode> 2096 case -670487542: /*versioning*/ return this.versioning == null ? new Base[0] : new Base[] {this.versioning}; // Enumeration<ReferenceVersionRules> 2097 default: return super.getProperty(hash, name, checkValid); 2098 } 2099 2100 } 2101 2102 @Override 2103 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2104 switch (hash) { 2105 case 3059181: // code 2106 this.code = TypeConvertor.castToUri(value); // UriType 2107 return value; 2108 case -309425751: // profile 2109 this.getProfile().add(TypeConvertor.castToCanonical(value)); // CanonicalType 2110 return value; 2111 case 1994521304: // targetProfile 2112 this.getTargetProfile().add(TypeConvertor.castToCanonical(value)); // CanonicalType 2113 return value; 2114 case 841524962: // aggregation 2115 value = new AggregationModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 2116 this.getAggregation().add((Enumeration) value); // Enumeration<AggregationMode> 2117 return value; 2118 case -670487542: // versioning 2119 value = new ReferenceVersionRulesEnumFactory().fromType(TypeConvertor.castToCode(value)); 2120 this.versioning = (Enumeration) value; // Enumeration<ReferenceVersionRules> 2121 return value; 2122 default: return super.setProperty(hash, name, value); 2123 } 2124 2125 } 2126 2127 @Override 2128 public Base setProperty(String name, Base value) throws FHIRException { 2129 if (name.equals("code")) { 2130 this.code = TypeConvertor.castToUri(value); // UriType 2131 } else if (name.equals("profile")) { 2132 this.getProfile().add(TypeConvertor.castToCanonical(value)); 2133 } else if (name.equals("targetProfile")) { 2134 this.getTargetProfile().add(TypeConvertor.castToCanonical(value)); 2135 } else if (name.equals("aggregation")) { 2136 value = new AggregationModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 2137 this.getAggregation().add((Enumeration) value); 2138 } else if (name.equals("versioning")) { 2139 value = new ReferenceVersionRulesEnumFactory().fromType(TypeConvertor.castToCode(value)); 2140 this.versioning = (Enumeration) value; // Enumeration<ReferenceVersionRules> 2141 } else 2142 return super.setProperty(name, value); 2143 return value; 2144 } 2145 2146 @Override 2147 public Base makeProperty(int hash, String name) throws FHIRException { 2148 switch (hash) { 2149 case 3059181: return getCodeElement(); 2150 case -309425751: return addProfileElement(); 2151 case 1994521304: return addTargetProfileElement(); 2152 case 841524962: return addAggregationElement(); 2153 case -670487542: return getVersioningElement(); 2154 default: return super.makeProperty(hash, name); 2155 } 2156 2157 } 2158 2159 @Override 2160 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2161 switch (hash) { 2162 case 3059181: /*code*/ return new String[] {"uri"}; 2163 case -309425751: /*profile*/ return new String[] {"canonical"}; 2164 case 1994521304: /*targetProfile*/ return new String[] {"canonical"}; 2165 case 841524962: /*aggregation*/ return new String[] {"code"}; 2166 case -670487542: /*versioning*/ return new String[] {"code"}; 2167 default: return super.getTypesForProperty(hash, name); 2168 } 2169 2170 } 2171 2172 @Override 2173 public Base addChild(String name) throws FHIRException { 2174 if (name.equals("code")) { 2175 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.type.code"); 2176 } 2177 else if (name.equals("profile")) { 2178 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.type.profile"); 2179 } 2180 else if (name.equals("targetProfile")) { 2181 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.type.targetProfile"); 2182 } 2183 else if (name.equals("aggregation")) { 2184 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.type.aggregation"); 2185 } 2186 else if (name.equals("versioning")) { 2187 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.type.versioning"); 2188 } 2189 else 2190 return super.addChild(name); 2191 } 2192 2193 public TypeRefComponent copy() { 2194 TypeRefComponent dst = new TypeRefComponent(); 2195 copyValues(dst); 2196 return dst; 2197 } 2198 2199 public void copyValues(TypeRefComponent dst) { 2200 super.copyValues(dst); 2201 dst.code = code == null ? null : code.copy(); 2202 if (profile != null) { 2203 dst.profile = new ArrayList<CanonicalType>(); 2204 for (CanonicalType i : profile) 2205 dst.profile.add(i.copy()); 2206 }; 2207 if (targetProfile != null) { 2208 dst.targetProfile = new ArrayList<CanonicalType>(); 2209 for (CanonicalType i : targetProfile) 2210 dst.targetProfile.add(i.copy()); 2211 }; 2212 if (aggregation != null) { 2213 dst.aggregation = new ArrayList<Enumeration<AggregationMode>>(); 2214 for (Enumeration<AggregationMode> i : aggregation) 2215 dst.aggregation.add(i.copy()); 2216 }; 2217 dst.versioning = versioning == null ? null : versioning.copy(); 2218 } 2219 2220 @Override 2221 public boolean equalsDeep(Base other_) { 2222 if (!super.equalsDeep(other_)) 2223 return false; 2224 if (!(other_ instanceof TypeRefComponent)) 2225 return false; 2226 TypeRefComponent o = (TypeRefComponent) other_; 2227 return compareDeep(code, o.code, true) && compareDeep(profile, o.profile, true) && compareDeep(targetProfile, o.targetProfile, true) 2228 && compareDeep(aggregation, o.aggregation, true) && compareDeep(versioning, o.versioning, true) 2229 ; 2230 } 2231 2232 @Override 2233 public boolean equalsShallow(Base other_) { 2234 if (!super.equalsShallow(other_)) 2235 return false; 2236 if (!(other_ instanceof TypeRefComponent)) 2237 return false; 2238 TypeRefComponent o = (TypeRefComponent) other_; 2239 return compareValues(code, o.code, true) && compareValues(profile, o.profile, true) && compareValues(targetProfile, o.targetProfile, true) 2240 && compareValues(aggregation, o.aggregation, true) && compareValues(versioning, o.versioning, true) 2241 ; 2242 } 2243 2244 public boolean isEmpty() { 2245 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, profile, targetProfile 2246 , aggregation, versioning); 2247 } 2248 2249 public String fhirType() { 2250 return "ElementDefinition.type"; 2251 2252 } 2253 2254// added from java-adornments.txt: 2255 2256 public boolean hasTarget() { 2257 return Utilities.existsInList(getCode(), "Reference", "canonical", "CodeableReference"); 2258 } 2259 2260 /** 2261 * This code checks for the system prefix and returns the FHIR type 2262 * 2263 * @return 2264 */ 2265 public String getWorkingCode() { 2266 if (hasExtension(ToolingExtensions.EXT_FHIR_TYPE)) 2267 return getExtensionString(ToolingExtensions.EXT_FHIR_TYPE); 2268 if (!hasCodeElement()) 2269 return null; 2270 if (getCodeElement().hasExtension(ToolingExtensions.EXT_XML_TYPE)) { 2271 String s = getCodeElement().getExtensionString(ToolingExtensions.EXT_XML_TYPE); 2272 if ("xsd:gYear OR xsd:gYearMonth OR xsd:date OR xsd:dateTime".equalsIgnoreCase(s)) 2273 return "dateTime"; 2274 if ("xsd:gYear OR xsd:gYearMonth OR xsd:date".equalsIgnoreCase(s)) 2275 return "date"; 2276 if ("xsd:dateTime".equalsIgnoreCase(s)) 2277 return "instant"; 2278 if ("xsd:token".equals(s)) 2279 return "code"; 2280 if ("xsd:boolean".equals(s)) 2281 return "boolean"; 2282 if ("xsd:string".equals(s)) 2283 return "string"; 2284 if ("xsd:time".equals(s)) 2285 return "time"; 2286 if ("xsd:int".equals(s)) 2287 return "integer"; 2288 if ("xsd:decimal OR xsd:double".equals(s)) 2289 return "decimal"; 2290 if ("xsd:decimal".equalsIgnoreCase(s)) 2291 return "decimal"; 2292 if ("xsd:base64Binary".equalsIgnoreCase(s)) 2293 return "base64Binary"; 2294 if ("xsd:positiveInteger".equalsIgnoreCase(s)) 2295 return "positiveInt"; 2296 if ("xsd:nonNegativeInteger".equalsIgnoreCase(s)) 2297 return "unsignedInt"; 2298 if ("xsd:anyURI".equalsIgnoreCase(s)) 2299 return "uri"; 2300 2301 throw new Error("Unknown xml type '"+s+"'"); 2302 } 2303 return getCode(); 2304 } 2305 2306 @Override 2307 public String toString() { 2308 String res = getCode(); 2309 if (hasProfile()) { 2310 res = res + "{"; 2311 boolean first = true; 2312 for (CanonicalType s : getProfile()) { 2313 if (first) first = false; else res = res + "|"; 2314 res = res + s.getValue(); 2315 } 2316 res = res + "}"; 2317 } 2318 if (hasTargetProfile()) { 2319 res = res + "->("; 2320 boolean first = true; 2321 for (CanonicalType s : getTargetProfile()) { 2322 if (first) first = false; else res = res + "|"; 2323 res = res + s.getValue(); 2324 } 2325 res = res + ")"; 2326 } 2327 return res; 2328 } 2329 2330 public String getName() { 2331 return getWorkingCode(); 2332 } 2333 2334 public boolean isResourceReference() { 2335 return "Reference".equals(getCode()) && hasTargetProfile(); 2336 } 2337// end addition 2338 } 2339 2340 @Block() 2341 public static class ElementDefinitionExampleComponent extends Element implements IBaseDatatypeElement { 2342 /** 2343 * Describes the purpose of this example amoung the set of examples. 2344 */ 2345 @Child(name = "label", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 2346 @Description(shortDefinition="Describes the purpose of this example", formalDefinition="Describes the purpose of this example amoung the set of examples." ) 2347 protected StringType label; 2348 2349 /** 2350 * The actual value for the element, which must be one of the types allowed for this element. 2351 */ 2352 @Child(name = "value", type = {Base64BinaryType.class, BooleanType.class, CanonicalType.class, CodeType.class, DateType.class, DateTimeType.class, DecimalType.class, IdType.class, InstantType.class, IntegerType.class, Integer64Type.class, MarkdownType.class, OidType.class, PositiveIntType.class, StringType.class, TimeType.class, UnsignedIntType.class, UriType.class, UrlType.class, UuidType.class, Address.class, Age.class, Annotation.class, Attachment.class, CodeableConcept.class, Coding.class, ContactPoint.class, Count.class, Distance.class, Duration.class, HumanName.class, Identifier.class, Money.class, Period.class, Quantity.class, Range.class, Ratio.class, Reference.class, SampledData.class, Signature.class, Timing.class, ContactDetail.class, Contributor.class, DataRequirement.class, Expression.class, ParameterDefinition.class, RelatedArtifact.class, TriggerDefinition.class, UsageContext.class, Dosage.class, Meta.class}, order=2, min=1, max=1, modifier=false, summary=true) 2353 @Description(shortDefinition="Value of Example (one of allowed types)", formalDefinition="The actual value for the element, which must be one of the types allowed for this element." ) 2354 protected DataType value; 2355 2356 private static final long serialVersionUID = 463190922L; 2357 2358 /** 2359 * Constructor 2360 */ 2361 public ElementDefinitionExampleComponent() { 2362 super(); 2363 } 2364 2365 /** 2366 * Constructor 2367 */ 2368 public ElementDefinitionExampleComponent(String label, DataType value) { 2369 super(); 2370 this.setLabel(label); 2371 this.setValue(value); 2372 } 2373 2374 /** 2375 * @return {@link #label} (Describes the purpose of this example amoung the set of examples.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value 2376 */ 2377 public StringType getLabelElement() { 2378 if (this.label == null) 2379 if (Configuration.errorOnAutoCreate()) 2380 throw new Error("Attempt to auto-create ElementDefinitionExampleComponent.label"); 2381 else if (Configuration.doAutoCreate()) 2382 this.label = new StringType(); // bb 2383 return this.label; 2384 } 2385 2386 public boolean hasLabelElement() { 2387 return this.label != null && !this.label.isEmpty(); 2388 } 2389 2390 public boolean hasLabel() { 2391 return this.label != null && !this.label.isEmpty(); 2392 } 2393 2394 /** 2395 * @param value {@link #label} (Describes the purpose of this example amoung the set of examples.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value 2396 */ 2397 public ElementDefinitionExampleComponent setLabelElement(StringType value) { 2398 this.label = value; 2399 return this; 2400 } 2401 2402 /** 2403 * @return Describes the purpose of this example amoung the set of examples. 2404 */ 2405 public String getLabel() { 2406 return this.label == null ? null : this.label.getValue(); 2407 } 2408 2409 /** 2410 * @param value Describes the purpose of this example amoung the set of examples. 2411 */ 2412 public ElementDefinitionExampleComponent setLabel(String value) { 2413 if (this.label == null) 2414 this.label = new StringType(); 2415 this.label.setValue(value); 2416 return this; 2417 } 2418 2419 /** 2420 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2421 */ 2422 public DataType getValue() { 2423 return this.value; 2424 } 2425 2426 /** 2427 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2428 */ 2429 public Base64BinaryType getValueBase64BinaryType() throws FHIRException { 2430 if (this.value == null) 2431 this.value = new Base64BinaryType(); 2432 if (!(this.value instanceof Base64BinaryType)) 2433 throw new FHIRException("Type mismatch: the type Base64BinaryType was expected, but "+this.value.getClass().getName()+" was encountered"); 2434 return (Base64BinaryType) this.value; 2435 } 2436 2437 public boolean hasValueBase64BinaryType() { 2438 return this != null && this.value instanceof Base64BinaryType; 2439 } 2440 2441 /** 2442 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2443 */ 2444 public BooleanType getValueBooleanType() throws FHIRException { 2445 if (this.value == null) 2446 this.value = new BooleanType(); 2447 if (!(this.value instanceof BooleanType)) 2448 throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.value.getClass().getName()+" was encountered"); 2449 return (BooleanType) this.value; 2450 } 2451 2452 public boolean hasValueBooleanType() { 2453 return this != null && this.value instanceof BooleanType; 2454 } 2455 2456 /** 2457 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2458 */ 2459 public CanonicalType getValueCanonicalType() throws FHIRException { 2460 if (this.value == null) 2461 this.value = new CanonicalType(); 2462 if (!(this.value instanceof CanonicalType)) 2463 throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.value.getClass().getName()+" was encountered"); 2464 return (CanonicalType) this.value; 2465 } 2466 2467 public boolean hasValueCanonicalType() { 2468 return this != null && this.value instanceof CanonicalType; 2469 } 2470 2471 /** 2472 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2473 */ 2474 public CodeType getValueCodeType() throws FHIRException { 2475 if (this.value == null) 2476 this.value = new CodeType(); 2477 if (!(this.value instanceof CodeType)) 2478 throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.value.getClass().getName()+" was encountered"); 2479 return (CodeType) this.value; 2480 } 2481 2482 public boolean hasValueCodeType() { 2483 return this != null && this.value instanceof CodeType; 2484 } 2485 2486 /** 2487 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2488 */ 2489 public DateType getValueDateType() throws FHIRException { 2490 if (this.value == null) 2491 this.value = new DateType(); 2492 if (!(this.value instanceof DateType)) 2493 throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.value.getClass().getName()+" was encountered"); 2494 return (DateType) this.value; 2495 } 2496 2497 public boolean hasValueDateType() { 2498 return this != null && this.value instanceof DateType; 2499 } 2500 2501 /** 2502 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2503 */ 2504 public DateTimeType getValueDateTimeType() throws FHIRException { 2505 if (this.value == null) 2506 this.value = new DateTimeType(); 2507 if (!(this.value instanceof DateTimeType)) 2508 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.value.getClass().getName()+" was encountered"); 2509 return (DateTimeType) this.value; 2510 } 2511 2512 public boolean hasValueDateTimeType() { 2513 return this != null && this.value instanceof DateTimeType; 2514 } 2515 2516 /** 2517 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2518 */ 2519 public DecimalType getValueDecimalType() throws FHIRException { 2520 if (this.value == null) 2521 this.value = new DecimalType(); 2522 if (!(this.value instanceof DecimalType)) 2523 throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.value.getClass().getName()+" was encountered"); 2524 return (DecimalType) this.value; 2525 } 2526 2527 public boolean hasValueDecimalType() { 2528 return this != null && this.value instanceof DecimalType; 2529 } 2530 2531 /** 2532 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2533 */ 2534 public IdType getValueIdType() throws FHIRException { 2535 if (this.value == null) 2536 this.value = new IdType(); 2537 if (!(this.value instanceof IdType)) 2538 throw new FHIRException("Type mismatch: the type IdType was expected, but "+this.value.getClass().getName()+" was encountered"); 2539 return (IdType) this.value; 2540 } 2541 2542 public boolean hasValueIdType() { 2543 return this != null && this.value instanceof IdType; 2544 } 2545 2546 /** 2547 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2548 */ 2549 public InstantType getValueInstantType() throws FHIRException { 2550 if (this.value == null) 2551 this.value = new InstantType(); 2552 if (!(this.value instanceof InstantType)) 2553 throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.value.getClass().getName()+" was encountered"); 2554 return (InstantType) this.value; 2555 } 2556 2557 public boolean hasValueInstantType() { 2558 return this != null && this.value instanceof InstantType; 2559 } 2560 2561 /** 2562 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2563 */ 2564 public IntegerType getValueIntegerType() throws FHIRException { 2565 if (this.value == null) 2566 this.value = new IntegerType(); 2567 if (!(this.value instanceof IntegerType)) 2568 throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.value.getClass().getName()+" was encountered"); 2569 return (IntegerType) this.value; 2570 } 2571 2572 public boolean hasValueIntegerType() { 2573 return this != null && this.value instanceof IntegerType; 2574 } 2575 2576 /** 2577 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2578 */ 2579 public Integer64Type getValueInteger64Type() throws FHIRException { 2580 if (this.value == null) 2581 this.value = new Integer64Type(); 2582 if (!(this.value instanceof Integer64Type)) 2583 throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.value.getClass().getName()+" was encountered"); 2584 return (Integer64Type) this.value; 2585 } 2586 2587 public boolean hasValueInteger64Type() { 2588 return this != null && this.value instanceof Integer64Type; 2589 } 2590 2591 /** 2592 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2593 */ 2594 public MarkdownType getValueMarkdownType() throws FHIRException { 2595 if (this.value == null) 2596 this.value = new MarkdownType(); 2597 if (!(this.value instanceof MarkdownType)) 2598 throw new FHIRException("Type mismatch: the type MarkdownType was expected, but "+this.value.getClass().getName()+" was encountered"); 2599 return (MarkdownType) this.value; 2600 } 2601 2602 public boolean hasValueMarkdownType() { 2603 return this != null && this.value instanceof MarkdownType; 2604 } 2605 2606 /** 2607 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2608 */ 2609 public OidType getValueOidType() throws FHIRException { 2610 if (this.value == null) 2611 this.value = new OidType(); 2612 if (!(this.value instanceof OidType)) 2613 throw new FHIRException("Type mismatch: the type OidType was expected, but "+this.value.getClass().getName()+" was encountered"); 2614 return (OidType) this.value; 2615 } 2616 2617 public boolean hasValueOidType() { 2618 return this != null && this.value instanceof OidType; 2619 } 2620 2621 /** 2622 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2623 */ 2624 public PositiveIntType getValuePositiveIntType() throws FHIRException { 2625 if (this.value == null) 2626 this.value = new PositiveIntType(); 2627 if (!(this.value instanceof PositiveIntType)) 2628 throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.value.getClass().getName()+" was encountered"); 2629 return (PositiveIntType) this.value; 2630 } 2631 2632 public boolean hasValuePositiveIntType() { 2633 return this != null && this.value instanceof PositiveIntType; 2634 } 2635 2636 /** 2637 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2638 */ 2639 public StringType getValueStringType() throws FHIRException { 2640 if (this.value == null) 2641 this.value = new StringType(); 2642 if (!(this.value instanceof StringType)) 2643 throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.value.getClass().getName()+" was encountered"); 2644 return (StringType) this.value; 2645 } 2646 2647 public boolean hasValueStringType() { 2648 return this != null && this.value instanceof StringType; 2649 } 2650 2651 /** 2652 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2653 */ 2654 public TimeType getValueTimeType() throws FHIRException { 2655 if (this.value == null) 2656 this.value = new TimeType(); 2657 if (!(this.value instanceof TimeType)) 2658 throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.value.getClass().getName()+" was encountered"); 2659 return (TimeType) this.value; 2660 } 2661 2662 public boolean hasValueTimeType() { 2663 return this != null && this.value instanceof TimeType; 2664 } 2665 2666 /** 2667 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2668 */ 2669 public UnsignedIntType getValueUnsignedIntType() throws FHIRException { 2670 if (this.value == null) 2671 this.value = new UnsignedIntType(); 2672 if (!(this.value instanceof UnsignedIntType)) 2673 throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.value.getClass().getName()+" was encountered"); 2674 return (UnsignedIntType) this.value; 2675 } 2676 2677 public boolean hasValueUnsignedIntType() { 2678 return this != null && this.value instanceof UnsignedIntType; 2679 } 2680 2681 /** 2682 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2683 */ 2684 public UriType getValueUriType() throws FHIRException { 2685 if (this.value == null) 2686 this.value = new UriType(); 2687 if (!(this.value instanceof UriType)) 2688 throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.value.getClass().getName()+" was encountered"); 2689 return (UriType) this.value; 2690 } 2691 2692 public boolean hasValueUriType() { 2693 return this != null && this.value instanceof UriType; 2694 } 2695 2696 /** 2697 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2698 */ 2699 public UrlType getValueUrlType() throws FHIRException { 2700 if (this.value == null) 2701 this.value = new UrlType(); 2702 if (!(this.value instanceof UrlType)) 2703 throw new FHIRException("Type mismatch: the type UrlType was expected, but "+this.value.getClass().getName()+" was encountered"); 2704 return (UrlType) this.value; 2705 } 2706 2707 public boolean hasValueUrlType() { 2708 return this != null && this.value instanceof UrlType; 2709 } 2710 2711 /** 2712 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2713 */ 2714 public UuidType getValueUuidType() throws FHIRException { 2715 if (this.value == null) 2716 this.value = new UuidType(); 2717 if (!(this.value instanceof UuidType)) 2718 throw new FHIRException("Type mismatch: the type UuidType was expected, but "+this.value.getClass().getName()+" was encountered"); 2719 return (UuidType) this.value; 2720 } 2721 2722 public boolean hasValueUuidType() { 2723 return this != null && this.value instanceof UuidType; 2724 } 2725 2726 /** 2727 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2728 */ 2729 public Address getValueAddress() throws FHIRException { 2730 if (this.value == null) 2731 this.value = new Address(); 2732 if (!(this.value instanceof Address)) 2733 throw new FHIRException("Type mismatch: the type Address was expected, but "+this.value.getClass().getName()+" was encountered"); 2734 return (Address) this.value; 2735 } 2736 2737 public boolean hasValueAddress() { 2738 return this != null && this.value instanceof Address; 2739 } 2740 2741 /** 2742 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2743 */ 2744 public Age getValueAge() throws FHIRException { 2745 if (this.value == null) 2746 this.value = new Age(); 2747 if (!(this.value instanceof Age)) 2748 throw new FHIRException("Type mismatch: the type Age was expected, but "+this.value.getClass().getName()+" was encountered"); 2749 return (Age) this.value; 2750 } 2751 2752 public boolean hasValueAge() { 2753 return this != null && this.value instanceof Age; 2754 } 2755 2756 /** 2757 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2758 */ 2759 public Annotation getValueAnnotation() throws FHIRException { 2760 if (this.value == null) 2761 this.value = new Annotation(); 2762 if (!(this.value instanceof Annotation)) 2763 throw new FHIRException("Type mismatch: the type Annotation was expected, but "+this.value.getClass().getName()+" was encountered"); 2764 return (Annotation) this.value; 2765 } 2766 2767 public boolean hasValueAnnotation() { 2768 return this != null && this.value instanceof Annotation; 2769 } 2770 2771 /** 2772 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2773 */ 2774 public Attachment getValueAttachment() throws FHIRException { 2775 if (this.value == null) 2776 this.value = new Attachment(); 2777 if (!(this.value instanceof Attachment)) 2778 throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.value.getClass().getName()+" was encountered"); 2779 return (Attachment) this.value; 2780 } 2781 2782 public boolean hasValueAttachment() { 2783 return this != null && this.value instanceof Attachment; 2784 } 2785 2786 /** 2787 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2788 */ 2789 public CodeableConcept getValueCodeableConcept() throws FHIRException { 2790 if (this.value == null) 2791 this.value = new CodeableConcept(); 2792 if (!(this.value instanceof CodeableConcept)) 2793 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.value.getClass().getName()+" was encountered"); 2794 return (CodeableConcept) this.value; 2795 } 2796 2797 public boolean hasValueCodeableConcept() { 2798 return this != null && this.value instanceof CodeableConcept; 2799 } 2800 2801 /** 2802 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2803 */ 2804 public Coding getValueCoding() throws FHIRException { 2805 if (this.value == null) 2806 this.value = new Coding(); 2807 if (!(this.value instanceof Coding)) 2808 throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.value.getClass().getName()+" was encountered"); 2809 return (Coding) this.value; 2810 } 2811 2812 public boolean hasValueCoding() { 2813 return this != null && this.value instanceof Coding; 2814 } 2815 2816 /** 2817 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2818 */ 2819 public ContactPoint getValueContactPoint() throws FHIRException { 2820 if (this.value == null) 2821 this.value = new ContactPoint(); 2822 if (!(this.value instanceof ContactPoint)) 2823 throw new FHIRException("Type mismatch: the type ContactPoint was expected, but "+this.value.getClass().getName()+" was encountered"); 2824 return (ContactPoint) this.value; 2825 } 2826 2827 public boolean hasValueContactPoint() { 2828 return this != null && this.value instanceof ContactPoint; 2829 } 2830 2831 /** 2832 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2833 */ 2834 public Count getValueCount() throws FHIRException { 2835 if (this.value == null) 2836 this.value = new Count(); 2837 if (!(this.value instanceof Count)) 2838 throw new FHIRException("Type mismatch: the type Count was expected, but "+this.value.getClass().getName()+" was encountered"); 2839 return (Count) this.value; 2840 } 2841 2842 public boolean hasValueCount() { 2843 return this != null && this.value instanceof Count; 2844 } 2845 2846 /** 2847 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2848 */ 2849 public Distance getValueDistance() throws FHIRException { 2850 if (this.value == null) 2851 this.value = new Distance(); 2852 if (!(this.value instanceof Distance)) 2853 throw new FHIRException("Type mismatch: the type Distance was expected, but "+this.value.getClass().getName()+" was encountered"); 2854 return (Distance) this.value; 2855 } 2856 2857 public boolean hasValueDistance() { 2858 return this != null && this.value instanceof Distance; 2859 } 2860 2861 /** 2862 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2863 */ 2864 public Duration getValueDuration() throws FHIRException { 2865 if (this.value == null) 2866 this.value = new Duration(); 2867 if (!(this.value instanceof Duration)) 2868 throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.value.getClass().getName()+" was encountered"); 2869 return (Duration) this.value; 2870 } 2871 2872 public boolean hasValueDuration() { 2873 return this != null && this.value instanceof Duration; 2874 } 2875 2876 /** 2877 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2878 */ 2879 public HumanName getValueHumanName() throws FHIRException { 2880 if (this.value == null) 2881 this.value = new HumanName(); 2882 if (!(this.value instanceof HumanName)) 2883 throw new FHIRException("Type mismatch: the type HumanName was expected, but "+this.value.getClass().getName()+" was encountered"); 2884 return (HumanName) this.value; 2885 } 2886 2887 public boolean hasValueHumanName() { 2888 return this != null && this.value instanceof HumanName; 2889 } 2890 2891 /** 2892 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2893 */ 2894 public Identifier getValueIdentifier() throws FHIRException { 2895 if (this.value == null) 2896 this.value = new Identifier(); 2897 if (!(this.value instanceof Identifier)) 2898 throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.value.getClass().getName()+" was encountered"); 2899 return (Identifier) this.value; 2900 } 2901 2902 public boolean hasValueIdentifier() { 2903 return this != null && this.value instanceof Identifier; 2904 } 2905 2906 /** 2907 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2908 */ 2909 public Money getValueMoney() throws FHIRException { 2910 if (this.value == null) 2911 this.value = new Money(); 2912 if (!(this.value instanceof Money)) 2913 throw new FHIRException("Type mismatch: the type Money was expected, but "+this.value.getClass().getName()+" was encountered"); 2914 return (Money) this.value; 2915 } 2916 2917 public boolean hasValueMoney() { 2918 return this != null && this.value instanceof Money; 2919 } 2920 2921 /** 2922 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2923 */ 2924 public Period getValuePeriod() throws FHIRException { 2925 if (this.value == null) 2926 this.value = new Period(); 2927 if (!(this.value instanceof Period)) 2928 throw new FHIRException("Type mismatch: the type Period was expected, but "+this.value.getClass().getName()+" was encountered"); 2929 return (Period) this.value; 2930 } 2931 2932 public boolean hasValuePeriod() { 2933 return this != null && this.value instanceof Period; 2934 } 2935 2936 /** 2937 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2938 */ 2939 public Quantity getValueQuantity() throws FHIRException { 2940 if (this.value == null) 2941 this.value = new Quantity(); 2942 if (!(this.value instanceof Quantity)) 2943 throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.value.getClass().getName()+" was encountered"); 2944 return (Quantity) this.value; 2945 } 2946 2947 public boolean hasValueQuantity() { 2948 return this != null && this.value instanceof Quantity; 2949 } 2950 2951 /** 2952 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2953 */ 2954 public Range getValueRange() throws FHIRException { 2955 if (this.value == null) 2956 this.value = new Range(); 2957 if (!(this.value instanceof Range)) 2958 throw new FHIRException("Type mismatch: the type Range was expected, but "+this.value.getClass().getName()+" was encountered"); 2959 return (Range) this.value; 2960 } 2961 2962 public boolean hasValueRange() { 2963 return this != null && this.value instanceof Range; 2964 } 2965 2966 /** 2967 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2968 */ 2969 public Ratio getValueRatio() throws FHIRException { 2970 if (this.value == null) 2971 this.value = new Ratio(); 2972 if (!(this.value instanceof Ratio)) 2973 throw new FHIRException("Type mismatch: the type Ratio was expected, but "+this.value.getClass().getName()+" was encountered"); 2974 return (Ratio) this.value; 2975 } 2976 2977 public boolean hasValueRatio() { 2978 return this != null && this.value instanceof Ratio; 2979 } 2980 2981 /** 2982 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2983 */ 2984 public Reference getValueReference() throws FHIRException { 2985 if (this.value == null) 2986 this.value = new Reference(); 2987 if (!(this.value instanceof Reference)) 2988 throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.value.getClass().getName()+" was encountered"); 2989 return (Reference) this.value; 2990 } 2991 2992 public boolean hasValueReference() { 2993 return this != null && this.value instanceof Reference; 2994 } 2995 2996 /** 2997 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 2998 */ 2999 public SampledData getValueSampledData() throws FHIRException { 3000 if (this.value == null) 3001 this.value = new SampledData(); 3002 if (!(this.value instanceof SampledData)) 3003 throw new FHIRException("Type mismatch: the type SampledData was expected, but "+this.value.getClass().getName()+" was encountered"); 3004 return (SampledData) this.value; 3005 } 3006 3007 public boolean hasValueSampledData() { 3008 return this != null && this.value instanceof SampledData; 3009 } 3010 3011 /** 3012 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3013 */ 3014 public Signature getValueSignature() throws FHIRException { 3015 if (this.value == null) 3016 this.value = new Signature(); 3017 if (!(this.value instanceof Signature)) 3018 throw new FHIRException("Type mismatch: the type Signature was expected, but "+this.value.getClass().getName()+" was encountered"); 3019 return (Signature) this.value; 3020 } 3021 3022 public boolean hasValueSignature() { 3023 return this != null && this.value instanceof Signature; 3024 } 3025 3026 /** 3027 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3028 */ 3029 public Timing getValueTiming() throws FHIRException { 3030 if (this.value == null) 3031 this.value = new Timing(); 3032 if (!(this.value instanceof Timing)) 3033 throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.value.getClass().getName()+" was encountered"); 3034 return (Timing) this.value; 3035 } 3036 3037 public boolean hasValueTiming() { 3038 return this != null && this.value instanceof Timing; 3039 } 3040 3041 /** 3042 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3043 */ 3044 public ContactDetail getValueContactDetail() throws FHIRException { 3045 if (this.value == null) 3046 this.value = new ContactDetail(); 3047 if (!(this.value instanceof ContactDetail)) 3048 throw new FHIRException("Type mismatch: the type ContactDetail was expected, but "+this.value.getClass().getName()+" was encountered"); 3049 return (ContactDetail) this.value; 3050 } 3051 3052 public boolean hasValueContactDetail() { 3053 return this != null && this.value instanceof ContactDetail; 3054 } 3055 3056 /** 3057 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3058 */ 3059 public Contributor getValueContributor() throws FHIRException { 3060 if (this.value == null) 3061 this.value = new Contributor(); 3062 if (!(this.value instanceof Contributor)) 3063 throw new FHIRException("Type mismatch: the type Contributor was expected, but "+this.value.getClass().getName()+" was encountered"); 3064 return (Contributor) this.value; 3065 } 3066 3067 public boolean hasValueContributor() { 3068 return this != null && this.value instanceof Contributor; 3069 } 3070 3071 /** 3072 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3073 */ 3074 public DataRequirement getValueDataRequirement() throws FHIRException { 3075 if (this.value == null) 3076 this.value = new DataRequirement(); 3077 if (!(this.value instanceof DataRequirement)) 3078 throw new FHIRException("Type mismatch: the type DataRequirement was expected, but "+this.value.getClass().getName()+" was encountered"); 3079 return (DataRequirement) this.value; 3080 } 3081 3082 public boolean hasValueDataRequirement() { 3083 return this != null && this.value instanceof DataRequirement; 3084 } 3085 3086 /** 3087 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3088 */ 3089 public Expression getValueExpression() throws FHIRException { 3090 if (this.value == null) 3091 this.value = new Expression(); 3092 if (!(this.value instanceof Expression)) 3093 throw new FHIRException("Type mismatch: the type Expression was expected, but "+this.value.getClass().getName()+" was encountered"); 3094 return (Expression) this.value; 3095 } 3096 3097 public boolean hasValueExpression() { 3098 return this != null && this.value instanceof Expression; 3099 } 3100 3101 /** 3102 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3103 */ 3104 public ParameterDefinition getValueParameterDefinition() throws FHIRException { 3105 if (this.value == null) 3106 this.value = new ParameterDefinition(); 3107 if (!(this.value instanceof ParameterDefinition)) 3108 throw new FHIRException("Type mismatch: the type ParameterDefinition was expected, but "+this.value.getClass().getName()+" was encountered"); 3109 return (ParameterDefinition) this.value; 3110 } 3111 3112 public boolean hasValueParameterDefinition() { 3113 return this != null && this.value instanceof ParameterDefinition; 3114 } 3115 3116 /** 3117 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3118 */ 3119 public RelatedArtifact getValueRelatedArtifact() throws FHIRException { 3120 if (this.value == null) 3121 this.value = new RelatedArtifact(); 3122 if (!(this.value instanceof RelatedArtifact)) 3123 throw new FHIRException("Type mismatch: the type RelatedArtifact was expected, but "+this.value.getClass().getName()+" was encountered"); 3124 return (RelatedArtifact) this.value; 3125 } 3126 3127 public boolean hasValueRelatedArtifact() { 3128 return this != null && this.value instanceof RelatedArtifact; 3129 } 3130 3131 /** 3132 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3133 */ 3134 public TriggerDefinition getValueTriggerDefinition() throws FHIRException { 3135 if (this.value == null) 3136 this.value = new TriggerDefinition(); 3137 if (!(this.value instanceof TriggerDefinition)) 3138 throw new FHIRException("Type mismatch: the type TriggerDefinition was expected, but "+this.value.getClass().getName()+" was encountered"); 3139 return (TriggerDefinition) this.value; 3140 } 3141 3142 public boolean hasValueTriggerDefinition() { 3143 return this != null && this.value instanceof TriggerDefinition; 3144 } 3145 3146 /** 3147 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3148 */ 3149 public UsageContext getValueUsageContext() throws FHIRException { 3150 if (this.value == null) 3151 this.value = new UsageContext(); 3152 if (!(this.value instanceof UsageContext)) 3153 throw new FHIRException("Type mismatch: the type UsageContext was expected, but "+this.value.getClass().getName()+" was encountered"); 3154 return (UsageContext) this.value; 3155 } 3156 3157 public boolean hasValueUsageContext() { 3158 return this != null && this.value instanceof UsageContext; 3159 } 3160 3161 /** 3162 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3163 */ 3164 public Dosage getValueDosage() throws FHIRException { 3165 if (this.value == null) 3166 this.value = new Dosage(); 3167 if (!(this.value instanceof Dosage)) 3168 throw new FHIRException("Type mismatch: the type Dosage was expected, but "+this.value.getClass().getName()+" was encountered"); 3169 return (Dosage) this.value; 3170 } 3171 3172 public boolean hasValueDosage() { 3173 return this != null && this.value instanceof Dosage; 3174 } 3175 3176 /** 3177 * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3178 */ 3179 public Meta getValueMeta() throws FHIRException { 3180 if (this.value == null) 3181 this.value = new Meta(); 3182 if (!(this.value instanceof Meta)) 3183 throw new FHIRException("Type mismatch: the type Meta was expected, but "+this.value.getClass().getName()+" was encountered"); 3184 return (Meta) this.value; 3185 } 3186 3187 public boolean hasValueMeta() { 3188 return this != null && this.value instanceof Meta; 3189 } 3190 3191 public boolean hasValue() { 3192 return this.value != null && !this.value.isEmpty(); 3193 } 3194 3195 /** 3196 * @param value {@link #value} (The actual value for the element, which must be one of the types allowed for this element.) 3197 */ 3198 public ElementDefinitionExampleComponent setValue(DataType value) { 3199 if (value != null && !(value instanceof Base64BinaryType || value instanceof BooleanType || value instanceof CanonicalType || value instanceof CodeType || value instanceof DateType || value instanceof DateTimeType || value instanceof DecimalType || value instanceof IdType || value instanceof InstantType || value instanceof IntegerType || value instanceof Integer64Type || value instanceof MarkdownType || value instanceof OidType || value instanceof PositiveIntType || value instanceof StringType || value instanceof TimeType || value instanceof UnsignedIntType || value instanceof UriType || value instanceof UrlType || value instanceof UuidType || value instanceof Address || value instanceof Age || value instanceof Annotation || value instanceof Attachment || value instanceof CodeableConcept || value instanceof Coding || value instanceof ContactPoint || value instanceof Count || value instanceof Distance || value instanceof Duration || value instanceof HumanName || value instanceof Identifier || value instanceof Money || value instanceof Period || value instanceof Quantity || value instanceof Range || value instanceof Ratio || value instanceof Reference || value instanceof SampledData || value instanceof Signature || value instanceof Timing || value instanceof ContactDetail || value instanceof Contributor || value instanceof DataRequirement || value instanceof Expression || value instanceof ParameterDefinition || value instanceof RelatedArtifact || value instanceof TriggerDefinition || value instanceof UsageContext || value instanceof Dosage || value instanceof Meta)) 3200 throw new Error("Not the right type for ElementDefinition.example.value[x]: "+value.fhirType()); 3201 this.value = value; 3202 return this; 3203 } 3204 3205 protected void listChildren(List<Property> children) { 3206 super.listChildren(children); 3207 children.add(new Property("label", "string", "Describes the purpose of this example amoung the set of examples.", 0, 1, label)); 3208 children.add(new Property("value[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value)); 3209 } 3210 3211 @Override 3212 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3213 switch (_hash) { 3214 case 102727412: /*label*/ return new Property("label", "string", "Describes the purpose of this example amoung the set of examples.", 0, 1, label); 3215 case -1410166417: /*value[x]*/ return new Property("value[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3216 case 111972721: /*value*/ return new Property("value[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3217 case -1535024575: /*valueBase64Binary*/ return new Property("value[x]", "base64Binary", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3218 case 733421943: /*valueBoolean*/ return new Property("value[x]", "boolean", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3219 case -786218365: /*valueCanonical*/ return new Property("value[x]", "canonical", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3220 case -766209282: /*valueCode*/ return new Property("value[x]", "code", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3221 case -766192449: /*valueDate*/ return new Property("value[x]", "date", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3222 case 1047929900: /*valueDateTime*/ return new Property("value[x]", "dateTime", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3223 case -2083993440: /*valueDecimal*/ return new Property("value[x]", "decimal", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3224 case 231604844: /*valueId*/ return new Property("value[x]", "id", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3225 case -1668687056: /*valueInstant*/ return new Property("value[x]", "instant", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3226 case -1668204915: /*valueInteger*/ return new Property("value[x]", "integer", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3227 case -1122120181: /*valueInteger64*/ return new Property("value[x]", "integer64", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3228 case -497880704: /*valueMarkdown*/ return new Property("value[x]", "markdown", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3229 case -1410178407: /*valueOid*/ return new Property("value[x]", "oid", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3230 case -1249932027: /*valuePositiveInt*/ return new Property("value[x]", "positiveInt", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3231 case -1424603934: /*valueString*/ return new Property("value[x]", "string", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3232 case -765708322: /*valueTime*/ return new Property("value[x]", "time", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3233 case 26529417: /*valueUnsignedInt*/ return new Property("value[x]", "unsignedInt", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3234 case -1410172357: /*valueUri*/ return new Property("value[x]", "uri", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3235 case -1410172354: /*valueUrl*/ return new Property("value[x]", "url", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3236 case -765667124: /*valueUuid*/ return new Property("value[x]", "uuid", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3237 case -478981821: /*valueAddress*/ return new Property("value[x]", "Address", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3238 case -1410191922: /*valueAge*/ return new Property("value[x]", "Age", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3239 case -67108992: /*valueAnnotation*/ return new Property("value[x]", "Annotation", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3240 case -475566732: /*valueAttachment*/ return new Property("value[x]", "Attachment", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3241 case 924902896: /*valueCodeableConcept*/ return new Property("value[x]", "CodeableConcept", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3242 case -1887705029: /*valueCoding*/ return new Property("value[x]", "Coding", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3243 case 944904545: /*valueContactPoint*/ return new Property("value[x]", "ContactPoint", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3244 case 2017332766: /*valueCount*/ return new Property("value[x]", "Count", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3245 case -456359802: /*valueDistance*/ return new Property("value[x]", "Distance", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3246 case 1558135333: /*valueDuration*/ return new Property("value[x]", "Duration", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3247 case -2026205465: /*valueHumanName*/ return new Property("value[x]", "HumanName", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3248 case -130498310: /*valueIdentifier*/ return new Property("value[x]", "Identifier", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3249 case 2026560975: /*valueMoney*/ return new Property("value[x]", "Money", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3250 case -1524344174: /*valuePeriod*/ return new Property("value[x]", "Period", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3251 case -2029823716: /*valueQuantity*/ return new Property("value[x]", "Quantity", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3252 case 2030761548: /*valueRange*/ return new Property("value[x]", "Range", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3253 case 2030767386: /*valueRatio*/ return new Property("value[x]", "Ratio", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3254 case 1755241690: /*valueReference*/ return new Property("value[x]", "Reference", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3255 case -962229101: /*valueSampledData*/ return new Property("value[x]", "SampledData", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3256 case -540985785: /*valueSignature*/ return new Property("value[x]", "Signature", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3257 case -1406282469: /*valueTiming*/ return new Property("value[x]", "Timing", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3258 case -1125200224: /*valueContactDetail*/ return new Property("value[x]", "ContactDetail", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3259 case 1281021610: /*valueContributor*/ return new Property("value[x]", "Contributor", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3260 case 1710554248: /*valueDataRequirement*/ return new Property("value[x]", "DataRequirement", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3261 case -307517719: /*valueExpression*/ return new Property("value[x]", "Expression", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3262 case 1387478187: /*valueParameterDefinition*/ return new Property("value[x]", "ParameterDefinition", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3263 case 1748214124: /*valueRelatedArtifact*/ return new Property("value[x]", "RelatedArtifact", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3264 case 976830394: /*valueTriggerDefinition*/ return new Property("value[x]", "TriggerDefinition", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3265 case 588000479: /*valueUsageContext*/ return new Property("value[x]", "UsageContext", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3266 case -1858636920: /*valueDosage*/ return new Property("value[x]", "Dosage", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3267 case -765920490: /*valueMeta*/ return new Property("value[x]", "Meta", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value); 3268 default: return super.getNamedProperty(_hash, _name, _checkValid); 3269 } 3270 3271 } 3272 3273 @Override 3274 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3275 switch (hash) { 3276 case 102727412: /*label*/ return this.label == null ? new Base[0] : new Base[] {this.label}; // StringType 3277 case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // DataType 3278 default: return super.getProperty(hash, name, checkValid); 3279 } 3280 3281 } 3282 3283 @Override 3284 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3285 switch (hash) { 3286 case 102727412: // label 3287 this.label = TypeConvertor.castToString(value); // StringType 3288 return value; 3289 case 111972721: // value 3290 this.value = TypeConvertor.castToType(value); // DataType 3291 return value; 3292 default: return super.setProperty(hash, name, value); 3293 } 3294 3295 } 3296 3297 @Override 3298 public Base setProperty(String name, Base value) throws FHIRException { 3299 if (name.equals("label")) { 3300 this.label = TypeConvertor.castToString(value); // StringType 3301 } else if (name.equals("value[x]")) { 3302 this.value = TypeConvertor.castToType(value); // DataType 3303 } else 3304 return super.setProperty(name, value); 3305 return value; 3306 } 3307 3308 @Override 3309 public Base makeProperty(int hash, String name) throws FHIRException { 3310 switch (hash) { 3311 case 102727412: return getLabelElement(); 3312 case -1410166417: return getValue(); 3313 case 111972721: return getValue(); 3314 default: return super.makeProperty(hash, name); 3315 } 3316 3317 } 3318 3319 @Override 3320 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3321 switch (hash) { 3322 case 102727412: /*label*/ return new String[] {"string"}; 3323 case 111972721: /*value*/ return new String[] {"base64Binary", "boolean", "canonical", "code", "date", "dateTime", "decimal", "id", "instant", "integer", "integer64", "markdown", "oid", "positiveInt", "string", "time", "unsignedInt", "uri", "url", "uuid", "Address", "Age", "Annotation", "Attachment", "CodeableConcept", "Coding", "ContactPoint", "Count", "Distance", "Duration", "HumanName", "Identifier", "Money", "Period", "Quantity", "Range", "Ratio", "Reference", "SampledData", "Signature", "Timing", "ContactDetail", "Contributor", "DataRequirement", "Expression", "ParameterDefinition", "RelatedArtifact", "TriggerDefinition", "UsageContext", "Dosage", "Meta"}; 3324 default: return super.getTypesForProperty(hash, name); 3325 } 3326 3327 } 3328 3329 @Override 3330 public Base addChild(String name) throws FHIRException { 3331 if (name.equals("label")) { 3332 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.example.label"); 3333 } 3334 else if (name.equals("valueBase64Binary")) { 3335 this.value = new Base64BinaryType(); 3336 return this.value; 3337 } 3338 else if (name.equals("valueBoolean")) { 3339 this.value = new BooleanType(); 3340 return this.value; 3341 } 3342 else if (name.equals("valueCanonical")) { 3343 this.value = new CanonicalType(); 3344 return this.value; 3345 } 3346 else if (name.equals("valueCode")) { 3347 this.value = new CodeType(); 3348 return this.value; 3349 } 3350 else if (name.equals("valueDate")) { 3351 this.value = new DateType(); 3352 return this.value; 3353 } 3354 else if (name.equals("valueDateTime")) { 3355 this.value = new DateTimeType(); 3356 return this.value; 3357 } 3358 else if (name.equals("valueDecimal")) { 3359 this.value = new DecimalType(); 3360 return this.value; 3361 } 3362 else if (name.equals("valueId")) { 3363 this.value = new IdType(); 3364 return this.value; 3365 } 3366 else if (name.equals("valueInstant")) { 3367 this.value = new InstantType(); 3368 return this.value; 3369 } 3370 else if (name.equals("valueInteger")) { 3371 this.value = new IntegerType(); 3372 return this.value; 3373 } 3374 else if (name.equals("valueInteger64")) { 3375 this.value = new Integer64Type(); 3376 return this.value; 3377 } 3378 else if (name.equals("valueMarkdown")) { 3379 this.value = new MarkdownType(); 3380 return this.value; 3381 } 3382 else if (name.equals("valueOid")) { 3383 this.value = new OidType(); 3384 return this.value; 3385 } 3386 else if (name.equals("valuePositiveInt")) { 3387 this.value = new PositiveIntType(); 3388 return this.value; 3389 } 3390 else if (name.equals("valueString")) { 3391 this.value = new StringType(); 3392 return this.value; 3393 } 3394 else if (name.equals("valueTime")) { 3395 this.value = new TimeType(); 3396 return this.value; 3397 } 3398 else if (name.equals("valueUnsignedInt")) { 3399 this.value = new UnsignedIntType(); 3400 return this.value; 3401 } 3402 else if (name.equals("valueUri")) { 3403 this.value = new UriType(); 3404 return this.value; 3405 } 3406 else if (name.equals("valueUrl")) { 3407 this.value = new UrlType(); 3408 return this.value; 3409 } 3410 else if (name.equals("valueUuid")) { 3411 this.value = new UuidType(); 3412 return this.value; 3413 } 3414 else if (name.equals("valueAddress")) { 3415 this.value = new Address(); 3416 return this.value; 3417 } 3418 else if (name.equals("valueAge")) { 3419 this.value = new Age(); 3420 return this.value; 3421 } 3422 else if (name.equals("valueAnnotation")) { 3423 this.value = new Annotation(); 3424 return this.value; 3425 } 3426 else if (name.equals("valueAttachment")) { 3427 this.value = new Attachment(); 3428 return this.value; 3429 } 3430 else if (name.equals("valueCodeableConcept")) { 3431 this.value = new CodeableConcept(); 3432 return this.value; 3433 } 3434 else if (name.equals("valueCoding")) { 3435 this.value = new Coding(); 3436 return this.value; 3437 } 3438 else if (name.equals("valueContactPoint")) { 3439 this.value = new ContactPoint(); 3440 return this.value; 3441 } 3442 else if (name.equals("valueCount")) { 3443 this.value = new Count(); 3444 return this.value; 3445 } 3446 else if (name.equals("valueDistance")) { 3447 this.value = new Distance(); 3448 return this.value; 3449 } 3450 else if (name.equals("valueDuration")) { 3451 this.value = new Duration(); 3452 return this.value; 3453 } 3454 else if (name.equals("valueHumanName")) { 3455 this.value = new HumanName(); 3456 return this.value; 3457 } 3458 else if (name.equals("valueIdentifier")) { 3459 this.value = new Identifier(); 3460 return this.value; 3461 } 3462 else if (name.equals("valueMoney")) { 3463 this.value = new Money(); 3464 return this.value; 3465 } 3466 else if (name.equals("valuePeriod")) { 3467 this.value = new Period(); 3468 return this.value; 3469 } 3470 else if (name.equals("valueQuantity")) { 3471 this.value = new Quantity(); 3472 return this.value; 3473 } 3474 else if (name.equals("valueRange")) { 3475 this.value = new Range(); 3476 return this.value; 3477 } 3478 else if (name.equals("valueRatio")) { 3479 this.value = new Ratio(); 3480 return this.value; 3481 } 3482 else if (name.equals("valueReference")) { 3483 this.value = new Reference(); 3484 return this.value; 3485 } 3486 else if (name.equals("valueSampledData")) { 3487 this.value = new SampledData(); 3488 return this.value; 3489 } 3490 else if (name.equals("valueSignature")) { 3491 this.value = new Signature(); 3492 return this.value; 3493 } 3494 else if (name.equals("valueTiming")) { 3495 this.value = new Timing(); 3496 return this.value; 3497 } 3498 else if (name.equals("valueContactDetail")) { 3499 this.value = new ContactDetail(); 3500 return this.value; 3501 } 3502 else if (name.equals("valueContributor")) { 3503 this.value = new Contributor(); 3504 return this.value; 3505 } 3506 else if (name.equals("valueDataRequirement")) { 3507 this.value = new DataRequirement(); 3508 return this.value; 3509 } 3510 else if (name.equals("valueExpression")) { 3511 this.value = new Expression(); 3512 return this.value; 3513 } 3514 else if (name.equals("valueParameterDefinition")) { 3515 this.value = new ParameterDefinition(); 3516 return this.value; 3517 } 3518 else if (name.equals("valueRelatedArtifact")) { 3519 this.value = new RelatedArtifact(); 3520 return this.value; 3521 } 3522 else if (name.equals("valueTriggerDefinition")) { 3523 this.value = new TriggerDefinition(); 3524 return this.value; 3525 } 3526 else if (name.equals("valueUsageContext")) { 3527 this.value = new UsageContext(); 3528 return this.value; 3529 } 3530 else if (name.equals("valueDosage")) { 3531 this.value = new Dosage(); 3532 return this.value; 3533 } 3534 else if (name.equals("valueMeta")) { 3535 this.value = new Meta(); 3536 return this.value; 3537 } 3538 else 3539 return super.addChild(name); 3540 } 3541 3542 public ElementDefinitionExampleComponent copy() { 3543 ElementDefinitionExampleComponent dst = new ElementDefinitionExampleComponent(); 3544 copyValues(dst); 3545 return dst; 3546 } 3547 3548 public void copyValues(ElementDefinitionExampleComponent dst) { 3549 super.copyValues(dst); 3550 dst.label = label == null ? null : label.copy(); 3551 dst.value = value == null ? null : value.copy(); 3552 } 3553 3554 @Override 3555 public boolean equalsDeep(Base other_) { 3556 if (!super.equalsDeep(other_)) 3557 return false; 3558 if (!(other_ instanceof ElementDefinitionExampleComponent)) 3559 return false; 3560 ElementDefinitionExampleComponent o = (ElementDefinitionExampleComponent) other_; 3561 return compareDeep(label, o.label, true) && compareDeep(value, o.value, true); 3562 } 3563 3564 @Override 3565 public boolean equalsShallow(Base other_) { 3566 if (!super.equalsShallow(other_)) 3567 return false; 3568 if (!(other_ instanceof ElementDefinitionExampleComponent)) 3569 return false; 3570 ElementDefinitionExampleComponent o = (ElementDefinitionExampleComponent) other_; 3571 return compareValues(label, o.label, true); 3572 } 3573 3574 public boolean isEmpty() { 3575 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(label, value); 3576 } 3577 3578 public String fhirType() { 3579 return "ElementDefinition.example"; 3580 3581 } 3582 3583 } 3584 3585 @Block() 3586 public static class ElementDefinitionConstraintComponent extends Element implements IBaseDatatypeElement { 3587 /** 3588 * Allows identification of which elements have their cardinalities impacted by the constraint. Will not be referenced for constraints that do not affect cardinality. 3589 */ 3590 @Child(name = "key", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=true) 3591 @Description(shortDefinition="Target of 'condition' reference above", formalDefinition="Allows identification of which elements have their cardinalities impacted by the constraint. Will not be referenced for constraints that do not affect cardinality." ) 3592 protected IdType key; 3593 3594 /** 3595 * Description of why this constraint is necessary or appropriate. 3596 */ 3597 @Child(name = "requirements", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 3598 @Description(shortDefinition="Why this constraint is necessary or appropriate", formalDefinition="Description of why this constraint is necessary or appropriate." ) 3599 protected StringType requirements; 3600 3601 /** 3602 * Identifies the impact constraint violation has on the conformance of the instance. 3603 */ 3604 @Child(name = "severity", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true) 3605 @Description(shortDefinition="error | warning", formalDefinition="Identifies the impact constraint violation has on the conformance of the instance." ) 3606 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/constraint-severity") 3607 protected Enumeration<ConstraintSeverity> severity; 3608 3609 /** 3610 * Text that can be used to describe the constraint in messages identifying that the constraint has been violated. 3611 */ 3612 @Child(name = "human", type = {StringType.class}, order=4, min=1, max=1, modifier=false, summary=true) 3613 @Description(shortDefinition="Human description of constraint", formalDefinition="Text that can be used to describe the constraint in messages identifying that the constraint has been violated." ) 3614 protected StringType human; 3615 3616 /** 3617 * A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met. 3618 */ 3619 @Child(name = "expression", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true) 3620 @Description(shortDefinition="FHIRPath expression of constraint", formalDefinition="A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met." ) 3621 protected StringType expression; 3622 3623 /** 3624 * An XPath expression of constraint that can be executed to see if this constraint is met. 3625 */ 3626 @Child(name = "xpath", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=true) 3627 @Description(shortDefinition="XPath expression of constraint", formalDefinition="An XPath expression of constraint that can be executed to see if this constraint is met." ) 3628 protected StringType xpath; 3629 3630 /** 3631 * A reference to the original source of the constraint, for traceability purposes. 3632 */ 3633 @Child(name = "source", type = {CanonicalType.class}, order=7, min=0, max=1, modifier=false, summary=true) 3634 @Description(shortDefinition="Reference to original source of constraint", formalDefinition="A reference to the original source of the constraint, for traceability purposes." ) 3635 protected CanonicalType source; 3636 3637 private static final long serialVersionUID = 1048354565L; 3638 3639 /** 3640 * Constructor 3641 */ 3642 public ElementDefinitionConstraintComponent() { 3643 super(); 3644 } 3645 3646 /** 3647 * Constructor 3648 */ 3649 public ElementDefinitionConstraintComponent(String key, ConstraintSeverity severity, String human) { 3650 super(); 3651 this.setKey(key); 3652 this.setSeverity(severity); 3653 this.setHuman(human); 3654 } 3655 3656 /** 3657 * @return {@link #key} (Allows identification of which elements have their cardinalities impacted by the constraint. Will not be referenced for constraints that do not affect cardinality.). This is the underlying object with id, value and extensions. The accessor "getKey" gives direct access to the value 3658 */ 3659 public IdType getKeyElement() { 3660 if (this.key == null) 3661 if (Configuration.errorOnAutoCreate()) 3662 throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.key"); 3663 else if (Configuration.doAutoCreate()) 3664 this.key = new IdType(); // bb 3665 return this.key; 3666 } 3667 3668 public boolean hasKeyElement() { 3669 return this.key != null && !this.key.isEmpty(); 3670 } 3671 3672 public boolean hasKey() { 3673 return this.key != null && !this.key.isEmpty(); 3674 } 3675 3676 /** 3677 * @param value {@link #key} (Allows identification of which elements have their cardinalities impacted by the constraint. Will not be referenced for constraints that do not affect cardinality.). This is the underlying object with id, value and extensions. The accessor "getKey" gives direct access to the value 3678 */ 3679 public ElementDefinitionConstraintComponent setKeyElement(IdType value) { 3680 this.key = value; 3681 return this; 3682 } 3683 3684 /** 3685 * @return Allows identification of which elements have their cardinalities impacted by the constraint. Will not be referenced for constraints that do not affect cardinality. 3686 */ 3687 public String getKey() { 3688 return this.key == null ? null : this.key.getValue(); 3689 } 3690 3691 /** 3692 * @param value Allows identification of which elements have their cardinalities impacted by the constraint. Will not be referenced for constraints that do not affect cardinality. 3693 */ 3694 public ElementDefinitionConstraintComponent setKey(String value) { 3695 if (this.key == null) 3696 this.key = new IdType(); 3697 this.key.setValue(value); 3698 return this; 3699 } 3700 3701 /** 3702 * @return {@link #requirements} (Description of why this constraint is necessary or appropriate.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value 3703 */ 3704 public StringType getRequirementsElement() { 3705 if (this.requirements == null) 3706 if (Configuration.errorOnAutoCreate()) 3707 throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.requirements"); 3708 else if (Configuration.doAutoCreate()) 3709 this.requirements = new StringType(); // bb 3710 return this.requirements; 3711 } 3712 3713 public boolean hasRequirementsElement() { 3714 return this.requirements != null && !this.requirements.isEmpty(); 3715 } 3716 3717 public boolean hasRequirements() { 3718 return this.requirements != null && !this.requirements.isEmpty(); 3719 } 3720 3721 /** 3722 * @param value {@link #requirements} (Description of why this constraint is necessary or appropriate.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value 3723 */ 3724 public ElementDefinitionConstraintComponent setRequirementsElement(StringType value) { 3725 this.requirements = value; 3726 return this; 3727 } 3728 3729 /** 3730 * @return Description of why this constraint is necessary or appropriate. 3731 */ 3732 public String getRequirements() { 3733 return this.requirements == null ? null : this.requirements.getValue(); 3734 } 3735 3736 /** 3737 * @param value Description of why this constraint is necessary or appropriate. 3738 */ 3739 public ElementDefinitionConstraintComponent setRequirements(String value) { 3740 if (Utilities.noString(value)) 3741 this.requirements = null; 3742 else { 3743 if (this.requirements == null) 3744 this.requirements = new StringType(); 3745 this.requirements.setValue(value); 3746 } 3747 return this; 3748 } 3749 3750 /** 3751 * @return {@link #severity} (Identifies the impact constraint violation has on the conformance of the instance.). This is the underlying object with id, value and extensions. The accessor "getSeverity" gives direct access to the value 3752 */ 3753 public Enumeration<ConstraintSeverity> getSeverityElement() { 3754 if (this.severity == null) 3755 if (Configuration.errorOnAutoCreate()) 3756 throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.severity"); 3757 else if (Configuration.doAutoCreate()) 3758 this.severity = new Enumeration<ConstraintSeverity>(new ConstraintSeverityEnumFactory()); // bb 3759 return this.severity; 3760 } 3761 3762 public boolean hasSeverityElement() { 3763 return this.severity != null && !this.severity.isEmpty(); 3764 } 3765 3766 public boolean hasSeverity() { 3767 return this.severity != null && !this.severity.isEmpty(); 3768 } 3769 3770 /** 3771 * @param value {@link #severity} (Identifies the impact constraint violation has on the conformance of the instance.). This is the underlying object with id, value and extensions. The accessor "getSeverity" gives direct access to the value 3772 */ 3773 public ElementDefinitionConstraintComponent setSeverityElement(Enumeration<ConstraintSeverity> value) { 3774 this.severity = value; 3775 return this; 3776 } 3777 3778 /** 3779 * @return Identifies the impact constraint violation has on the conformance of the instance. 3780 */ 3781 public ConstraintSeverity getSeverity() { 3782 return this.severity == null ? null : this.severity.getValue(); 3783 } 3784 3785 /** 3786 * @param value Identifies the impact constraint violation has on the conformance of the instance. 3787 */ 3788 public ElementDefinitionConstraintComponent setSeverity(ConstraintSeverity value) { 3789 if (this.severity == null) 3790 this.severity = new Enumeration<ConstraintSeverity>(new ConstraintSeverityEnumFactory()); 3791 this.severity.setValue(value); 3792 return this; 3793 } 3794 3795 /** 3796 * @return {@link #human} (Text that can be used to describe the constraint in messages identifying that the constraint has been violated.). This is the underlying object with id, value and extensions. The accessor "getHuman" gives direct access to the value 3797 */ 3798 public StringType getHumanElement() { 3799 if (this.human == null) 3800 if (Configuration.errorOnAutoCreate()) 3801 throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.human"); 3802 else if (Configuration.doAutoCreate()) 3803 this.human = new StringType(); // bb 3804 return this.human; 3805 } 3806 3807 public boolean hasHumanElement() { 3808 return this.human != null && !this.human.isEmpty(); 3809 } 3810 3811 public boolean hasHuman() { 3812 return this.human != null && !this.human.isEmpty(); 3813 } 3814 3815 /** 3816 * @param value {@link #human} (Text that can be used to describe the constraint in messages identifying that the constraint has been violated.). This is the underlying object with id, value and extensions. The accessor "getHuman" gives direct access to the value 3817 */ 3818 public ElementDefinitionConstraintComponent setHumanElement(StringType value) { 3819 this.human = value; 3820 return this; 3821 } 3822 3823 /** 3824 * @return Text that can be used to describe the constraint in messages identifying that the constraint has been violated. 3825 */ 3826 public String getHuman() { 3827 return this.human == null ? null : this.human.getValue(); 3828 } 3829 3830 /** 3831 * @param value Text that can be used to describe the constraint in messages identifying that the constraint has been violated. 3832 */ 3833 public ElementDefinitionConstraintComponent setHuman(String value) { 3834 if (this.human == null) 3835 this.human = new StringType(); 3836 this.human.setValue(value); 3837 return this; 3838 } 3839 3840 /** 3841 * @return {@link #expression} (A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value 3842 */ 3843 public StringType getExpressionElement() { 3844 if (this.expression == null) 3845 if (Configuration.errorOnAutoCreate()) 3846 throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.expression"); 3847 else if (Configuration.doAutoCreate()) 3848 this.expression = new StringType(); // bb 3849 return this.expression; 3850 } 3851 3852 public boolean hasExpressionElement() { 3853 return this.expression != null && !this.expression.isEmpty(); 3854 } 3855 3856 public boolean hasExpression() { 3857 return this.expression != null && !this.expression.isEmpty(); 3858 } 3859 3860 /** 3861 * @param value {@link #expression} (A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value 3862 */ 3863 public ElementDefinitionConstraintComponent setExpressionElement(StringType value) { 3864 this.expression = value; 3865 return this; 3866 } 3867 3868 /** 3869 * @return A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met. 3870 */ 3871 public String getExpression() { 3872 return this.expression == null ? null : this.expression.getValue(); 3873 } 3874 3875 /** 3876 * @param value A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met. 3877 */ 3878 public ElementDefinitionConstraintComponent setExpression(String value) { 3879 if (Utilities.noString(value)) 3880 this.expression = null; 3881 else { 3882 if (this.expression == null) 3883 this.expression = new StringType(); 3884 this.expression.setValue(value); 3885 } 3886 return this; 3887 } 3888 3889 /** 3890 * @return {@link #xpath} (An XPath expression of constraint that can be executed to see if this constraint is met.). This is the underlying object with id, value and extensions. The accessor "getXpath" gives direct access to the value 3891 */ 3892 public StringType getXpathElement() { 3893 if (this.xpath == null) 3894 if (Configuration.errorOnAutoCreate()) 3895 throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.xpath"); 3896 else if (Configuration.doAutoCreate()) 3897 this.xpath = new StringType(); // bb 3898 return this.xpath; 3899 } 3900 3901 public boolean hasXpathElement() { 3902 return this.xpath != null && !this.xpath.isEmpty(); 3903 } 3904 3905 public boolean hasXpath() { 3906 return this.xpath != null && !this.xpath.isEmpty(); 3907 } 3908 3909 /** 3910 * @param value {@link #xpath} (An XPath expression of constraint that can be executed to see if this constraint is met.). This is the underlying object with id, value and extensions. The accessor "getXpath" gives direct access to the value 3911 */ 3912 public ElementDefinitionConstraintComponent setXpathElement(StringType value) { 3913 this.xpath = value; 3914 return this; 3915 } 3916 3917 /** 3918 * @return An XPath expression of constraint that can be executed to see if this constraint is met. 3919 */ 3920 public String getXpath() { 3921 return this.xpath == null ? null : this.xpath.getValue(); 3922 } 3923 3924 /** 3925 * @param value An XPath expression of constraint that can be executed to see if this constraint is met. 3926 */ 3927 public ElementDefinitionConstraintComponent setXpath(String value) { 3928 if (Utilities.noString(value)) 3929 this.xpath = null; 3930 else { 3931 if (this.xpath == null) 3932 this.xpath = new StringType(); 3933 this.xpath.setValue(value); 3934 } 3935 return this; 3936 } 3937 3938 /** 3939 * @return {@link #source} (A reference to the original source of the constraint, for traceability purposes.). This is the underlying object with id, value and extensions. The accessor "getSource" gives direct access to the value 3940 */ 3941 public CanonicalType getSourceElement() { 3942 if (this.source == null) 3943 if (Configuration.errorOnAutoCreate()) 3944 throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.source"); 3945 else if (Configuration.doAutoCreate()) 3946 this.source = new CanonicalType(); // bb 3947 return this.source; 3948 } 3949 3950 public boolean hasSourceElement() { 3951 return this.source != null && !this.source.isEmpty(); 3952 } 3953 3954 public boolean hasSource() { 3955 return this.source != null && !this.source.isEmpty(); 3956 } 3957 3958 /** 3959 * @param value {@link #source} (A reference to the original source of the constraint, for traceability purposes.). This is the underlying object with id, value and extensions. The accessor "getSource" gives direct access to the value 3960 */ 3961 public ElementDefinitionConstraintComponent setSourceElement(CanonicalType value) { 3962 this.source = value; 3963 return this; 3964 } 3965 3966 /** 3967 * @return A reference to the original source of the constraint, for traceability purposes. 3968 */ 3969 public String getSource() { 3970 return this.source == null ? null : this.source.getValue(); 3971 } 3972 3973 /** 3974 * @param value A reference to the original source of the constraint, for traceability purposes. 3975 */ 3976 public ElementDefinitionConstraintComponent setSource(String value) { 3977 if (Utilities.noString(value)) 3978 this.source = null; 3979 else { 3980 if (this.source == null) 3981 this.source = new CanonicalType(); 3982 this.source.setValue(value); 3983 } 3984 return this; 3985 } 3986 3987 protected void listChildren(List<Property> children) { 3988 super.listChildren(children); 3989 children.add(new Property("key", "id", "Allows identification of which elements have their cardinalities impacted by the constraint. Will not be referenced for constraints that do not affect cardinality.", 0, 1, key)); 3990 children.add(new Property("requirements", "string", "Description of why this constraint is necessary or appropriate.", 0, 1, requirements)); 3991 children.add(new Property("severity", "code", "Identifies the impact constraint violation has on the conformance of the instance.", 0, 1, severity)); 3992 children.add(new Property("human", "string", "Text that can be used to describe the constraint in messages identifying that the constraint has been violated.", 0, 1, human)); 3993 children.add(new Property("expression", "string", "A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.", 0, 1, expression)); 3994 children.add(new Property("xpath", "string", "An XPath expression of constraint that can be executed to see if this constraint is met.", 0, 1, xpath)); 3995 children.add(new Property("source", "canonical(StructureDefinition)", "A reference to the original source of the constraint, for traceability purposes.", 0, 1, source)); 3996 } 3997 3998 @Override 3999 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4000 switch (_hash) { 4001 case 106079: /*key*/ return new Property("key", "id", "Allows identification of which elements have their cardinalities impacted by the constraint. Will not be referenced for constraints that do not affect cardinality.", 0, 1, key); 4002 case -1619874672: /*requirements*/ return new Property("requirements", "string", "Description of why this constraint is necessary or appropriate.", 0, 1, requirements); 4003 case 1478300413: /*severity*/ return new Property("severity", "code", "Identifies the impact constraint violation has on the conformance of the instance.", 0, 1, severity); 4004 case 99639597: /*human*/ return new Property("human", "string", "Text that can be used to describe the constraint in messages identifying that the constraint has been violated.", 0, 1, human); 4005 case -1795452264: /*expression*/ return new Property("expression", "string", "A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.", 0, 1, expression); 4006 case 114256029: /*xpath*/ return new Property("xpath", "string", "An XPath expression of constraint that can be executed to see if this constraint is met.", 0, 1, xpath); 4007 case -896505829: /*source*/ return new Property("source", "canonical(StructureDefinition)", "A reference to the original source of the constraint, for traceability purposes.", 0, 1, source); 4008 default: return super.getNamedProperty(_hash, _name, _checkValid); 4009 } 4010 4011 } 4012 4013 @Override 4014 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4015 switch (hash) { 4016 case 106079: /*key*/ return this.key == null ? new Base[0] : new Base[] {this.key}; // IdType 4017 case -1619874672: /*requirements*/ return this.requirements == null ? new Base[0] : new Base[] {this.requirements}; // StringType 4018 case 1478300413: /*severity*/ return this.severity == null ? new Base[0] : new Base[] {this.severity}; // Enumeration<ConstraintSeverity> 4019 case 99639597: /*human*/ return this.human == null ? new Base[0] : new Base[] {this.human}; // StringType 4020 case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType 4021 case 114256029: /*xpath*/ return this.xpath == null ? new Base[0] : new Base[] {this.xpath}; // StringType 4022 case -896505829: /*source*/ return this.source == null ? new Base[0] : new Base[] {this.source}; // CanonicalType 4023 default: return super.getProperty(hash, name, checkValid); 4024 } 4025 4026 } 4027 4028 @Override 4029 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4030 switch (hash) { 4031 case 106079: // key 4032 this.key = TypeConvertor.castToId(value); // IdType 4033 return value; 4034 case -1619874672: // requirements 4035 this.requirements = TypeConvertor.castToString(value); // StringType 4036 return value; 4037 case 1478300413: // severity 4038 value = new ConstraintSeverityEnumFactory().fromType(TypeConvertor.castToCode(value)); 4039 this.severity = (Enumeration) value; // Enumeration<ConstraintSeverity> 4040 return value; 4041 case 99639597: // human 4042 this.human = TypeConvertor.castToString(value); // StringType 4043 return value; 4044 case -1795452264: // expression 4045 this.expression = TypeConvertor.castToString(value); // StringType 4046 return value; 4047 case 114256029: // xpath 4048 this.xpath = TypeConvertor.castToString(value); // StringType 4049 return value; 4050 case -896505829: // source 4051 this.source = TypeConvertor.castToCanonical(value); // CanonicalType 4052 return value; 4053 default: return super.setProperty(hash, name, value); 4054 } 4055 4056 } 4057 4058 @Override 4059 public Base setProperty(String name, Base value) throws FHIRException { 4060 if (name.equals("key")) { 4061 this.key = TypeConvertor.castToId(value); // IdType 4062 } else if (name.equals("requirements")) { 4063 this.requirements = TypeConvertor.castToString(value); // StringType 4064 } else if (name.equals("severity")) { 4065 value = new ConstraintSeverityEnumFactory().fromType(TypeConvertor.castToCode(value)); 4066 this.severity = (Enumeration) value; // Enumeration<ConstraintSeverity> 4067 } else if (name.equals("human")) { 4068 this.human = TypeConvertor.castToString(value); // StringType 4069 } else if (name.equals("expression")) { 4070 this.expression = TypeConvertor.castToString(value); // StringType 4071 } else if (name.equals("xpath")) { 4072 this.xpath = TypeConvertor.castToString(value); // StringType 4073 } else if (name.equals("source")) { 4074 this.source = TypeConvertor.castToCanonical(value); // CanonicalType 4075 } else 4076 return super.setProperty(name, value); 4077 return value; 4078 } 4079 4080 @Override 4081 public Base makeProperty(int hash, String name) throws FHIRException { 4082 switch (hash) { 4083 case 106079: return getKeyElement(); 4084 case -1619874672: return getRequirementsElement(); 4085 case 1478300413: return getSeverityElement(); 4086 case 99639597: return getHumanElement(); 4087 case -1795452264: return getExpressionElement(); 4088 case 114256029: return getXpathElement(); 4089 case -896505829: return getSourceElement(); 4090 default: return super.makeProperty(hash, name); 4091 } 4092 4093 } 4094 4095 @Override 4096 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4097 switch (hash) { 4098 case 106079: /*key*/ return new String[] {"id"}; 4099 case -1619874672: /*requirements*/ return new String[] {"string"}; 4100 case 1478300413: /*severity*/ return new String[] {"code"}; 4101 case 99639597: /*human*/ return new String[] {"string"}; 4102 case -1795452264: /*expression*/ return new String[] {"string"}; 4103 case 114256029: /*xpath*/ return new String[] {"string"}; 4104 case -896505829: /*source*/ return new String[] {"canonical"}; 4105 default: return super.getTypesForProperty(hash, name); 4106 } 4107 4108 } 4109 4110 @Override 4111 public Base addChild(String name) throws FHIRException { 4112 if (name.equals("key")) { 4113 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.constraint.key"); 4114 } 4115 else if (name.equals("requirements")) { 4116 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.constraint.requirements"); 4117 } 4118 else if (name.equals("severity")) { 4119 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.constraint.severity"); 4120 } 4121 else if (name.equals("human")) { 4122 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.constraint.human"); 4123 } 4124 else if (name.equals("expression")) { 4125 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.constraint.expression"); 4126 } 4127 else if (name.equals("xpath")) { 4128 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.constraint.xpath"); 4129 } 4130 else if (name.equals("source")) { 4131 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.constraint.source"); 4132 } 4133 else 4134 return super.addChild(name); 4135 } 4136 4137 public ElementDefinitionConstraintComponent copy() { 4138 ElementDefinitionConstraintComponent dst = new ElementDefinitionConstraintComponent(); 4139 copyValues(dst); 4140 return dst; 4141 } 4142 4143 public void copyValues(ElementDefinitionConstraintComponent dst) { 4144 super.copyValues(dst); 4145 dst.key = key == null ? null : key.copy(); 4146 dst.requirements = requirements == null ? null : requirements.copy(); 4147 dst.severity = severity == null ? null : severity.copy(); 4148 dst.human = human == null ? null : human.copy(); 4149 dst.expression = expression == null ? null : expression.copy(); 4150 dst.xpath = xpath == null ? null : xpath.copy(); 4151 dst.source = source == null ? null : source.copy(); 4152 } 4153 4154 @Override 4155 public boolean equalsDeep(Base other_) { 4156 if (!super.equalsDeep(other_)) 4157 return false; 4158 if (!(other_ instanceof ElementDefinitionConstraintComponent)) 4159 return false; 4160 ElementDefinitionConstraintComponent o = (ElementDefinitionConstraintComponent) other_; 4161 return compareDeep(key, o.key, true) && compareDeep(requirements, o.requirements, true) && compareDeep(severity, o.severity, true) 4162 && compareDeep(human, o.human, true) && compareDeep(expression, o.expression, true) && compareDeep(xpath, o.xpath, true) 4163 && compareDeep(source, o.source, true); 4164 } 4165 4166 @Override 4167 public boolean equalsShallow(Base other_) { 4168 if (!super.equalsShallow(other_)) 4169 return false; 4170 if (!(other_ instanceof ElementDefinitionConstraintComponent)) 4171 return false; 4172 ElementDefinitionConstraintComponent o = (ElementDefinitionConstraintComponent) other_; 4173 return compareValues(key, o.key, true) && compareValues(requirements, o.requirements, true) && compareValues(severity, o.severity, true) 4174 && compareValues(human, o.human, true) && compareValues(expression, o.expression, true) && compareValues(xpath, o.xpath, true) 4175 && compareValues(source, o.source, true); 4176 } 4177 4178 public boolean isEmpty() { 4179 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(key, requirements, severity 4180 , human, expression, xpath, source); 4181 } 4182 4183 public String fhirType() { 4184 return "ElementDefinition.constraint"; 4185 4186 } 4187 4188 } 4189 4190 @Block() 4191 public static class ElementDefinitionBindingComponent extends Element implements IBaseDatatypeElement { 4192 /** 4193 * Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances. 4194 */ 4195 @Child(name = "strength", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 4196 @Description(shortDefinition="required | extensible | preferred | example", formalDefinition="Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances." ) 4197 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/binding-strength") 4198 protected Enumeration<BindingStrength> strength; 4199 4200 /** 4201 * Describes the intended use of this particular set of codes. 4202 */ 4203 @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 4204 @Description(shortDefinition="Human explanation of the value set", formalDefinition="Describes the intended use of this particular set of codes." ) 4205 protected StringType description; 4206 4207 /** 4208 * Refers to the value set that identifies the set of codes the binding refers to. 4209 */ 4210 @Child(name = "valueSet", type = {CanonicalType.class}, order=3, min=0, max=1, modifier=false, summary=true) 4211 @Description(shortDefinition="Source of value set", formalDefinition="Refers to the value set that identifies the set of codes the binding refers to." ) 4212 protected CanonicalType valueSet; 4213 4214 private static final long serialVersionUID = -514477030L; 4215 4216 /** 4217 * Constructor 4218 */ 4219 public ElementDefinitionBindingComponent() { 4220 super(); 4221 } 4222 4223 /** 4224 * Constructor 4225 */ 4226 public ElementDefinitionBindingComponent(BindingStrength strength) { 4227 super(); 4228 this.setStrength(strength); 4229 } 4230 4231 /** 4232 * @return {@link #strength} (Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.). This is the underlying object with id, value and extensions. The accessor "getStrength" gives direct access to the value 4233 */ 4234 public Enumeration<BindingStrength> getStrengthElement() { 4235 if (this.strength == null) 4236 if (Configuration.errorOnAutoCreate()) 4237 throw new Error("Attempt to auto-create ElementDefinitionBindingComponent.strength"); 4238 else if (Configuration.doAutoCreate()) 4239 this.strength = new Enumeration<BindingStrength>(new BindingStrengthEnumFactory()); // bb 4240 return this.strength; 4241 } 4242 4243 public boolean hasStrengthElement() { 4244 return this.strength != null && !this.strength.isEmpty(); 4245 } 4246 4247 public boolean hasStrength() { 4248 return this.strength != null && !this.strength.isEmpty(); 4249 } 4250 4251 /** 4252 * @param value {@link #strength} (Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.). This is the underlying object with id, value and extensions. The accessor "getStrength" gives direct access to the value 4253 */ 4254 public ElementDefinitionBindingComponent setStrengthElement(Enumeration<BindingStrength> value) { 4255 this.strength = value; 4256 return this; 4257 } 4258 4259 /** 4260 * @return Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances. 4261 */ 4262 public BindingStrength getStrength() { 4263 return this.strength == null ? null : this.strength.getValue(); 4264 } 4265 4266 /** 4267 * @param value Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances. 4268 */ 4269 public ElementDefinitionBindingComponent setStrength(BindingStrength value) { 4270 if (this.strength == null) 4271 this.strength = new Enumeration<BindingStrength>(new BindingStrengthEnumFactory()); 4272 this.strength.setValue(value); 4273 return this; 4274 } 4275 4276 /** 4277 * @return {@link #description} (Describes the intended use of this particular set of codes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 4278 */ 4279 public StringType getDescriptionElement() { 4280 if (this.description == null) 4281 if (Configuration.errorOnAutoCreate()) 4282 throw new Error("Attempt to auto-create ElementDefinitionBindingComponent.description"); 4283 else if (Configuration.doAutoCreate()) 4284 this.description = new StringType(); // bb 4285 return this.description; 4286 } 4287 4288 public boolean hasDescriptionElement() { 4289 return this.description != null && !this.description.isEmpty(); 4290 } 4291 4292 public boolean hasDescription() { 4293 return this.description != null && !this.description.isEmpty(); 4294 } 4295 4296 /** 4297 * @param value {@link #description} (Describes the intended use of this particular set of codes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 4298 */ 4299 public ElementDefinitionBindingComponent setDescriptionElement(StringType value) { 4300 this.description = value; 4301 return this; 4302 } 4303 4304 /** 4305 * @return Describes the intended use of this particular set of codes. 4306 */ 4307 public String getDescription() { 4308 return this.description == null ? null : this.description.getValue(); 4309 } 4310 4311 /** 4312 * @param value Describes the intended use of this particular set of codes. 4313 */ 4314 public ElementDefinitionBindingComponent setDescription(String value) { 4315 if (Utilities.noString(value)) 4316 this.description = null; 4317 else { 4318 if (this.description == null) 4319 this.description = new StringType(); 4320 this.description.setValue(value); 4321 } 4322 return this; 4323 } 4324 4325 /** 4326 * @return {@link #valueSet} (Refers to the value set that identifies the set of codes the binding refers to.). This is the underlying object with id, value and extensions. The accessor "getValueSet" gives direct access to the value 4327 */ 4328 public CanonicalType getValueSetElement() { 4329 if (this.valueSet == null) 4330 if (Configuration.errorOnAutoCreate()) 4331 throw new Error("Attempt to auto-create ElementDefinitionBindingComponent.valueSet"); 4332 else if (Configuration.doAutoCreate()) 4333 this.valueSet = new CanonicalType(); // bb 4334 return this.valueSet; 4335 } 4336 4337 public boolean hasValueSetElement() { 4338 return this.valueSet != null && !this.valueSet.isEmpty(); 4339 } 4340 4341 public boolean hasValueSet() { 4342 return this.valueSet != null && !this.valueSet.isEmpty(); 4343 } 4344 4345 /** 4346 * @param value {@link #valueSet} (Refers to the value set that identifies the set of codes the binding refers to.). This is the underlying object with id, value and extensions. The accessor "getValueSet" gives direct access to the value 4347 */ 4348 public ElementDefinitionBindingComponent setValueSetElement(CanonicalType value) { 4349 this.valueSet = value; 4350 return this; 4351 } 4352 4353 /** 4354 * @return Refers to the value set that identifies the set of codes the binding refers to. 4355 */ 4356 public String getValueSet() { 4357 return this.valueSet == null ? null : this.valueSet.getValue(); 4358 } 4359 4360 /** 4361 * @param value Refers to the value set that identifies the set of codes the binding refers to. 4362 */ 4363 public ElementDefinitionBindingComponent setValueSet(String value) { 4364 if (Utilities.noString(value)) 4365 this.valueSet = null; 4366 else { 4367 if (this.valueSet == null) 4368 this.valueSet = new CanonicalType(); 4369 this.valueSet.setValue(value); 4370 } 4371 return this; 4372 } 4373 4374 protected void listChildren(List<Property> children) { 4375 super.listChildren(children); 4376 children.add(new Property("strength", "code", "Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.", 0, 1, strength)); 4377 children.add(new Property("description", "string", "Describes the intended use of this particular set of codes.", 0, 1, description)); 4378 children.add(new Property("valueSet", "canonical(ValueSet)", "Refers to the value set that identifies the set of codes the binding refers to.", 0, 1, valueSet)); 4379 } 4380 4381 @Override 4382 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4383 switch (_hash) { 4384 case 1791316033: /*strength*/ return new Property("strength", "code", "Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.", 0, 1, strength); 4385 case -1724546052: /*description*/ return new Property("description", "string", "Describes the intended use of this particular set of codes.", 0, 1, description); 4386 case -1410174671: /*valueSet*/ return new Property("valueSet", "canonical(ValueSet)", "Refers to the value set that identifies the set of codes the binding refers to.", 0, 1, valueSet); 4387 default: return super.getNamedProperty(_hash, _name, _checkValid); 4388 } 4389 4390 } 4391 4392 @Override 4393 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4394 switch (hash) { 4395 case 1791316033: /*strength*/ return this.strength == null ? new Base[0] : new Base[] {this.strength}; // Enumeration<BindingStrength> 4396 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 4397 case -1410174671: /*valueSet*/ return this.valueSet == null ? new Base[0] : new Base[] {this.valueSet}; // CanonicalType 4398 default: return super.getProperty(hash, name, checkValid); 4399 } 4400 4401 } 4402 4403 @Override 4404 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4405 switch (hash) { 4406 case 1791316033: // strength 4407 value = new BindingStrengthEnumFactory().fromType(TypeConvertor.castToCode(value)); 4408 this.strength = (Enumeration) value; // Enumeration<BindingStrength> 4409 return value; 4410 case -1724546052: // description 4411 this.description = TypeConvertor.castToString(value); // StringType 4412 return value; 4413 case -1410174671: // valueSet 4414 this.valueSet = TypeConvertor.castToCanonical(value); // CanonicalType 4415 return value; 4416 default: return super.setProperty(hash, name, value); 4417 } 4418 4419 } 4420 4421 @Override 4422 public Base setProperty(String name, Base value) throws FHIRException { 4423 if (name.equals("strength")) { 4424 value = new BindingStrengthEnumFactory().fromType(TypeConvertor.castToCode(value)); 4425 this.strength = (Enumeration) value; // Enumeration<BindingStrength> 4426 } else if (name.equals("description")) { 4427 this.description = TypeConvertor.castToString(value); // StringType 4428 } else if (name.equals("valueSet")) { 4429 this.valueSet = TypeConvertor.castToCanonical(value); // CanonicalType 4430 } else 4431 return super.setProperty(name, value); 4432 return value; 4433 } 4434 4435 @Override 4436 public Base makeProperty(int hash, String name) throws FHIRException { 4437 switch (hash) { 4438 case 1791316033: return getStrengthElement(); 4439 case -1724546052: return getDescriptionElement(); 4440 case -1410174671: return getValueSetElement(); 4441 default: return super.makeProperty(hash, name); 4442 } 4443 4444 } 4445 4446 @Override 4447 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4448 switch (hash) { 4449 case 1791316033: /*strength*/ return new String[] {"code"}; 4450 case -1724546052: /*description*/ return new String[] {"string"}; 4451 case -1410174671: /*valueSet*/ return new String[] {"canonical"}; 4452 default: return super.getTypesForProperty(hash, name); 4453 } 4454 4455 } 4456 4457 @Override 4458 public Base addChild(String name) throws FHIRException { 4459 if (name.equals("strength")) { 4460 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.binding.strength"); 4461 } 4462 else if (name.equals("description")) { 4463 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.binding.description"); 4464 } 4465 else if (name.equals("valueSet")) { 4466 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.binding.valueSet"); 4467 } 4468 else 4469 return super.addChild(name); 4470 } 4471 4472 public ElementDefinitionBindingComponent copy() { 4473 ElementDefinitionBindingComponent dst = new ElementDefinitionBindingComponent(); 4474 copyValues(dst); 4475 return dst; 4476 } 4477 4478 public void copyValues(ElementDefinitionBindingComponent dst) { 4479 super.copyValues(dst); 4480 dst.strength = strength == null ? null : strength.copy(); 4481 dst.description = description == null ? null : description.copy(); 4482 dst.valueSet = valueSet == null ? null : valueSet.copy(); 4483 } 4484 4485 @Override 4486 public boolean equalsDeep(Base other_) { 4487 if (!super.equalsDeep(other_)) 4488 return false; 4489 if (!(other_ instanceof ElementDefinitionBindingComponent)) 4490 return false; 4491 ElementDefinitionBindingComponent o = (ElementDefinitionBindingComponent) other_; 4492 return compareDeep(strength, o.strength, true) && compareDeep(description, o.description, true) 4493 && compareDeep(valueSet, o.valueSet, true); 4494 } 4495 4496 @Override 4497 public boolean equalsShallow(Base other_) { 4498 if (!super.equalsShallow(other_)) 4499 return false; 4500 if (!(other_ instanceof ElementDefinitionBindingComponent)) 4501 return false; 4502 ElementDefinitionBindingComponent o = (ElementDefinitionBindingComponent) other_; 4503 return compareValues(strength, o.strength, true) && compareValues(description, o.description, true) 4504 && compareValues(valueSet, o.valueSet, true); 4505 } 4506 4507 public boolean isEmpty() { 4508 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(strength, description, valueSet 4509 ); 4510 } 4511 4512 public String fhirType() { 4513 return "ElementDefinition.binding"; 4514 4515 } 4516 4517 } 4518 4519 @Block() 4520 public static class ElementDefinitionMappingComponent extends Element implements IBaseDatatypeElement { 4521 /** 4522 * An internal reference to the definition of a mapping. 4523 */ 4524 @Child(name = "identity", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=true) 4525 @Description(shortDefinition="Reference to mapping declaration", formalDefinition="An internal reference to the definition of a mapping." ) 4526 protected IdType identity; 4527 4528 /** 4529 * Identifies the computable language in which mapping.map is expressed. 4530 */ 4531 @Child(name = "language", type = {CodeType.class}, order=2, min=0, max=1, modifier=false, summary=true) 4532 @Description(shortDefinition="Computable language of mapping", formalDefinition="Identifies the computable language in which mapping.map is expressed." ) 4533 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes") 4534 protected CodeType language; 4535 4536 /** 4537 * Expresses what part of the target specification corresponds to this element. 4538 */ 4539 @Child(name = "map", type = {StringType.class}, order=3, min=1, max=1, modifier=false, summary=true) 4540 @Description(shortDefinition="Details of the mapping", formalDefinition="Expresses what part of the target specification corresponds to this element." ) 4541 protected StringType map; 4542 4543 /** 4544 * Comments that provide information about the mapping or its use. 4545 */ 4546 @Child(name = "comment", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true) 4547 @Description(shortDefinition="Comments about the mapping or its use", formalDefinition="Comments that provide information about the mapping or its use." ) 4548 protected StringType comment; 4549 4550 private static final long serialVersionUID = 1386816887L; 4551 4552 /** 4553 * Constructor 4554 */ 4555 public ElementDefinitionMappingComponent() { 4556 super(); 4557 } 4558 4559 /** 4560 * Constructor 4561 */ 4562 public ElementDefinitionMappingComponent(String identity, String map) { 4563 super(); 4564 this.setIdentity(identity); 4565 this.setMap(map); 4566 } 4567 4568 /** 4569 * @return {@link #identity} (An internal reference to the definition of a mapping.). This is the underlying object with id, value and extensions. The accessor "getIdentity" gives direct access to the value 4570 */ 4571 public IdType getIdentityElement() { 4572 if (this.identity == null) 4573 if (Configuration.errorOnAutoCreate()) 4574 throw new Error("Attempt to auto-create ElementDefinitionMappingComponent.identity"); 4575 else if (Configuration.doAutoCreate()) 4576 this.identity = new IdType(); // bb 4577 return this.identity; 4578 } 4579 4580 public boolean hasIdentityElement() { 4581 return this.identity != null && !this.identity.isEmpty(); 4582 } 4583 4584 public boolean hasIdentity() { 4585 return this.identity != null && !this.identity.isEmpty(); 4586 } 4587 4588 /** 4589 * @param value {@link #identity} (An internal reference to the definition of a mapping.). This is the underlying object with id, value and extensions. The accessor "getIdentity" gives direct access to the value 4590 */ 4591 public ElementDefinitionMappingComponent setIdentityElement(IdType value) { 4592 this.identity = value; 4593 return this; 4594 } 4595 4596 /** 4597 * @return An internal reference to the definition of a mapping. 4598 */ 4599 public String getIdentity() { 4600 return this.identity == null ? null : this.identity.getValue(); 4601 } 4602 4603 /** 4604 * @param value An internal reference to the definition of a mapping. 4605 */ 4606 public ElementDefinitionMappingComponent setIdentity(String value) { 4607 if (this.identity == null) 4608 this.identity = new IdType(); 4609 this.identity.setValue(value); 4610 return this; 4611 } 4612 4613 /** 4614 * @return {@link #language} (Identifies the computable language in which mapping.map is expressed.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value 4615 */ 4616 public CodeType getLanguageElement() { 4617 if (this.language == null) 4618 if (Configuration.errorOnAutoCreate()) 4619 throw new Error("Attempt to auto-create ElementDefinitionMappingComponent.language"); 4620 else if (Configuration.doAutoCreate()) 4621 this.language = new CodeType(); // bb 4622 return this.language; 4623 } 4624 4625 public boolean hasLanguageElement() { 4626 return this.language != null && !this.language.isEmpty(); 4627 } 4628 4629 public boolean hasLanguage() { 4630 return this.language != null && !this.language.isEmpty(); 4631 } 4632 4633 /** 4634 * @param value {@link #language} (Identifies the computable language in which mapping.map is expressed.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value 4635 */ 4636 public ElementDefinitionMappingComponent setLanguageElement(CodeType value) { 4637 this.language = value; 4638 return this; 4639 } 4640 4641 /** 4642 * @return Identifies the computable language in which mapping.map is expressed. 4643 */ 4644 public String getLanguage() { 4645 return this.language == null ? null : this.language.getValue(); 4646 } 4647 4648 /** 4649 * @param value Identifies the computable language in which mapping.map is expressed. 4650 */ 4651 public ElementDefinitionMappingComponent setLanguage(String value) { 4652 if (Utilities.noString(value)) 4653 this.language = null; 4654 else { 4655 if (this.language == null) 4656 this.language = new CodeType(); 4657 this.language.setValue(value); 4658 } 4659 return this; 4660 } 4661 4662 /** 4663 * @return {@link #map} (Expresses what part of the target specification corresponds to this element.). This is the underlying object with id, value and extensions. The accessor "getMap" gives direct access to the value 4664 */ 4665 public StringType getMapElement() { 4666 if (this.map == null) 4667 if (Configuration.errorOnAutoCreate()) 4668 throw new Error("Attempt to auto-create ElementDefinitionMappingComponent.map"); 4669 else if (Configuration.doAutoCreate()) 4670 this.map = new StringType(); // bb 4671 return this.map; 4672 } 4673 4674 public boolean hasMapElement() { 4675 return this.map != null && !this.map.isEmpty(); 4676 } 4677 4678 public boolean hasMap() { 4679 return this.map != null && !this.map.isEmpty(); 4680 } 4681 4682 /** 4683 * @param value {@link #map} (Expresses what part of the target specification corresponds to this element.). This is the underlying object with id, value and extensions. The accessor "getMap" gives direct access to the value 4684 */ 4685 public ElementDefinitionMappingComponent setMapElement(StringType value) { 4686 this.map = value; 4687 return this; 4688 } 4689 4690 /** 4691 * @return Expresses what part of the target specification corresponds to this element. 4692 */ 4693 public String getMap() { 4694 return this.map == null ? null : this.map.getValue(); 4695 } 4696 4697 /** 4698 * @param value Expresses what part of the target specification corresponds to this element. 4699 */ 4700 public ElementDefinitionMappingComponent setMap(String value) { 4701 if (this.map == null) 4702 this.map = new StringType(); 4703 this.map.setValue(value); 4704 return this; 4705 } 4706 4707 /** 4708 * @return {@link #comment} (Comments that provide information about the mapping or its use.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value 4709 */ 4710 public StringType getCommentElement() { 4711 if (this.comment == null) 4712 if (Configuration.errorOnAutoCreate()) 4713 throw new Error("Attempt to auto-create ElementDefinitionMappingComponent.comment"); 4714 else if (Configuration.doAutoCreate()) 4715 this.comment = new StringType(); // bb 4716 return this.comment; 4717 } 4718 4719 public boolean hasCommentElement() { 4720 return this.comment != null && !this.comment.isEmpty(); 4721 } 4722 4723 public boolean hasComment() { 4724 return this.comment != null && !this.comment.isEmpty(); 4725 } 4726 4727 /** 4728 * @param value {@link #comment} (Comments that provide information about the mapping or its use.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value 4729 */ 4730 public ElementDefinitionMappingComponent setCommentElement(StringType value) { 4731 this.comment = value; 4732 return this; 4733 } 4734 4735 /** 4736 * @return Comments that provide information about the mapping or its use. 4737 */ 4738 public String getComment() { 4739 return this.comment == null ? null : this.comment.getValue(); 4740 } 4741 4742 /** 4743 * @param value Comments that provide information about the mapping or its use. 4744 */ 4745 public ElementDefinitionMappingComponent setComment(String value) { 4746 if (Utilities.noString(value)) 4747 this.comment = null; 4748 else { 4749 if (this.comment == null) 4750 this.comment = new StringType(); 4751 this.comment.setValue(value); 4752 } 4753 return this; 4754 } 4755 4756 protected void listChildren(List<Property> children) { 4757 super.listChildren(children); 4758 children.add(new Property("identity", "id", "An internal reference to the definition of a mapping.", 0, 1, identity)); 4759 children.add(new Property("language", "code", "Identifies the computable language in which mapping.map is expressed.", 0, 1, language)); 4760 children.add(new Property("map", "string", "Expresses what part of the target specification corresponds to this element.", 0, 1, map)); 4761 children.add(new Property("comment", "string", "Comments that provide information about the mapping or its use.", 0, 1, comment)); 4762 } 4763 4764 @Override 4765 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4766 switch (_hash) { 4767 case -135761730: /*identity*/ return new Property("identity", "id", "An internal reference to the definition of a mapping.", 0, 1, identity); 4768 case -1613589672: /*language*/ return new Property("language", "code", "Identifies the computable language in which mapping.map is expressed.", 0, 1, language); 4769 case 107868: /*map*/ return new Property("map", "string", "Expresses what part of the target specification corresponds to this element.", 0, 1, map); 4770 case 950398559: /*comment*/ return new Property("comment", "string", "Comments that provide information about the mapping or its use.", 0, 1, comment); 4771 default: return super.getNamedProperty(_hash, _name, _checkValid); 4772 } 4773 4774 } 4775 4776 @Override 4777 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4778 switch (hash) { 4779 case -135761730: /*identity*/ return this.identity == null ? new Base[0] : new Base[] {this.identity}; // IdType 4780 case -1613589672: /*language*/ return this.language == null ? new Base[0] : new Base[] {this.language}; // CodeType 4781 case 107868: /*map*/ return this.map == null ? new Base[0] : new Base[] {this.map}; // StringType 4782 case 950398559: /*comment*/ return this.comment == null ? new Base[0] : new Base[] {this.comment}; // StringType 4783 default: return super.getProperty(hash, name, checkValid); 4784 } 4785 4786 } 4787 4788 @Override 4789 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4790 switch (hash) { 4791 case -135761730: // identity 4792 this.identity = TypeConvertor.castToId(value); // IdType 4793 return value; 4794 case -1613589672: // language 4795 this.language = TypeConvertor.castToCode(value); // CodeType 4796 return value; 4797 case 107868: // map 4798 this.map = TypeConvertor.castToString(value); // StringType 4799 return value; 4800 case 950398559: // comment 4801 this.comment = TypeConvertor.castToString(value); // StringType 4802 return value; 4803 default: return super.setProperty(hash, name, value); 4804 } 4805 4806 } 4807 4808 @Override 4809 public Base setProperty(String name, Base value) throws FHIRException { 4810 if (name.equals("identity")) { 4811 this.identity = TypeConvertor.castToId(value); // IdType 4812 } else if (name.equals("language")) { 4813 this.language = TypeConvertor.castToCode(value); // CodeType 4814 } else if (name.equals("map")) { 4815 this.map = TypeConvertor.castToString(value); // StringType 4816 } else if (name.equals("comment")) { 4817 this.comment = TypeConvertor.castToString(value); // StringType 4818 } else 4819 return super.setProperty(name, value); 4820 return value; 4821 } 4822 4823 @Override 4824 public Base makeProperty(int hash, String name) throws FHIRException { 4825 switch (hash) { 4826 case -135761730: return getIdentityElement(); 4827 case -1613589672: return getLanguageElement(); 4828 case 107868: return getMapElement(); 4829 case 950398559: return getCommentElement(); 4830 default: return super.makeProperty(hash, name); 4831 } 4832 4833 } 4834 4835 @Override 4836 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4837 switch (hash) { 4838 case -135761730: /*identity*/ return new String[] {"id"}; 4839 case -1613589672: /*language*/ return new String[] {"code"}; 4840 case 107868: /*map*/ return new String[] {"string"}; 4841 case 950398559: /*comment*/ return new String[] {"string"}; 4842 default: return super.getTypesForProperty(hash, name); 4843 } 4844 4845 } 4846 4847 @Override 4848 public Base addChild(String name) throws FHIRException { 4849 if (name.equals("identity")) { 4850 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.mapping.identity"); 4851 } 4852 else if (name.equals("language")) { 4853 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.mapping.language"); 4854 } 4855 else if (name.equals("map")) { 4856 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.mapping.map"); 4857 } 4858 else if (name.equals("comment")) { 4859 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.mapping.comment"); 4860 } 4861 else 4862 return super.addChild(name); 4863 } 4864 4865 public ElementDefinitionMappingComponent copy() { 4866 ElementDefinitionMappingComponent dst = new ElementDefinitionMappingComponent(); 4867 copyValues(dst); 4868 return dst; 4869 } 4870 4871 public void copyValues(ElementDefinitionMappingComponent dst) { 4872 super.copyValues(dst); 4873 dst.identity = identity == null ? null : identity.copy(); 4874 dst.language = language == null ? null : language.copy(); 4875 dst.map = map == null ? null : map.copy(); 4876 dst.comment = comment == null ? null : comment.copy(); 4877 } 4878 4879 @Override 4880 public boolean equalsDeep(Base other_) { 4881 if (!super.equalsDeep(other_)) 4882 return false; 4883 if (!(other_ instanceof ElementDefinitionMappingComponent)) 4884 return false; 4885 ElementDefinitionMappingComponent o = (ElementDefinitionMappingComponent) other_; 4886 return compareDeep(identity, o.identity, true) && compareDeep(language, o.language, true) && compareDeep(map, o.map, true) 4887 && compareDeep(comment, o.comment, true); 4888 } 4889 4890 @Override 4891 public boolean equalsShallow(Base other_) { 4892 if (!super.equalsShallow(other_)) 4893 return false; 4894 if (!(other_ instanceof ElementDefinitionMappingComponent)) 4895 return false; 4896 ElementDefinitionMappingComponent o = (ElementDefinitionMappingComponent) other_; 4897 return compareValues(identity, o.identity, true) && compareValues(language, o.language, true) && compareValues(map, o.map, true) 4898 && compareValues(comment, o.comment, true); 4899 } 4900 4901 public boolean isEmpty() { 4902 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identity, language, map 4903 , comment); 4904 } 4905 4906 public String fhirType() { 4907 return "ElementDefinition.mapping"; 4908 4909 } 4910 4911 } 4912 4913 /** 4914 * The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension. 4915 */ 4916 @Child(name = "path", type = {StringType.class}, order=0, min=1, max=1, modifier=false, summary=true) 4917 @Description(shortDefinition="Path of the element in the hierarchy of elements", formalDefinition="The path identifies the element and is expressed as a \".\"-separated list of ancestor elements, beginning with the name of the resource or extension." ) 4918 protected StringType path; 4919 4920 /** 4921 * Codes that define how this element is represented in instances, when the deviation varies from the normal case. 4922 */ 4923 @Child(name = "representation", type = {CodeType.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 4924 @Description(shortDefinition="xmlAttr | xmlText | typeAttr | cdaText | xhtml", formalDefinition="Codes that define how this element is represented in instances, when the deviation varies from the normal case." ) 4925 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/property-representation") 4926 protected List<Enumeration<PropertyRepresentation>> representation; 4927 4928 /** 4929 * The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element. 4930 */ 4931 @Child(name = "sliceName", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 4932 @Description(shortDefinition="Name for this particular element (in a set of slices)", formalDefinition="The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element." ) 4933 protected StringType sliceName; 4934 4935 /** 4936 * If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName. 4937 */ 4938 @Child(name = "sliceIsConstraining", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=true) 4939 @Description(shortDefinition="If this slice definition constrains an inherited slice definition (or not)", formalDefinition="If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName." ) 4940 protected BooleanType sliceIsConstraining; 4941 4942 /** 4943 * A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form. 4944 */ 4945 @Child(name = "label", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true) 4946 @Description(shortDefinition="Name for element to display with or prompt for element", formalDefinition="A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form." ) 4947 protected StringType label; 4948 4949 /** 4950 * A code that has the same meaning as the element in a particular terminology. 4951 */ 4952 @Child(name = "code", type = {Coding.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 4953 @Description(shortDefinition="Corresponding codes in terminologies", formalDefinition="A code that has the same meaning as the element in a particular terminology." ) 4954 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/observation-codes") 4955 protected List<Coding> code; 4956 4957 /** 4958 * Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set). 4959 */ 4960 @Child(name = "slicing", type = {}, order=6, min=0, max=1, modifier=false, summary=true) 4961 @Description(shortDefinition="This element is sliced - slices follow", formalDefinition="Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set)." ) 4962 protected ElementDefinitionSlicingComponent slicing; 4963 4964 /** 4965 * A concise description of what this element means (e.g. for use in autogenerated summaries). 4966 */ 4967 @Child(name = "short", type = {StringType.class}, order=7, min=0, max=1, modifier=false, summary=true) 4968 @Description(shortDefinition="Concise definition for space-constrained presentation", formalDefinition="A concise description of what this element means (e.g. for use in autogenerated summaries)." ) 4969 protected StringType short_; 4970 4971 /** 4972 * Provides a complete explanation of the meaning of the data element for human readability. For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition). 4973 */ 4974 @Child(name = "definition", type = {MarkdownType.class}, order=8, min=0, max=1, modifier=false, summary=true) 4975 @Description(shortDefinition="Full formal definition as narrative text", formalDefinition="Provides a complete explanation of the meaning of the data element for human readability. For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition)." ) 4976 protected MarkdownType definition; 4977 4978 /** 4979 * Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment). 4980 */ 4981 @Child(name = "comment", type = {MarkdownType.class}, order=9, min=0, max=1, modifier=false, summary=true) 4982 @Description(shortDefinition="Comments about the use of this element", formalDefinition="Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment)." ) 4983 protected MarkdownType comment; 4984 4985 /** 4986 * This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element. 4987 */ 4988 @Child(name = "requirements", type = {MarkdownType.class}, order=10, min=0, max=1, modifier=false, summary=true) 4989 @Description(shortDefinition="Why this resource has been created", formalDefinition="This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element." ) 4990 protected MarkdownType requirements; 4991 4992 /** 4993 * Identifies additional names by which this element might also be known. 4994 */ 4995 @Child(name = "alias", type = {StringType.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 4996 @Description(shortDefinition="Other names", formalDefinition="Identifies additional names by which this element might also be known." ) 4997 protected List<StringType> alias; 4998 4999 /** 5000 * The minimum number of times this element SHALL appear in the instance. 5001 */ 5002 @Child(name = "min", type = {UnsignedIntType.class}, order=12, min=0, max=1, modifier=false, summary=true) 5003 @Description(shortDefinition="Minimum Cardinality", formalDefinition="The minimum number of times this element SHALL appear in the instance." ) 5004 protected UnsignedIntType min; 5005 5006 /** 5007 * The maximum number of times this element is permitted to appear in the instance. 5008 */ 5009 @Child(name = "max", type = {StringType.class}, order=13, min=0, max=1, modifier=false, summary=true) 5010 @Description(shortDefinition="Maximum Cardinality (a number or *)", formalDefinition="The maximum number of times this element is permitted to appear in the instance." ) 5011 protected StringType max; 5012 5013 /** 5014 * Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - i.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same. 5015 */ 5016 @Child(name = "base", type = {}, order=14, min=0, max=1, modifier=false, summary=true) 5017 @Description(shortDefinition="Base definition information for tools", formalDefinition="Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - i.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same." ) 5018 protected ElementDefinitionBaseComponent base; 5019 5020 /** 5021 * Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc. 5022 */ 5023 @Child(name = "contentReference", type = {UriType.class}, order=15, min=0, max=1, modifier=false, summary=true) 5024 @Description(shortDefinition="Reference to definition of content for the element", formalDefinition="Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc." ) 5025 protected UriType contentReference; 5026 5027 /** 5028 * The data type or resource that the value of this element is permitted to be. 5029 */ 5030 @Child(name = "type", type = {}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5031 @Description(shortDefinition="Data type and Profile for this element", formalDefinition="The data type or resource that the value of this element is permitted to be." ) 5032 protected List<TypeRefComponent> type; 5033 5034 /** 5035 * The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false'). 5036 */ 5037 @Child(name = "defaultValue", type = {Base64BinaryType.class, BooleanType.class, CanonicalType.class, CodeType.class, DateType.class, DateTimeType.class, DecimalType.class, IdType.class, InstantType.class, IntegerType.class, Integer64Type.class, MarkdownType.class, OidType.class, PositiveIntType.class, StringType.class, TimeType.class, UnsignedIntType.class, UriType.class, UrlType.class, UuidType.class, Address.class, Age.class, Annotation.class, Attachment.class, CodeableConcept.class, Coding.class, ContactPoint.class, Count.class, Distance.class, Duration.class, HumanName.class, Identifier.class, Money.class, Period.class, Quantity.class, Range.class, Ratio.class, Reference.class, SampledData.class, Signature.class, Timing.class, ContactDetail.class, Contributor.class, DataRequirement.class, Expression.class, ParameterDefinition.class, RelatedArtifact.class, TriggerDefinition.class, UsageContext.class, Dosage.class, Meta.class}, order=17, min=0, max=1, modifier=false, summary=true) 5038 @Description(shortDefinition="Specified value if missing from instance", formalDefinition="The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false')." ) 5039 protected DataType defaultValue; 5040 5041 /** 5042 * The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing'). 5043 */ 5044 @Child(name = "meaningWhenMissing", type = {MarkdownType.class}, order=18, min=0, max=1, modifier=false, summary=true) 5045 @Description(shortDefinition="Implicit meaning when this element is missing", formalDefinition="The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing')." ) 5046 protected MarkdownType meaningWhenMissing; 5047 5048 /** 5049 * If present, indicates that the order of the repeating element has meaning and describes what that meaning is. If absent, it means that the order of the element has no meaning. 5050 */ 5051 @Child(name = "orderMeaning", type = {StringType.class}, order=19, min=0, max=1, modifier=false, summary=true) 5052 @Description(shortDefinition="What the order of the elements means", formalDefinition="If present, indicates that the order of the repeating element has meaning and describes what that meaning is. If absent, it means that the order of the element has no meaning." ) 5053 protected StringType orderMeaning; 5054 5055 /** 5056 * Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing. 5057 */ 5058 @Child(name = "fixed", type = {Base64BinaryType.class, BooleanType.class, CanonicalType.class, CodeType.class, DateType.class, DateTimeType.class, DecimalType.class, IdType.class, InstantType.class, IntegerType.class, Integer64Type.class, MarkdownType.class, OidType.class, PositiveIntType.class, StringType.class, TimeType.class, UnsignedIntType.class, UriType.class, UrlType.class, UuidType.class, Address.class, Age.class, Annotation.class, Attachment.class, CodeableConcept.class, Coding.class, ContactPoint.class, Count.class, Distance.class, Duration.class, HumanName.class, Identifier.class, Money.class, Period.class, Quantity.class, Range.class, Ratio.class, Reference.class, SampledData.class, Signature.class, Timing.class, ContactDetail.class, Contributor.class, DataRequirement.class, Expression.class, ParameterDefinition.class, RelatedArtifact.class, TriggerDefinition.class, UsageContext.class, Dosage.class, Meta.class}, order=20, min=0, max=1, modifier=false, summary=true) 5059 @Description(shortDefinition="Value must be exactly this", formalDefinition="Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing." ) 5060 protected DataType fixed; 5061 5062 /** 5063 * Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 5064 5065When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 5066 5067When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 5068 5069When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 5070 50711. If primitive: it must match exactly the pattern value 50722. If a complex object: it must match (recursively) the pattern value 50733. If an array: it must match (recursively) the pattern value. 5074 */ 5075 @Child(name = "pattern", type = {Base64BinaryType.class, BooleanType.class, CanonicalType.class, CodeType.class, DateType.class, DateTimeType.class, DecimalType.class, IdType.class, InstantType.class, IntegerType.class, Integer64Type.class, MarkdownType.class, OidType.class, PositiveIntType.class, StringType.class, TimeType.class, UnsignedIntType.class, UriType.class, UrlType.class, UuidType.class, Address.class, Age.class, Annotation.class, Attachment.class, CodeableConcept.class, Coding.class, ContactPoint.class, Count.class, Distance.class, Duration.class, HumanName.class, Identifier.class, Money.class, Period.class, Quantity.class, Range.class, Ratio.class, Reference.class, SampledData.class, Signature.class, Timing.class, ContactDetail.class, Contributor.class, DataRequirement.class, Expression.class, ParameterDefinition.class, RelatedArtifact.class, TriggerDefinition.class, UsageContext.class, Dosage.class, Meta.class}, order=21, min=0, max=1, modifier=false, summary=true) 5076 @Description(shortDefinition="Value must have at least these property values", formalDefinition="Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value." ) 5077 protected DataType pattern; 5078 5079 /** 5080 * A sample value for this element demonstrating the type of information that would typically be found in the element. 5081 */ 5082 @Child(name = "example", type = {}, order=22, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5083 @Description(shortDefinition="Example value (as defined for type)", formalDefinition="A sample value for this element demonstrating the type of information that would typically be found in the element." ) 5084 protected List<ElementDefinitionExampleComponent> example; 5085 5086 /** 5087 * The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity. 5088 */ 5089 @Child(name = "minValue", type = {DateType.class, DateTimeType.class, InstantType.class, TimeType.class, DecimalType.class, IntegerType.class, Integer64Type.class, PositiveIntType.class, UnsignedIntType.class, Quantity.class}, order=23, min=0, max=1, modifier=false, summary=true) 5090 @Description(shortDefinition="Minimum Allowed Value (for some types)", formalDefinition="The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity." ) 5091 protected DataType minValue; 5092 5093 /** 5094 * The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity. 5095 */ 5096 @Child(name = "maxValue", type = {DateType.class, DateTimeType.class, InstantType.class, TimeType.class, DecimalType.class, IntegerType.class, Integer64Type.class, PositiveIntType.class, UnsignedIntType.class, Quantity.class}, order=24, min=0, max=1, modifier=false, summary=true) 5097 @Description(shortDefinition="Maximum Allowed Value (for some types)", formalDefinition="The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity." ) 5098 protected DataType maxValue; 5099 5100 /** 5101 * Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element. 5102 */ 5103 @Child(name = "maxLength", type = {IntegerType.class}, order=25, min=0, max=1, modifier=false, summary=true) 5104 @Description(shortDefinition="Max length for strings", formalDefinition="Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element." ) 5105 protected IntegerType maxLength; 5106 5107 /** 5108 * A reference to an invariant that may make additional statements about the cardinality or value in the instance. 5109 */ 5110 @Child(name = "condition", type = {IdType.class}, order=26, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5111 @Description(shortDefinition="Reference to invariant about presence", formalDefinition="A reference to an invariant that may make additional statements about the cardinality or value in the instance." ) 5112 protected List<IdType> condition; 5113 5114 /** 5115 * Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance. 5116 */ 5117 @Child(name = "constraint", type = {}, order=27, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5118 @Description(shortDefinition="Condition that must evaluate to true", formalDefinition="Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance." ) 5119 protected List<ElementDefinitionConstraintComponent> constraint; 5120 5121 /** 5122 * If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation. 5123 */ 5124 @Child(name = "mustSupport", type = {BooleanType.class}, order=28, min=0, max=1, modifier=false, summary=true) 5125 @Description(shortDefinition="If the element must be supported", formalDefinition="If true, implementations that produce or consume resources SHALL provide \"support\" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation." ) 5126 protected BooleanType mustSupport; 5127 5128 /** 5129 * If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system. 5130 */ 5131 @Child(name = "isModifier", type = {BooleanType.class}, order=29, min=0, max=1, modifier=false, summary=true) 5132 @Description(shortDefinition="If this modifies the meaning of other elements", formalDefinition="If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system." ) 5133 protected BooleanType isModifier; 5134 5135 /** 5136 * Explains how that element affects the interpretation of the resource or element that contains it. 5137 */ 5138 @Child(name = "isModifierReason", type = {StringType.class}, order=30, min=0, max=1, modifier=false, summary=true) 5139 @Description(shortDefinition="Reason that this element is marked as a modifier", formalDefinition="Explains how that element affects the interpretation of the resource or element that contains it." ) 5140 protected StringType isModifierReason; 5141 5142 /** 5143 * Whether the element should be included if a client requests a search with the parameter _summary=true. 5144 */ 5145 @Child(name = "isSummary", type = {BooleanType.class}, order=31, min=0, max=1, modifier=false, summary=true) 5146 @Description(shortDefinition="Include when _summary = true?", formalDefinition="Whether the element should be included if a client requests a search with the parameter _summary=true." ) 5147 protected BooleanType isSummary; 5148 5149 /** 5150 * Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri). 5151 */ 5152 @Child(name = "binding", type = {}, order=32, min=0, max=1, modifier=false, summary=true) 5153 @Description(shortDefinition="ValueSet details if this is coded", formalDefinition="Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri)." ) 5154 protected ElementDefinitionBindingComponent binding; 5155 5156 /** 5157 * Identifies a concept from an external specification that roughly corresponds to this element. 5158 */ 5159 @Child(name = "mapping", type = {}, order=33, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5160 @Description(shortDefinition="Map element to another set of definitions", formalDefinition="Identifies a concept from an external specification that roughly corresponds to this element." ) 5161 protected List<ElementDefinitionMappingComponent> mapping; 5162 5163 private static final long serialVersionUID = 821951601L; 5164 5165 /** 5166 * Constructor 5167 */ 5168 public ElementDefinition() { 5169 super(); 5170 } 5171 5172 /** 5173 * Constructor 5174 */ 5175 public ElementDefinition(String path) { 5176 super(); 5177 this.setPath(path); 5178 } 5179 5180 /** 5181 * @return {@link #path} (The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value 5182 */ 5183 public StringType getPathElement() { 5184 if (this.path == null) 5185 if (Configuration.errorOnAutoCreate()) 5186 throw new Error("Attempt to auto-create ElementDefinition.path"); 5187 else if (Configuration.doAutoCreate()) 5188 this.path = new StringType(); // bb 5189 return this.path; 5190 } 5191 5192 public boolean hasPathElement() { 5193 return this.path != null && !this.path.isEmpty(); 5194 } 5195 5196 public boolean hasPath() { 5197 return this.path != null && !this.path.isEmpty(); 5198 } 5199 5200 /** 5201 * @param value {@link #path} (The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value 5202 */ 5203 public ElementDefinition setPathElement(StringType value) { 5204 this.path = value; 5205 return this; 5206 } 5207 5208 /** 5209 * @return The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension. 5210 */ 5211 public String getPath() { 5212 return this.path == null ? null : this.path.getValue(); 5213 } 5214 5215 /** 5216 * @param value The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension. 5217 */ 5218 public ElementDefinition setPath(String value) { 5219 if (this.path == null) 5220 this.path = new StringType(); 5221 this.path.setValue(value); 5222 return this; 5223 } 5224 5225 /** 5226 * @return {@link #representation} (Codes that define how this element is represented in instances, when the deviation varies from the normal case.) 5227 */ 5228 public List<Enumeration<PropertyRepresentation>> getRepresentation() { 5229 if (this.representation == null) 5230 this.representation = new ArrayList<Enumeration<PropertyRepresentation>>(); 5231 return this.representation; 5232 } 5233 5234 /** 5235 * @return Returns a reference to <code>this</code> for easy method chaining 5236 */ 5237 public ElementDefinition setRepresentation(List<Enumeration<PropertyRepresentation>> theRepresentation) { 5238 this.representation = theRepresentation; 5239 return this; 5240 } 5241 5242 public boolean hasRepresentation() { 5243 if (this.representation == null) 5244 return false; 5245 for (Enumeration<PropertyRepresentation> item : this.representation) 5246 if (!item.isEmpty()) 5247 return true; 5248 return false; 5249 } 5250 5251 /** 5252 * @return {@link #representation} (Codes that define how this element is represented in instances, when the deviation varies from the normal case.) 5253 */ 5254 public Enumeration<PropertyRepresentation> addRepresentationElement() {//2 5255 Enumeration<PropertyRepresentation> t = new Enumeration<PropertyRepresentation>(new PropertyRepresentationEnumFactory()); 5256 if (this.representation == null) 5257 this.representation = new ArrayList<Enumeration<PropertyRepresentation>>(); 5258 this.representation.add(t); 5259 return t; 5260 } 5261 5262 /** 5263 * @param value {@link #representation} (Codes that define how this element is represented in instances, when the deviation varies from the normal case.) 5264 */ 5265 public ElementDefinition addRepresentation(PropertyRepresentation value) { //1 5266 Enumeration<PropertyRepresentation> t = new Enumeration<PropertyRepresentation>(new PropertyRepresentationEnumFactory()); 5267 t.setValue(value); 5268 if (this.representation == null) 5269 this.representation = new ArrayList<Enumeration<PropertyRepresentation>>(); 5270 this.representation.add(t); 5271 return this; 5272 } 5273 5274 /** 5275 * @param value {@link #representation} (Codes that define how this element is represented in instances, when the deviation varies from the normal case.) 5276 */ 5277 public boolean hasRepresentation(PropertyRepresentation value) { 5278 if (this.representation == null) 5279 return false; 5280 for (Enumeration<PropertyRepresentation> v : this.representation) 5281 if (v.getValue().equals(value)) // code 5282 return true; 5283 return false; 5284 } 5285 5286 /** 5287 * @return {@link #sliceName} (The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.). This is the underlying object with id, value and extensions. The accessor "getSliceName" gives direct access to the value 5288 */ 5289 public StringType getSliceNameElement() { 5290 if (this.sliceName == null) 5291 if (Configuration.errorOnAutoCreate()) 5292 throw new Error("Attempt to auto-create ElementDefinition.sliceName"); 5293 else if (Configuration.doAutoCreate()) 5294 this.sliceName = new StringType(); // bb 5295 return this.sliceName; 5296 } 5297 5298 public boolean hasSliceNameElement() { 5299 return this.sliceName != null && !this.sliceName.isEmpty(); 5300 } 5301 5302 public boolean hasSliceName() { 5303 return this.sliceName != null && !this.sliceName.isEmpty(); 5304 } 5305 5306 /** 5307 * @param value {@link #sliceName} (The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.). This is the underlying object with id, value and extensions. The accessor "getSliceName" gives direct access to the value 5308 */ 5309 public ElementDefinition setSliceNameElement(StringType value) { 5310 this.sliceName = value; 5311 return this; 5312 } 5313 5314 /** 5315 * @return The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element. 5316 */ 5317 public String getSliceName() { 5318 return this.sliceName == null ? null : this.sliceName.getValue(); 5319 } 5320 5321 /** 5322 * @param value The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element. 5323 */ 5324 public ElementDefinition setSliceName(String value) { 5325 if (Utilities.noString(value)) 5326 this.sliceName = null; 5327 else { 5328 if (this.sliceName == null) 5329 this.sliceName = new StringType(); 5330 this.sliceName.setValue(value); 5331 } 5332 return this; 5333 } 5334 5335 /** 5336 * @return {@link #sliceIsConstraining} (If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.). This is the underlying object with id, value and extensions. The accessor "getSliceIsConstraining" gives direct access to the value 5337 */ 5338 public BooleanType getSliceIsConstrainingElement() { 5339 if (this.sliceIsConstraining == null) 5340 if (Configuration.errorOnAutoCreate()) 5341 throw new Error("Attempt to auto-create ElementDefinition.sliceIsConstraining"); 5342 else if (Configuration.doAutoCreate()) 5343 this.sliceIsConstraining = new BooleanType(); // bb 5344 return this.sliceIsConstraining; 5345 } 5346 5347 public boolean hasSliceIsConstrainingElement() { 5348 return this.sliceIsConstraining != null && !this.sliceIsConstraining.isEmpty(); 5349 } 5350 5351 public boolean hasSliceIsConstraining() { 5352 return this.sliceIsConstraining != null && !this.sliceIsConstraining.isEmpty(); 5353 } 5354 5355 /** 5356 * @param value {@link #sliceIsConstraining} (If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.). This is the underlying object with id, value and extensions. The accessor "getSliceIsConstraining" gives direct access to the value 5357 */ 5358 public ElementDefinition setSliceIsConstrainingElement(BooleanType value) { 5359 this.sliceIsConstraining = value; 5360 return this; 5361 } 5362 5363 /** 5364 * @return If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName. 5365 */ 5366 public boolean getSliceIsConstraining() { 5367 return this.sliceIsConstraining == null || this.sliceIsConstraining.isEmpty() ? false : this.sliceIsConstraining.getValue(); 5368 } 5369 5370 /** 5371 * @param value If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName. 5372 */ 5373 public ElementDefinition setSliceIsConstraining(boolean value) { 5374 if (this.sliceIsConstraining == null) 5375 this.sliceIsConstraining = new BooleanType(); 5376 this.sliceIsConstraining.setValue(value); 5377 return this; 5378 } 5379 5380 /** 5381 * @return {@link #label} (A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value 5382 */ 5383 public StringType getLabelElement() { 5384 if (this.label == null) 5385 if (Configuration.errorOnAutoCreate()) 5386 throw new Error("Attempt to auto-create ElementDefinition.label"); 5387 else if (Configuration.doAutoCreate()) 5388 this.label = new StringType(); // bb 5389 return this.label; 5390 } 5391 5392 public boolean hasLabelElement() { 5393 return this.label != null && !this.label.isEmpty(); 5394 } 5395 5396 public boolean hasLabel() { 5397 return this.label != null && !this.label.isEmpty(); 5398 } 5399 5400 /** 5401 * @param value {@link #label} (A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value 5402 */ 5403 public ElementDefinition setLabelElement(StringType value) { 5404 this.label = value; 5405 return this; 5406 } 5407 5408 /** 5409 * @return A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form. 5410 */ 5411 public String getLabel() { 5412 return this.label == null ? null : this.label.getValue(); 5413 } 5414 5415 /** 5416 * @param value A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form. 5417 */ 5418 public ElementDefinition setLabel(String value) { 5419 if (Utilities.noString(value)) 5420 this.label = null; 5421 else { 5422 if (this.label == null) 5423 this.label = new StringType(); 5424 this.label.setValue(value); 5425 } 5426 return this; 5427 } 5428 5429 /** 5430 * @return {@link #code} (A code that has the same meaning as the element in a particular terminology.) 5431 */ 5432 public List<Coding> getCode() { 5433 if (this.code == null) 5434 this.code = new ArrayList<Coding>(); 5435 return this.code; 5436 } 5437 5438 /** 5439 * @return Returns a reference to <code>this</code> for easy method chaining 5440 */ 5441 public ElementDefinition setCode(List<Coding> theCode) { 5442 this.code = theCode; 5443 return this; 5444 } 5445 5446 public boolean hasCode() { 5447 if (this.code == null) 5448 return false; 5449 for (Coding item : this.code) 5450 if (!item.isEmpty()) 5451 return true; 5452 return false; 5453 } 5454 5455 public Coding addCode() { //3 5456 Coding t = new Coding(); 5457 if (this.code == null) 5458 this.code = new ArrayList<Coding>(); 5459 this.code.add(t); 5460 return t; 5461 } 5462 5463 public ElementDefinition addCode(Coding t) { //3 5464 if (t == null) 5465 return this; 5466 if (this.code == null) 5467 this.code = new ArrayList<Coding>(); 5468 this.code.add(t); 5469 return this; 5470 } 5471 5472 /** 5473 * @return The first repetition of repeating field {@link #code}, creating it if it does not already exist {3} 5474 */ 5475 public Coding getCodeFirstRep() { 5476 if (getCode().isEmpty()) { 5477 addCode(); 5478 } 5479 return getCode().get(0); 5480 } 5481 5482 /** 5483 * @return {@link #slicing} (Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set).) 5484 */ 5485 public ElementDefinitionSlicingComponent getSlicing() { 5486 if (this.slicing == null) 5487 if (Configuration.errorOnAutoCreate()) 5488 throw new Error("Attempt to auto-create ElementDefinition.slicing"); 5489 else if (Configuration.doAutoCreate()) 5490 this.slicing = new ElementDefinitionSlicingComponent(); // cc 5491 return this.slicing; 5492 } 5493 5494 public boolean hasSlicing() { 5495 return this.slicing != null && !this.slicing.isEmpty(); 5496 } 5497 5498 /** 5499 * @param value {@link #slicing} (Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set).) 5500 */ 5501 public ElementDefinition setSlicing(ElementDefinitionSlicingComponent value) { 5502 this.slicing = value; 5503 return this; 5504 } 5505 5506 /** 5507 * @return {@link #short_} (A concise description of what this element means (e.g. for use in autogenerated summaries).). This is the underlying object with id, value and extensions. The accessor "getShort" gives direct access to the value 5508 */ 5509 public StringType getShortElement() { 5510 if (this.short_ == null) 5511 if (Configuration.errorOnAutoCreate()) 5512 throw new Error("Attempt to auto-create ElementDefinition.short_"); 5513 else if (Configuration.doAutoCreate()) 5514 this.short_ = new StringType(); // bb 5515 return this.short_; 5516 } 5517 5518 public boolean hasShortElement() { 5519 return this.short_ != null && !this.short_.isEmpty(); 5520 } 5521 5522 public boolean hasShort() { 5523 return this.short_ != null && !this.short_.isEmpty(); 5524 } 5525 5526 /** 5527 * @param value {@link #short_} (A concise description of what this element means (e.g. for use in autogenerated summaries).). This is the underlying object with id, value and extensions. The accessor "getShort" gives direct access to the value 5528 */ 5529 public ElementDefinition setShortElement(StringType value) { 5530 this.short_ = value; 5531 return this; 5532 } 5533 5534 /** 5535 * @return A concise description of what this element means (e.g. for use in autogenerated summaries). 5536 */ 5537 public String getShort() { 5538 return this.short_ == null ? null : this.short_.getValue(); 5539 } 5540 5541 /** 5542 * @param value A concise description of what this element means (e.g. for use in autogenerated summaries). 5543 */ 5544 public ElementDefinition setShort(String value) { 5545 if (Utilities.noString(value)) 5546 this.short_ = null; 5547 else { 5548 if (this.short_ == null) 5549 this.short_ = new StringType(); 5550 this.short_.setValue(value); 5551 } 5552 return this; 5553 } 5554 5555 /** 5556 * @return {@link #definition} (Provides a complete explanation of the meaning of the data element for human readability. For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 5557 */ 5558 public MarkdownType getDefinitionElement() { 5559 if (this.definition == null) 5560 if (Configuration.errorOnAutoCreate()) 5561 throw new Error("Attempt to auto-create ElementDefinition.definition"); 5562 else if (Configuration.doAutoCreate()) 5563 this.definition = new MarkdownType(); // bb 5564 return this.definition; 5565 } 5566 5567 public boolean hasDefinitionElement() { 5568 return this.definition != null && !this.definition.isEmpty(); 5569 } 5570 5571 public boolean hasDefinition() { 5572 return this.definition != null && !this.definition.isEmpty(); 5573 } 5574 5575 /** 5576 * @param value {@link #definition} (Provides a complete explanation of the meaning of the data element for human readability. For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 5577 */ 5578 public ElementDefinition setDefinitionElement(MarkdownType value) { 5579 this.definition = value; 5580 return this; 5581 } 5582 5583 /** 5584 * @return Provides a complete explanation of the meaning of the data element for human readability. For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition). 5585 */ 5586 public String getDefinition() { 5587 return this.definition == null ? null : this.definition.getValue(); 5588 } 5589 5590 /** 5591 * @param value Provides a complete explanation of the meaning of the data element for human readability. For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition). 5592 */ 5593 public ElementDefinition setDefinition(String value) { 5594 if (value == null) 5595 this.definition = null; 5596 else { 5597 if (this.definition == null) 5598 this.definition = new MarkdownType(); 5599 this.definition.setValue(value); 5600 } 5601 return this; 5602 } 5603 5604 /** 5605 * @return {@link #comment} (Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value 5606 */ 5607 public MarkdownType getCommentElement() { 5608 if (this.comment == null) 5609 if (Configuration.errorOnAutoCreate()) 5610 throw new Error("Attempt to auto-create ElementDefinition.comment"); 5611 else if (Configuration.doAutoCreate()) 5612 this.comment = new MarkdownType(); // bb 5613 return this.comment; 5614 } 5615 5616 public boolean hasCommentElement() { 5617 return this.comment != null && !this.comment.isEmpty(); 5618 } 5619 5620 public boolean hasComment() { 5621 return this.comment != null && !this.comment.isEmpty(); 5622 } 5623 5624 /** 5625 * @param value {@link #comment} (Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value 5626 */ 5627 public ElementDefinition setCommentElement(MarkdownType value) { 5628 this.comment = value; 5629 return this; 5630 } 5631 5632 /** 5633 * @return Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment). 5634 */ 5635 public String getComment() { 5636 return this.comment == null ? null : this.comment.getValue(); 5637 } 5638 5639 /** 5640 * @param value Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment). 5641 */ 5642 public ElementDefinition setComment(String value) { 5643 if (value == null) 5644 this.comment = null; 5645 else { 5646 if (this.comment == null) 5647 this.comment = new MarkdownType(); 5648 this.comment.setValue(value); 5649 } 5650 return this; 5651 } 5652 5653 /** 5654 * @return {@link #requirements} (This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value 5655 */ 5656 public MarkdownType getRequirementsElement() { 5657 if (this.requirements == null) 5658 if (Configuration.errorOnAutoCreate()) 5659 throw new Error("Attempt to auto-create ElementDefinition.requirements"); 5660 else if (Configuration.doAutoCreate()) 5661 this.requirements = new MarkdownType(); // bb 5662 return this.requirements; 5663 } 5664 5665 public boolean hasRequirementsElement() { 5666 return this.requirements != null && !this.requirements.isEmpty(); 5667 } 5668 5669 public boolean hasRequirements() { 5670 return this.requirements != null && !this.requirements.isEmpty(); 5671 } 5672 5673 /** 5674 * @param value {@link #requirements} (This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value 5675 */ 5676 public ElementDefinition setRequirementsElement(MarkdownType value) { 5677 this.requirements = value; 5678 return this; 5679 } 5680 5681 /** 5682 * @return This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element. 5683 */ 5684 public String getRequirements() { 5685 return this.requirements == null ? null : this.requirements.getValue(); 5686 } 5687 5688 /** 5689 * @param value This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element. 5690 */ 5691 public ElementDefinition setRequirements(String value) { 5692 if (value == null) 5693 this.requirements = null; 5694 else { 5695 if (this.requirements == null) 5696 this.requirements = new MarkdownType(); 5697 this.requirements.setValue(value); 5698 } 5699 return this; 5700 } 5701 5702 /** 5703 * @return {@link #alias} (Identifies additional names by which this element might also be known.) 5704 */ 5705 public List<StringType> getAlias() { 5706 if (this.alias == null) 5707 this.alias = new ArrayList<StringType>(); 5708 return this.alias; 5709 } 5710 5711 /** 5712 * @return Returns a reference to <code>this</code> for easy method chaining 5713 */ 5714 public ElementDefinition setAlias(List<StringType> theAlias) { 5715 this.alias = theAlias; 5716 return this; 5717 } 5718 5719 public boolean hasAlias() { 5720 if (this.alias == null) 5721 return false; 5722 for (StringType item : this.alias) 5723 if (!item.isEmpty()) 5724 return true; 5725 return false; 5726 } 5727 5728 /** 5729 * @return {@link #alias} (Identifies additional names by which this element might also be known.) 5730 */ 5731 public StringType addAliasElement() {//2 5732 StringType t = new StringType(); 5733 if (this.alias == null) 5734 this.alias = new ArrayList<StringType>(); 5735 this.alias.add(t); 5736 return t; 5737 } 5738 5739 /** 5740 * @param value {@link #alias} (Identifies additional names by which this element might also be known.) 5741 */ 5742 public ElementDefinition addAlias(String value) { //1 5743 StringType t = new StringType(); 5744 t.setValue(value); 5745 if (this.alias == null) 5746 this.alias = new ArrayList<StringType>(); 5747 this.alias.add(t); 5748 return this; 5749 } 5750 5751 /** 5752 * @param value {@link #alias} (Identifies additional names by which this element might also be known.) 5753 */ 5754 public boolean hasAlias(String value) { 5755 if (this.alias == null) 5756 return false; 5757 for (StringType v : this.alias) 5758 if (v.getValue().equals(value)) // string 5759 return true; 5760 return false; 5761 } 5762 5763 /** 5764 * @return {@link #min} (The minimum number of times this element SHALL appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value 5765 */ 5766 public UnsignedIntType getMinElement() { 5767 if (this.min == null) 5768 if (Configuration.errorOnAutoCreate()) 5769 throw new Error("Attempt to auto-create ElementDefinition.min"); 5770 else if (Configuration.doAutoCreate()) 5771 this.min = new UnsignedIntType(); // bb 5772 return this.min; 5773 } 5774 5775 public boolean hasMinElement() { 5776 return this.min != null && !this.min.isEmpty(); 5777 } 5778 5779 public boolean hasMin() { 5780 return this.min != null && !this.min.isEmpty(); 5781 } 5782 5783 /** 5784 * @param value {@link #min} (The minimum number of times this element SHALL appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value 5785 */ 5786 public ElementDefinition setMinElement(UnsignedIntType value) { 5787 this.min = value; 5788 return this; 5789 } 5790 5791 /** 5792 * @return The minimum number of times this element SHALL appear in the instance. 5793 */ 5794 public int getMin() { 5795 return this.min == null || this.min.isEmpty() ? 0 : this.min.getValue(); 5796 } 5797 5798 /** 5799 * @param value The minimum number of times this element SHALL appear in the instance. 5800 */ 5801 public ElementDefinition setMin(int value) { 5802 if (this.min == null) 5803 this.min = new UnsignedIntType(); 5804 this.min.setValue(value); 5805 return this; 5806 } 5807 5808 /** 5809 * @return {@link #max} (The maximum number of times this element is permitted to appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value 5810 */ 5811 public StringType getMaxElement() { 5812 if (this.max == null) 5813 if (Configuration.errorOnAutoCreate()) 5814 throw new Error("Attempt to auto-create ElementDefinition.max"); 5815 else if (Configuration.doAutoCreate()) 5816 this.max = new StringType(); // bb 5817 return this.max; 5818 } 5819 5820 public boolean hasMaxElement() { 5821 return this.max != null && !this.max.isEmpty(); 5822 } 5823 5824 public boolean hasMax() { 5825 return this.max != null && !this.max.isEmpty(); 5826 } 5827 5828 /** 5829 * @param value {@link #max} (The maximum number of times this element is permitted to appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value 5830 */ 5831 public ElementDefinition setMaxElement(StringType value) { 5832 this.max = value; 5833 return this; 5834 } 5835 5836 /** 5837 * @return The maximum number of times this element is permitted to appear in the instance. 5838 */ 5839 public String getMax() { 5840 return this.max == null ? null : this.max.getValue(); 5841 } 5842 5843 /** 5844 * @param value The maximum number of times this element is permitted to appear in the instance. 5845 */ 5846 public ElementDefinition setMax(String value) { 5847 if (Utilities.noString(value)) 5848 this.max = null; 5849 else { 5850 if (this.max == null) 5851 this.max = new StringType(); 5852 this.max.setValue(value); 5853 } 5854 return this; 5855 } 5856 5857 /** 5858 * @return {@link #base} (Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - i.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same.) 5859 */ 5860 public ElementDefinitionBaseComponent getBase() { 5861 if (this.base == null) 5862 if (Configuration.errorOnAutoCreate()) 5863 throw new Error("Attempt to auto-create ElementDefinition.base"); 5864 else if (Configuration.doAutoCreate()) 5865 this.base = new ElementDefinitionBaseComponent(); // cc 5866 return this.base; 5867 } 5868 5869 public boolean hasBase() { 5870 return this.base != null && !this.base.isEmpty(); 5871 } 5872 5873 /** 5874 * @param value {@link #base} (Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - i.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same.) 5875 */ 5876 public ElementDefinition setBase(ElementDefinitionBaseComponent value) { 5877 this.base = value; 5878 return this; 5879 } 5880 5881 /** 5882 * @return {@link #contentReference} (Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.). This is the underlying object with id, value and extensions. The accessor "getContentReference" gives direct access to the value 5883 */ 5884 public UriType getContentReferenceElement() { 5885 if (this.contentReference == null) 5886 if (Configuration.errorOnAutoCreate()) 5887 throw new Error("Attempt to auto-create ElementDefinition.contentReference"); 5888 else if (Configuration.doAutoCreate()) 5889 this.contentReference = new UriType(); // bb 5890 return this.contentReference; 5891 } 5892 5893 public boolean hasContentReferenceElement() { 5894 return this.contentReference != null && !this.contentReference.isEmpty(); 5895 } 5896 5897 public boolean hasContentReference() { 5898 return this.contentReference != null && !this.contentReference.isEmpty(); 5899 } 5900 5901 /** 5902 * @param value {@link #contentReference} (Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.). This is the underlying object with id, value and extensions. The accessor "getContentReference" gives direct access to the value 5903 */ 5904 public ElementDefinition setContentReferenceElement(UriType value) { 5905 this.contentReference = value; 5906 return this; 5907 } 5908 5909 /** 5910 * @return Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc. 5911 */ 5912 public String getContentReference() { 5913 return this.contentReference == null ? null : this.contentReference.getValue(); 5914 } 5915 5916 /** 5917 * @param value Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc. 5918 */ 5919 public ElementDefinition setContentReference(String value) { 5920 if (Utilities.noString(value)) 5921 this.contentReference = null; 5922 else { 5923 if (this.contentReference == null) 5924 this.contentReference = new UriType(); 5925 this.contentReference.setValue(value); 5926 } 5927 return this; 5928 } 5929 5930 /** 5931 * @return {@link #type} (The data type or resource that the value of this element is permitted to be.) 5932 */ 5933 public List<TypeRefComponent> getType() { 5934 if (this.type == null) 5935 this.type = new ArrayList<TypeRefComponent>(); 5936 return this.type; 5937 } 5938 5939 /** 5940 * @return Returns a reference to <code>this</code> for easy method chaining 5941 */ 5942 public ElementDefinition setType(List<TypeRefComponent> theType) { 5943 this.type = theType; 5944 return this; 5945 } 5946 5947 public boolean hasType() { 5948 if (this.type == null) 5949 return false; 5950 for (TypeRefComponent item : this.type) 5951 if (!item.isEmpty()) 5952 return true; 5953 return false; 5954 } 5955 5956 public TypeRefComponent addType() { //3 5957 TypeRefComponent t = new TypeRefComponent(); 5958 if (this.type == null) 5959 this.type = new ArrayList<TypeRefComponent>(); 5960 this.type.add(t); 5961 return t; 5962 } 5963 5964 public ElementDefinition addType(TypeRefComponent t) { //3 5965 if (t == null) 5966 return this; 5967 if (this.type == null) 5968 this.type = new ArrayList<TypeRefComponent>(); 5969 this.type.add(t); 5970 return this; 5971 } 5972 5973 /** 5974 * @return The first repetition of repeating field {@link #type}, creating it if it does not already exist {3} 5975 */ 5976 public TypeRefComponent getTypeFirstRep() { 5977 if (getType().isEmpty()) { 5978 addType(); 5979 } 5980 return getType().get(0); 5981 } 5982 5983 /** 5984 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 5985 */ 5986 public DataType getDefaultValue() { 5987 return this.defaultValue; 5988 } 5989 5990 /** 5991 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 5992 */ 5993 public Base64BinaryType getDefaultValueBase64BinaryType() throws FHIRException { 5994 if (this.defaultValue == null) 5995 this.defaultValue = new Base64BinaryType(); 5996 if (!(this.defaultValue instanceof Base64BinaryType)) 5997 throw new FHIRException("Type mismatch: the type Base64BinaryType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 5998 return (Base64BinaryType) this.defaultValue; 5999 } 6000 6001 public boolean hasDefaultValueBase64BinaryType() { 6002 return this != null && this.defaultValue instanceof Base64BinaryType; 6003 } 6004 6005 /** 6006 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6007 */ 6008 public BooleanType getDefaultValueBooleanType() throws FHIRException { 6009 if (this.defaultValue == null) 6010 this.defaultValue = new BooleanType(); 6011 if (!(this.defaultValue instanceof BooleanType)) 6012 throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6013 return (BooleanType) this.defaultValue; 6014 } 6015 6016 public boolean hasDefaultValueBooleanType() { 6017 return this != null && this.defaultValue instanceof BooleanType; 6018 } 6019 6020 /** 6021 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6022 */ 6023 public CanonicalType getDefaultValueCanonicalType() throws FHIRException { 6024 if (this.defaultValue == null) 6025 this.defaultValue = new CanonicalType(); 6026 if (!(this.defaultValue instanceof CanonicalType)) 6027 throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6028 return (CanonicalType) this.defaultValue; 6029 } 6030 6031 public boolean hasDefaultValueCanonicalType() { 6032 return this != null && this.defaultValue instanceof CanonicalType; 6033 } 6034 6035 /** 6036 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6037 */ 6038 public CodeType getDefaultValueCodeType() throws FHIRException { 6039 if (this.defaultValue == null) 6040 this.defaultValue = new CodeType(); 6041 if (!(this.defaultValue instanceof CodeType)) 6042 throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6043 return (CodeType) this.defaultValue; 6044 } 6045 6046 public boolean hasDefaultValueCodeType() { 6047 return this != null && this.defaultValue instanceof CodeType; 6048 } 6049 6050 /** 6051 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6052 */ 6053 public DateType getDefaultValueDateType() throws FHIRException { 6054 if (this.defaultValue == null) 6055 this.defaultValue = new DateType(); 6056 if (!(this.defaultValue instanceof DateType)) 6057 throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6058 return (DateType) this.defaultValue; 6059 } 6060 6061 public boolean hasDefaultValueDateType() { 6062 return this != null && this.defaultValue instanceof DateType; 6063 } 6064 6065 /** 6066 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6067 */ 6068 public DateTimeType getDefaultValueDateTimeType() throws FHIRException { 6069 if (this.defaultValue == null) 6070 this.defaultValue = new DateTimeType(); 6071 if (!(this.defaultValue instanceof DateTimeType)) 6072 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6073 return (DateTimeType) this.defaultValue; 6074 } 6075 6076 public boolean hasDefaultValueDateTimeType() { 6077 return this != null && this.defaultValue instanceof DateTimeType; 6078 } 6079 6080 /** 6081 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6082 */ 6083 public DecimalType getDefaultValueDecimalType() throws FHIRException { 6084 if (this.defaultValue == null) 6085 this.defaultValue = new DecimalType(); 6086 if (!(this.defaultValue instanceof DecimalType)) 6087 throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6088 return (DecimalType) this.defaultValue; 6089 } 6090 6091 public boolean hasDefaultValueDecimalType() { 6092 return this != null && this.defaultValue instanceof DecimalType; 6093 } 6094 6095 /** 6096 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6097 */ 6098 public IdType getDefaultValueIdType() throws FHIRException { 6099 if (this.defaultValue == null) 6100 this.defaultValue = new IdType(); 6101 if (!(this.defaultValue instanceof IdType)) 6102 throw new FHIRException("Type mismatch: the type IdType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6103 return (IdType) this.defaultValue; 6104 } 6105 6106 public boolean hasDefaultValueIdType() { 6107 return this != null && this.defaultValue instanceof IdType; 6108 } 6109 6110 /** 6111 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6112 */ 6113 public InstantType getDefaultValueInstantType() throws FHIRException { 6114 if (this.defaultValue == null) 6115 this.defaultValue = new InstantType(); 6116 if (!(this.defaultValue instanceof InstantType)) 6117 throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6118 return (InstantType) this.defaultValue; 6119 } 6120 6121 public boolean hasDefaultValueInstantType() { 6122 return this != null && this.defaultValue instanceof InstantType; 6123 } 6124 6125 /** 6126 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6127 */ 6128 public IntegerType getDefaultValueIntegerType() throws FHIRException { 6129 if (this.defaultValue == null) 6130 this.defaultValue = new IntegerType(); 6131 if (!(this.defaultValue instanceof IntegerType)) 6132 throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6133 return (IntegerType) this.defaultValue; 6134 } 6135 6136 public boolean hasDefaultValueIntegerType() { 6137 return this != null && this.defaultValue instanceof IntegerType; 6138 } 6139 6140 /** 6141 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6142 */ 6143 public Integer64Type getDefaultValueInteger64Type() throws FHIRException { 6144 if (this.defaultValue == null) 6145 this.defaultValue = new Integer64Type(); 6146 if (!(this.defaultValue instanceof Integer64Type)) 6147 throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6148 return (Integer64Type) this.defaultValue; 6149 } 6150 6151 public boolean hasDefaultValueInteger64Type() { 6152 return this != null && this.defaultValue instanceof Integer64Type; 6153 } 6154 6155 /** 6156 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6157 */ 6158 public MarkdownType getDefaultValueMarkdownType() throws FHIRException { 6159 if (this.defaultValue == null) 6160 this.defaultValue = new MarkdownType(); 6161 if (!(this.defaultValue instanceof MarkdownType)) 6162 throw new FHIRException("Type mismatch: the type MarkdownType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6163 return (MarkdownType) this.defaultValue; 6164 } 6165 6166 public boolean hasDefaultValueMarkdownType() { 6167 return this != null && this.defaultValue instanceof MarkdownType; 6168 } 6169 6170 /** 6171 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6172 */ 6173 public OidType getDefaultValueOidType() throws FHIRException { 6174 if (this.defaultValue == null) 6175 this.defaultValue = new OidType(); 6176 if (!(this.defaultValue instanceof OidType)) 6177 throw new FHIRException("Type mismatch: the type OidType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6178 return (OidType) this.defaultValue; 6179 } 6180 6181 public boolean hasDefaultValueOidType() { 6182 return this != null && this.defaultValue instanceof OidType; 6183 } 6184 6185 /** 6186 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6187 */ 6188 public PositiveIntType getDefaultValuePositiveIntType() throws FHIRException { 6189 if (this.defaultValue == null) 6190 this.defaultValue = new PositiveIntType(); 6191 if (!(this.defaultValue instanceof PositiveIntType)) 6192 throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6193 return (PositiveIntType) this.defaultValue; 6194 } 6195 6196 public boolean hasDefaultValuePositiveIntType() { 6197 return this != null && this.defaultValue instanceof PositiveIntType; 6198 } 6199 6200 /** 6201 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6202 */ 6203 public StringType getDefaultValueStringType() throws FHIRException { 6204 if (this.defaultValue == null) 6205 this.defaultValue = new StringType(); 6206 if (!(this.defaultValue instanceof StringType)) 6207 throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6208 return (StringType) this.defaultValue; 6209 } 6210 6211 public boolean hasDefaultValueStringType() { 6212 return this != null && this.defaultValue instanceof StringType; 6213 } 6214 6215 /** 6216 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6217 */ 6218 public TimeType getDefaultValueTimeType() throws FHIRException { 6219 if (this.defaultValue == null) 6220 this.defaultValue = new TimeType(); 6221 if (!(this.defaultValue instanceof TimeType)) 6222 throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6223 return (TimeType) this.defaultValue; 6224 } 6225 6226 public boolean hasDefaultValueTimeType() { 6227 return this != null && this.defaultValue instanceof TimeType; 6228 } 6229 6230 /** 6231 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6232 */ 6233 public UnsignedIntType getDefaultValueUnsignedIntType() throws FHIRException { 6234 if (this.defaultValue == null) 6235 this.defaultValue = new UnsignedIntType(); 6236 if (!(this.defaultValue instanceof UnsignedIntType)) 6237 throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6238 return (UnsignedIntType) this.defaultValue; 6239 } 6240 6241 public boolean hasDefaultValueUnsignedIntType() { 6242 return this != null && this.defaultValue instanceof UnsignedIntType; 6243 } 6244 6245 /** 6246 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6247 */ 6248 public UriType getDefaultValueUriType() throws FHIRException { 6249 if (this.defaultValue == null) 6250 this.defaultValue = new UriType(); 6251 if (!(this.defaultValue instanceof UriType)) 6252 throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6253 return (UriType) this.defaultValue; 6254 } 6255 6256 public boolean hasDefaultValueUriType() { 6257 return this != null && this.defaultValue instanceof UriType; 6258 } 6259 6260 /** 6261 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6262 */ 6263 public UrlType getDefaultValueUrlType() throws FHIRException { 6264 if (this.defaultValue == null) 6265 this.defaultValue = new UrlType(); 6266 if (!(this.defaultValue instanceof UrlType)) 6267 throw new FHIRException("Type mismatch: the type UrlType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6268 return (UrlType) this.defaultValue; 6269 } 6270 6271 public boolean hasDefaultValueUrlType() { 6272 return this != null && this.defaultValue instanceof UrlType; 6273 } 6274 6275 /** 6276 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6277 */ 6278 public UuidType getDefaultValueUuidType() throws FHIRException { 6279 if (this.defaultValue == null) 6280 this.defaultValue = new UuidType(); 6281 if (!(this.defaultValue instanceof UuidType)) 6282 throw new FHIRException("Type mismatch: the type UuidType was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6283 return (UuidType) this.defaultValue; 6284 } 6285 6286 public boolean hasDefaultValueUuidType() { 6287 return this != null && this.defaultValue instanceof UuidType; 6288 } 6289 6290 /** 6291 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6292 */ 6293 public Address getDefaultValueAddress() throws FHIRException { 6294 if (this.defaultValue == null) 6295 this.defaultValue = new Address(); 6296 if (!(this.defaultValue instanceof Address)) 6297 throw new FHIRException("Type mismatch: the type Address was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6298 return (Address) this.defaultValue; 6299 } 6300 6301 public boolean hasDefaultValueAddress() { 6302 return this != null && this.defaultValue instanceof Address; 6303 } 6304 6305 /** 6306 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6307 */ 6308 public Age getDefaultValueAge() throws FHIRException { 6309 if (this.defaultValue == null) 6310 this.defaultValue = new Age(); 6311 if (!(this.defaultValue instanceof Age)) 6312 throw new FHIRException("Type mismatch: the type Age was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6313 return (Age) this.defaultValue; 6314 } 6315 6316 public boolean hasDefaultValueAge() { 6317 return this != null && this.defaultValue instanceof Age; 6318 } 6319 6320 /** 6321 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6322 */ 6323 public Annotation getDefaultValueAnnotation() throws FHIRException { 6324 if (this.defaultValue == null) 6325 this.defaultValue = new Annotation(); 6326 if (!(this.defaultValue instanceof Annotation)) 6327 throw new FHIRException("Type mismatch: the type Annotation was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6328 return (Annotation) this.defaultValue; 6329 } 6330 6331 public boolean hasDefaultValueAnnotation() { 6332 return this != null && this.defaultValue instanceof Annotation; 6333 } 6334 6335 /** 6336 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6337 */ 6338 public Attachment getDefaultValueAttachment() throws FHIRException { 6339 if (this.defaultValue == null) 6340 this.defaultValue = new Attachment(); 6341 if (!(this.defaultValue instanceof Attachment)) 6342 throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6343 return (Attachment) this.defaultValue; 6344 } 6345 6346 public boolean hasDefaultValueAttachment() { 6347 return this != null && this.defaultValue instanceof Attachment; 6348 } 6349 6350 /** 6351 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6352 */ 6353 public CodeableConcept getDefaultValueCodeableConcept() throws FHIRException { 6354 if (this.defaultValue == null) 6355 this.defaultValue = new CodeableConcept(); 6356 if (!(this.defaultValue instanceof CodeableConcept)) 6357 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6358 return (CodeableConcept) this.defaultValue; 6359 } 6360 6361 public boolean hasDefaultValueCodeableConcept() { 6362 return this != null && this.defaultValue instanceof CodeableConcept; 6363 } 6364 6365 /** 6366 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6367 */ 6368 public Coding getDefaultValueCoding() throws FHIRException { 6369 if (this.defaultValue == null) 6370 this.defaultValue = new Coding(); 6371 if (!(this.defaultValue instanceof Coding)) 6372 throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6373 return (Coding) this.defaultValue; 6374 } 6375 6376 public boolean hasDefaultValueCoding() { 6377 return this != null && this.defaultValue instanceof Coding; 6378 } 6379 6380 /** 6381 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6382 */ 6383 public ContactPoint getDefaultValueContactPoint() throws FHIRException { 6384 if (this.defaultValue == null) 6385 this.defaultValue = new ContactPoint(); 6386 if (!(this.defaultValue instanceof ContactPoint)) 6387 throw new FHIRException("Type mismatch: the type ContactPoint was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6388 return (ContactPoint) this.defaultValue; 6389 } 6390 6391 public boolean hasDefaultValueContactPoint() { 6392 return this != null && this.defaultValue instanceof ContactPoint; 6393 } 6394 6395 /** 6396 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6397 */ 6398 public Count getDefaultValueCount() throws FHIRException { 6399 if (this.defaultValue == null) 6400 this.defaultValue = new Count(); 6401 if (!(this.defaultValue instanceof Count)) 6402 throw new FHIRException("Type mismatch: the type Count was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6403 return (Count) this.defaultValue; 6404 } 6405 6406 public boolean hasDefaultValueCount() { 6407 return this != null && this.defaultValue instanceof Count; 6408 } 6409 6410 /** 6411 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6412 */ 6413 public Distance getDefaultValueDistance() throws FHIRException { 6414 if (this.defaultValue == null) 6415 this.defaultValue = new Distance(); 6416 if (!(this.defaultValue instanceof Distance)) 6417 throw new FHIRException("Type mismatch: the type Distance was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6418 return (Distance) this.defaultValue; 6419 } 6420 6421 public boolean hasDefaultValueDistance() { 6422 return this != null && this.defaultValue instanceof Distance; 6423 } 6424 6425 /** 6426 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6427 */ 6428 public Duration getDefaultValueDuration() throws FHIRException { 6429 if (this.defaultValue == null) 6430 this.defaultValue = new Duration(); 6431 if (!(this.defaultValue instanceof Duration)) 6432 throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6433 return (Duration) this.defaultValue; 6434 } 6435 6436 public boolean hasDefaultValueDuration() { 6437 return this != null && this.defaultValue instanceof Duration; 6438 } 6439 6440 /** 6441 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6442 */ 6443 public HumanName getDefaultValueHumanName() throws FHIRException { 6444 if (this.defaultValue == null) 6445 this.defaultValue = new HumanName(); 6446 if (!(this.defaultValue instanceof HumanName)) 6447 throw new FHIRException("Type mismatch: the type HumanName was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6448 return (HumanName) this.defaultValue; 6449 } 6450 6451 public boolean hasDefaultValueHumanName() { 6452 return this != null && this.defaultValue instanceof HumanName; 6453 } 6454 6455 /** 6456 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6457 */ 6458 public Identifier getDefaultValueIdentifier() throws FHIRException { 6459 if (this.defaultValue == null) 6460 this.defaultValue = new Identifier(); 6461 if (!(this.defaultValue instanceof Identifier)) 6462 throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6463 return (Identifier) this.defaultValue; 6464 } 6465 6466 public boolean hasDefaultValueIdentifier() { 6467 return this != null && this.defaultValue instanceof Identifier; 6468 } 6469 6470 /** 6471 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6472 */ 6473 public Money getDefaultValueMoney() throws FHIRException { 6474 if (this.defaultValue == null) 6475 this.defaultValue = new Money(); 6476 if (!(this.defaultValue instanceof Money)) 6477 throw new FHIRException("Type mismatch: the type Money was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6478 return (Money) this.defaultValue; 6479 } 6480 6481 public boolean hasDefaultValueMoney() { 6482 return this != null && this.defaultValue instanceof Money; 6483 } 6484 6485 /** 6486 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6487 */ 6488 public Period getDefaultValuePeriod() throws FHIRException { 6489 if (this.defaultValue == null) 6490 this.defaultValue = new Period(); 6491 if (!(this.defaultValue instanceof Period)) 6492 throw new FHIRException("Type mismatch: the type Period was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6493 return (Period) this.defaultValue; 6494 } 6495 6496 public boolean hasDefaultValuePeriod() { 6497 return this != null && this.defaultValue instanceof Period; 6498 } 6499 6500 /** 6501 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6502 */ 6503 public Quantity getDefaultValueQuantity() throws FHIRException { 6504 if (this.defaultValue == null) 6505 this.defaultValue = new Quantity(); 6506 if (!(this.defaultValue instanceof Quantity)) 6507 throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6508 return (Quantity) this.defaultValue; 6509 } 6510 6511 public boolean hasDefaultValueQuantity() { 6512 return this != null && this.defaultValue instanceof Quantity; 6513 } 6514 6515 /** 6516 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6517 */ 6518 public Range getDefaultValueRange() throws FHIRException { 6519 if (this.defaultValue == null) 6520 this.defaultValue = new Range(); 6521 if (!(this.defaultValue instanceof Range)) 6522 throw new FHIRException("Type mismatch: the type Range was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6523 return (Range) this.defaultValue; 6524 } 6525 6526 public boolean hasDefaultValueRange() { 6527 return this != null && this.defaultValue instanceof Range; 6528 } 6529 6530 /** 6531 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6532 */ 6533 public Ratio getDefaultValueRatio() throws FHIRException { 6534 if (this.defaultValue == null) 6535 this.defaultValue = new Ratio(); 6536 if (!(this.defaultValue instanceof Ratio)) 6537 throw new FHIRException("Type mismatch: the type Ratio was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6538 return (Ratio) this.defaultValue; 6539 } 6540 6541 public boolean hasDefaultValueRatio() { 6542 return this != null && this.defaultValue instanceof Ratio; 6543 } 6544 6545 /** 6546 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6547 */ 6548 public Reference getDefaultValueReference() throws FHIRException { 6549 if (this.defaultValue == null) 6550 this.defaultValue = new Reference(); 6551 if (!(this.defaultValue instanceof Reference)) 6552 throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6553 return (Reference) this.defaultValue; 6554 } 6555 6556 public boolean hasDefaultValueReference() { 6557 return this != null && this.defaultValue instanceof Reference; 6558 } 6559 6560 /** 6561 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6562 */ 6563 public SampledData getDefaultValueSampledData() throws FHIRException { 6564 if (this.defaultValue == null) 6565 this.defaultValue = new SampledData(); 6566 if (!(this.defaultValue instanceof SampledData)) 6567 throw new FHIRException("Type mismatch: the type SampledData was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6568 return (SampledData) this.defaultValue; 6569 } 6570 6571 public boolean hasDefaultValueSampledData() { 6572 return this != null && this.defaultValue instanceof SampledData; 6573 } 6574 6575 /** 6576 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6577 */ 6578 public Signature getDefaultValueSignature() throws FHIRException { 6579 if (this.defaultValue == null) 6580 this.defaultValue = new Signature(); 6581 if (!(this.defaultValue instanceof Signature)) 6582 throw new FHIRException("Type mismatch: the type Signature was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6583 return (Signature) this.defaultValue; 6584 } 6585 6586 public boolean hasDefaultValueSignature() { 6587 return this != null && this.defaultValue instanceof Signature; 6588 } 6589 6590 /** 6591 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6592 */ 6593 public Timing getDefaultValueTiming() throws FHIRException { 6594 if (this.defaultValue == null) 6595 this.defaultValue = new Timing(); 6596 if (!(this.defaultValue instanceof Timing)) 6597 throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6598 return (Timing) this.defaultValue; 6599 } 6600 6601 public boolean hasDefaultValueTiming() { 6602 return this != null && this.defaultValue instanceof Timing; 6603 } 6604 6605 /** 6606 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6607 */ 6608 public ContactDetail getDefaultValueContactDetail() throws FHIRException { 6609 if (this.defaultValue == null) 6610 this.defaultValue = new ContactDetail(); 6611 if (!(this.defaultValue instanceof ContactDetail)) 6612 throw new FHIRException("Type mismatch: the type ContactDetail was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6613 return (ContactDetail) this.defaultValue; 6614 } 6615 6616 public boolean hasDefaultValueContactDetail() { 6617 return this != null && this.defaultValue instanceof ContactDetail; 6618 } 6619 6620 /** 6621 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6622 */ 6623 public Contributor getDefaultValueContributor() throws FHIRException { 6624 if (this.defaultValue == null) 6625 this.defaultValue = new Contributor(); 6626 if (!(this.defaultValue instanceof Contributor)) 6627 throw new FHIRException("Type mismatch: the type Contributor was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6628 return (Contributor) this.defaultValue; 6629 } 6630 6631 public boolean hasDefaultValueContributor() { 6632 return this != null && this.defaultValue instanceof Contributor; 6633 } 6634 6635 /** 6636 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6637 */ 6638 public DataRequirement getDefaultValueDataRequirement() throws FHIRException { 6639 if (this.defaultValue == null) 6640 this.defaultValue = new DataRequirement(); 6641 if (!(this.defaultValue instanceof DataRequirement)) 6642 throw new FHIRException("Type mismatch: the type DataRequirement was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6643 return (DataRequirement) this.defaultValue; 6644 } 6645 6646 public boolean hasDefaultValueDataRequirement() { 6647 return this != null && this.defaultValue instanceof DataRequirement; 6648 } 6649 6650 /** 6651 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6652 */ 6653 public Expression getDefaultValueExpression() throws FHIRException { 6654 if (this.defaultValue == null) 6655 this.defaultValue = new Expression(); 6656 if (!(this.defaultValue instanceof Expression)) 6657 throw new FHIRException("Type mismatch: the type Expression was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6658 return (Expression) this.defaultValue; 6659 } 6660 6661 public boolean hasDefaultValueExpression() { 6662 return this != null && this.defaultValue instanceof Expression; 6663 } 6664 6665 /** 6666 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6667 */ 6668 public ParameterDefinition getDefaultValueParameterDefinition() throws FHIRException { 6669 if (this.defaultValue == null) 6670 this.defaultValue = new ParameterDefinition(); 6671 if (!(this.defaultValue instanceof ParameterDefinition)) 6672 throw new FHIRException("Type mismatch: the type ParameterDefinition was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6673 return (ParameterDefinition) this.defaultValue; 6674 } 6675 6676 public boolean hasDefaultValueParameterDefinition() { 6677 return this != null && this.defaultValue instanceof ParameterDefinition; 6678 } 6679 6680 /** 6681 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6682 */ 6683 public RelatedArtifact getDefaultValueRelatedArtifact() throws FHIRException { 6684 if (this.defaultValue == null) 6685 this.defaultValue = new RelatedArtifact(); 6686 if (!(this.defaultValue instanceof RelatedArtifact)) 6687 throw new FHIRException("Type mismatch: the type RelatedArtifact was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6688 return (RelatedArtifact) this.defaultValue; 6689 } 6690 6691 public boolean hasDefaultValueRelatedArtifact() { 6692 return this != null && this.defaultValue instanceof RelatedArtifact; 6693 } 6694 6695 /** 6696 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6697 */ 6698 public TriggerDefinition getDefaultValueTriggerDefinition() throws FHIRException { 6699 if (this.defaultValue == null) 6700 this.defaultValue = new TriggerDefinition(); 6701 if (!(this.defaultValue instanceof TriggerDefinition)) 6702 throw new FHIRException("Type mismatch: the type TriggerDefinition was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6703 return (TriggerDefinition) this.defaultValue; 6704 } 6705 6706 public boolean hasDefaultValueTriggerDefinition() { 6707 return this != null && this.defaultValue instanceof TriggerDefinition; 6708 } 6709 6710 /** 6711 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6712 */ 6713 public UsageContext getDefaultValueUsageContext() throws FHIRException { 6714 if (this.defaultValue == null) 6715 this.defaultValue = new UsageContext(); 6716 if (!(this.defaultValue instanceof UsageContext)) 6717 throw new FHIRException("Type mismatch: the type UsageContext was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6718 return (UsageContext) this.defaultValue; 6719 } 6720 6721 public boolean hasDefaultValueUsageContext() { 6722 return this != null && this.defaultValue instanceof UsageContext; 6723 } 6724 6725 /** 6726 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6727 */ 6728 public Dosage getDefaultValueDosage() throws FHIRException { 6729 if (this.defaultValue == null) 6730 this.defaultValue = new Dosage(); 6731 if (!(this.defaultValue instanceof Dosage)) 6732 throw new FHIRException("Type mismatch: the type Dosage was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6733 return (Dosage) this.defaultValue; 6734 } 6735 6736 public boolean hasDefaultValueDosage() { 6737 return this != null && this.defaultValue instanceof Dosage; 6738 } 6739 6740 /** 6741 * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6742 */ 6743 public Meta getDefaultValueMeta() throws FHIRException { 6744 if (this.defaultValue == null) 6745 this.defaultValue = new Meta(); 6746 if (!(this.defaultValue instanceof Meta)) 6747 throw new FHIRException("Type mismatch: the type Meta was expected, but "+this.defaultValue.getClass().getName()+" was encountered"); 6748 return (Meta) this.defaultValue; 6749 } 6750 6751 public boolean hasDefaultValueMeta() { 6752 return this != null && this.defaultValue instanceof Meta; 6753 } 6754 6755 public boolean hasDefaultValue() { 6756 return this.defaultValue != null && !this.defaultValue.isEmpty(); 6757 } 6758 6759 /** 6760 * @param value {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').) 6761 */ 6762 public ElementDefinition setDefaultValue(DataType value) { 6763 if (value != null && !(value instanceof Base64BinaryType || value instanceof BooleanType || value instanceof CanonicalType || value instanceof CodeType || value instanceof DateType || value instanceof DateTimeType || value instanceof DecimalType || value instanceof IdType || value instanceof InstantType || value instanceof IntegerType || value instanceof Integer64Type || value instanceof MarkdownType || value instanceof OidType || value instanceof PositiveIntType || value instanceof StringType || value instanceof TimeType || value instanceof UnsignedIntType || value instanceof UriType || value instanceof UrlType || value instanceof UuidType || value instanceof Address || value instanceof Age || value instanceof Annotation || value instanceof Attachment || value instanceof CodeableConcept || value instanceof Coding || value instanceof ContactPoint || value instanceof Count || value instanceof Distance || value instanceof Duration || value instanceof HumanName || value instanceof Identifier || value instanceof Money || value instanceof Period || value instanceof Quantity || value instanceof Range || value instanceof Ratio || value instanceof Reference || value instanceof SampledData || value instanceof Signature || value instanceof Timing || value instanceof ContactDetail || value instanceof Contributor || value instanceof DataRequirement || value instanceof Expression || value instanceof ParameterDefinition || value instanceof RelatedArtifact || value instanceof TriggerDefinition || value instanceof UsageContext || value instanceof Dosage || value instanceof Meta)) 6764 throw new Error("Not the right type for ElementDefinition.defaultValue[x]: "+value.fhirType()); 6765 this.defaultValue = value; 6766 return this; 6767 } 6768 6769 /** 6770 * @return {@link #meaningWhenMissing} (The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').). This is the underlying object with id, value and extensions. The accessor "getMeaningWhenMissing" gives direct access to the value 6771 */ 6772 public MarkdownType getMeaningWhenMissingElement() { 6773 if (this.meaningWhenMissing == null) 6774 if (Configuration.errorOnAutoCreate()) 6775 throw new Error("Attempt to auto-create ElementDefinition.meaningWhenMissing"); 6776 else if (Configuration.doAutoCreate()) 6777 this.meaningWhenMissing = new MarkdownType(); // bb 6778 return this.meaningWhenMissing; 6779 } 6780 6781 public boolean hasMeaningWhenMissingElement() { 6782 return this.meaningWhenMissing != null && !this.meaningWhenMissing.isEmpty(); 6783 } 6784 6785 public boolean hasMeaningWhenMissing() { 6786 return this.meaningWhenMissing != null && !this.meaningWhenMissing.isEmpty(); 6787 } 6788 6789 /** 6790 * @param value {@link #meaningWhenMissing} (The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').). This is the underlying object with id, value and extensions. The accessor "getMeaningWhenMissing" gives direct access to the value 6791 */ 6792 public ElementDefinition setMeaningWhenMissingElement(MarkdownType value) { 6793 this.meaningWhenMissing = value; 6794 return this; 6795 } 6796 6797 /** 6798 * @return The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing'). 6799 */ 6800 public String getMeaningWhenMissing() { 6801 return this.meaningWhenMissing == null ? null : this.meaningWhenMissing.getValue(); 6802 } 6803 6804 /** 6805 * @param value The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing'). 6806 */ 6807 public ElementDefinition setMeaningWhenMissing(String value) { 6808 if (value == null) 6809 this.meaningWhenMissing = null; 6810 else { 6811 if (this.meaningWhenMissing == null) 6812 this.meaningWhenMissing = new MarkdownType(); 6813 this.meaningWhenMissing.setValue(value); 6814 } 6815 return this; 6816 } 6817 6818 /** 6819 * @return {@link #orderMeaning} (If present, indicates that the order of the repeating element has meaning and describes what that meaning is. If absent, it means that the order of the element has no meaning.). This is the underlying object with id, value and extensions. The accessor "getOrderMeaning" gives direct access to the value 6820 */ 6821 public StringType getOrderMeaningElement() { 6822 if (this.orderMeaning == null) 6823 if (Configuration.errorOnAutoCreate()) 6824 throw new Error("Attempt to auto-create ElementDefinition.orderMeaning"); 6825 else if (Configuration.doAutoCreate()) 6826 this.orderMeaning = new StringType(); // bb 6827 return this.orderMeaning; 6828 } 6829 6830 public boolean hasOrderMeaningElement() { 6831 return this.orderMeaning != null && !this.orderMeaning.isEmpty(); 6832 } 6833 6834 public boolean hasOrderMeaning() { 6835 return this.orderMeaning != null && !this.orderMeaning.isEmpty(); 6836 } 6837 6838 /** 6839 * @param value {@link #orderMeaning} (If present, indicates that the order of the repeating element has meaning and describes what that meaning is. If absent, it means that the order of the element has no meaning.). This is the underlying object with id, value and extensions. The accessor "getOrderMeaning" gives direct access to the value 6840 */ 6841 public ElementDefinition setOrderMeaningElement(StringType value) { 6842 this.orderMeaning = value; 6843 return this; 6844 } 6845 6846 /** 6847 * @return If present, indicates that the order of the repeating element has meaning and describes what that meaning is. If absent, it means that the order of the element has no meaning. 6848 */ 6849 public String getOrderMeaning() { 6850 return this.orderMeaning == null ? null : this.orderMeaning.getValue(); 6851 } 6852 6853 /** 6854 * @param value If present, indicates that the order of the repeating element has meaning and describes what that meaning is. If absent, it means that the order of the element has no meaning. 6855 */ 6856 public ElementDefinition setOrderMeaning(String value) { 6857 if (Utilities.noString(value)) 6858 this.orderMeaning = null; 6859 else { 6860 if (this.orderMeaning == null) 6861 this.orderMeaning = new StringType(); 6862 this.orderMeaning.setValue(value); 6863 } 6864 return this; 6865 } 6866 6867 /** 6868 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6869 */ 6870 public DataType getFixed() { 6871 return this.fixed; 6872 } 6873 6874 /** 6875 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6876 */ 6877 public Base64BinaryType getFixedBase64BinaryType() throws FHIRException { 6878 if (this.fixed == null) 6879 this.fixed = new Base64BinaryType(); 6880 if (!(this.fixed instanceof Base64BinaryType)) 6881 throw new FHIRException("Type mismatch: the type Base64BinaryType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 6882 return (Base64BinaryType) this.fixed; 6883 } 6884 6885 public boolean hasFixedBase64BinaryType() { 6886 return this != null && this.fixed instanceof Base64BinaryType; 6887 } 6888 6889 /** 6890 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6891 */ 6892 public BooleanType getFixedBooleanType() throws FHIRException { 6893 if (this.fixed == null) 6894 this.fixed = new BooleanType(); 6895 if (!(this.fixed instanceof BooleanType)) 6896 throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 6897 return (BooleanType) this.fixed; 6898 } 6899 6900 public boolean hasFixedBooleanType() { 6901 return this != null && this.fixed instanceof BooleanType; 6902 } 6903 6904 /** 6905 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6906 */ 6907 public CanonicalType getFixedCanonicalType() throws FHIRException { 6908 if (this.fixed == null) 6909 this.fixed = new CanonicalType(); 6910 if (!(this.fixed instanceof CanonicalType)) 6911 throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 6912 return (CanonicalType) this.fixed; 6913 } 6914 6915 public boolean hasFixedCanonicalType() { 6916 return this != null && this.fixed instanceof CanonicalType; 6917 } 6918 6919 /** 6920 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6921 */ 6922 public CodeType getFixedCodeType() throws FHIRException { 6923 if (this.fixed == null) 6924 this.fixed = new CodeType(); 6925 if (!(this.fixed instanceof CodeType)) 6926 throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 6927 return (CodeType) this.fixed; 6928 } 6929 6930 public boolean hasFixedCodeType() { 6931 return this != null && this.fixed instanceof CodeType; 6932 } 6933 6934 /** 6935 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6936 */ 6937 public DateType getFixedDateType() throws FHIRException { 6938 if (this.fixed == null) 6939 this.fixed = new DateType(); 6940 if (!(this.fixed instanceof DateType)) 6941 throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 6942 return (DateType) this.fixed; 6943 } 6944 6945 public boolean hasFixedDateType() { 6946 return this != null && this.fixed instanceof DateType; 6947 } 6948 6949 /** 6950 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6951 */ 6952 public DateTimeType getFixedDateTimeType() throws FHIRException { 6953 if (this.fixed == null) 6954 this.fixed = new DateTimeType(); 6955 if (!(this.fixed instanceof DateTimeType)) 6956 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 6957 return (DateTimeType) this.fixed; 6958 } 6959 6960 public boolean hasFixedDateTimeType() { 6961 return this != null && this.fixed instanceof DateTimeType; 6962 } 6963 6964 /** 6965 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6966 */ 6967 public DecimalType getFixedDecimalType() throws FHIRException { 6968 if (this.fixed == null) 6969 this.fixed = new DecimalType(); 6970 if (!(this.fixed instanceof DecimalType)) 6971 throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 6972 return (DecimalType) this.fixed; 6973 } 6974 6975 public boolean hasFixedDecimalType() { 6976 return this != null && this.fixed instanceof DecimalType; 6977 } 6978 6979 /** 6980 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6981 */ 6982 public IdType getFixedIdType() throws FHIRException { 6983 if (this.fixed == null) 6984 this.fixed = new IdType(); 6985 if (!(this.fixed instanceof IdType)) 6986 throw new FHIRException("Type mismatch: the type IdType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 6987 return (IdType) this.fixed; 6988 } 6989 6990 public boolean hasFixedIdType() { 6991 return this != null && this.fixed instanceof IdType; 6992 } 6993 6994 /** 6995 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 6996 */ 6997 public InstantType getFixedInstantType() throws FHIRException { 6998 if (this.fixed == null) 6999 this.fixed = new InstantType(); 7000 if (!(this.fixed instanceof InstantType)) 7001 throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7002 return (InstantType) this.fixed; 7003 } 7004 7005 public boolean hasFixedInstantType() { 7006 return this != null && this.fixed instanceof InstantType; 7007 } 7008 7009 /** 7010 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7011 */ 7012 public IntegerType getFixedIntegerType() throws FHIRException { 7013 if (this.fixed == null) 7014 this.fixed = new IntegerType(); 7015 if (!(this.fixed instanceof IntegerType)) 7016 throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7017 return (IntegerType) this.fixed; 7018 } 7019 7020 public boolean hasFixedIntegerType() { 7021 return this != null && this.fixed instanceof IntegerType; 7022 } 7023 7024 /** 7025 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7026 */ 7027 public Integer64Type getFixedInteger64Type() throws FHIRException { 7028 if (this.fixed == null) 7029 this.fixed = new Integer64Type(); 7030 if (!(this.fixed instanceof Integer64Type)) 7031 throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7032 return (Integer64Type) this.fixed; 7033 } 7034 7035 public boolean hasFixedInteger64Type() { 7036 return this != null && this.fixed instanceof Integer64Type; 7037 } 7038 7039 /** 7040 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7041 */ 7042 public MarkdownType getFixedMarkdownType() throws FHIRException { 7043 if (this.fixed == null) 7044 this.fixed = new MarkdownType(); 7045 if (!(this.fixed instanceof MarkdownType)) 7046 throw new FHIRException("Type mismatch: the type MarkdownType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7047 return (MarkdownType) this.fixed; 7048 } 7049 7050 public boolean hasFixedMarkdownType() { 7051 return this != null && this.fixed instanceof MarkdownType; 7052 } 7053 7054 /** 7055 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7056 */ 7057 public OidType getFixedOidType() throws FHIRException { 7058 if (this.fixed == null) 7059 this.fixed = new OidType(); 7060 if (!(this.fixed instanceof OidType)) 7061 throw new FHIRException("Type mismatch: the type OidType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7062 return (OidType) this.fixed; 7063 } 7064 7065 public boolean hasFixedOidType() { 7066 return this != null && this.fixed instanceof OidType; 7067 } 7068 7069 /** 7070 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7071 */ 7072 public PositiveIntType getFixedPositiveIntType() throws FHIRException { 7073 if (this.fixed == null) 7074 this.fixed = new PositiveIntType(); 7075 if (!(this.fixed instanceof PositiveIntType)) 7076 throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7077 return (PositiveIntType) this.fixed; 7078 } 7079 7080 public boolean hasFixedPositiveIntType() { 7081 return this != null && this.fixed instanceof PositiveIntType; 7082 } 7083 7084 /** 7085 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7086 */ 7087 public StringType getFixedStringType() throws FHIRException { 7088 if (this.fixed == null) 7089 this.fixed = new StringType(); 7090 if (!(this.fixed instanceof StringType)) 7091 throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7092 return (StringType) this.fixed; 7093 } 7094 7095 public boolean hasFixedStringType() { 7096 return this != null && this.fixed instanceof StringType; 7097 } 7098 7099 /** 7100 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7101 */ 7102 public TimeType getFixedTimeType() throws FHIRException { 7103 if (this.fixed == null) 7104 this.fixed = new TimeType(); 7105 if (!(this.fixed instanceof TimeType)) 7106 throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7107 return (TimeType) this.fixed; 7108 } 7109 7110 public boolean hasFixedTimeType() { 7111 return this != null && this.fixed instanceof TimeType; 7112 } 7113 7114 /** 7115 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7116 */ 7117 public UnsignedIntType getFixedUnsignedIntType() throws FHIRException { 7118 if (this.fixed == null) 7119 this.fixed = new UnsignedIntType(); 7120 if (!(this.fixed instanceof UnsignedIntType)) 7121 throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7122 return (UnsignedIntType) this.fixed; 7123 } 7124 7125 public boolean hasFixedUnsignedIntType() { 7126 return this != null && this.fixed instanceof UnsignedIntType; 7127 } 7128 7129 /** 7130 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7131 */ 7132 public UriType getFixedUriType() throws FHIRException { 7133 if (this.fixed == null) 7134 this.fixed = new UriType(); 7135 if (!(this.fixed instanceof UriType)) 7136 throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7137 return (UriType) this.fixed; 7138 } 7139 7140 public boolean hasFixedUriType() { 7141 return this != null && this.fixed instanceof UriType; 7142 } 7143 7144 /** 7145 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7146 */ 7147 public UrlType getFixedUrlType() throws FHIRException { 7148 if (this.fixed == null) 7149 this.fixed = new UrlType(); 7150 if (!(this.fixed instanceof UrlType)) 7151 throw new FHIRException("Type mismatch: the type UrlType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7152 return (UrlType) this.fixed; 7153 } 7154 7155 public boolean hasFixedUrlType() { 7156 return this != null && this.fixed instanceof UrlType; 7157 } 7158 7159 /** 7160 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7161 */ 7162 public UuidType getFixedUuidType() throws FHIRException { 7163 if (this.fixed == null) 7164 this.fixed = new UuidType(); 7165 if (!(this.fixed instanceof UuidType)) 7166 throw new FHIRException("Type mismatch: the type UuidType was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7167 return (UuidType) this.fixed; 7168 } 7169 7170 public boolean hasFixedUuidType() { 7171 return this != null && this.fixed instanceof UuidType; 7172 } 7173 7174 /** 7175 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7176 */ 7177 public Address getFixedAddress() throws FHIRException { 7178 if (this.fixed == null) 7179 this.fixed = new Address(); 7180 if (!(this.fixed instanceof Address)) 7181 throw new FHIRException("Type mismatch: the type Address was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7182 return (Address) this.fixed; 7183 } 7184 7185 public boolean hasFixedAddress() { 7186 return this != null && this.fixed instanceof Address; 7187 } 7188 7189 /** 7190 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7191 */ 7192 public Age getFixedAge() throws FHIRException { 7193 if (this.fixed == null) 7194 this.fixed = new Age(); 7195 if (!(this.fixed instanceof Age)) 7196 throw new FHIRException("Type mismatch: the type Age was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7197 return (Age) this.fixed; 7198 } 7199 7200 public boolean hasFixedAge() { 7201 return this != null && this.fixed instanceof Age; 7202 } 7203 7204 /** 7205 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7206 */ 7207 public Annotation getFixedAnnotation() throws FHIRException { 7208 if (this.fixed == null) 7209 this.fixed = new Annotation(); 7210 if (!(this.fixed instanceof Annotation)) 7211 throw new FHIRException("Type mismatch: the type Annotation was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7212 return (Annotation) this.fixed; 7213 } 7214 7215 public boolean hasFixedAnnotation() { 7216 return this != null && this.fixed instanceof Annotation; 7217 } 7218 7219 /** 7220 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7221 */ 7222 public Attachment getFixedAttachment() throws FHIRException { 7223 if (this.fixed == null) 7224 this.fixed = new Attachment(); 7225 if (!(this.fixed instanceof Attachment)) 7226 throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7227 return (Attachment) this.fixed; 7228 } 7229 7230 public boolean hasFixedAttachment() { 7231 return this != null && this.fixed instanceof Attachment; 7232 } 7233 7234 /** 7235 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7236 */ 7237 public CodeableConcept getFixedCodeableConcept() throws FHIRException { 7238 if (this.fixed == null) 7239 this.fixed = new CodeableConcept(); 7240 if (!(this.fixed instanceof CodeableConcept)) 7241 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7242 return (CodeableConcept) this.fixed; 7243 } 7244 7245 public boolean hasFixedCodeableConcept() { 7246 return this != null && this.fixed instanceof CodeableConcept; 7247 } 7248 7249 /** 7250 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7251 */ 7252 public Coding getFixedCoding() throws FHIRException { 7253 if (this.fixed == null) 7254 this.fixed = new Coding(); 7255 if (!(this.fixed instanceof Coding)) 7256 throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7257 return (Coding) this.fixed; 7258 } 7259 7260 public boolean hasFixedCoding() { 7261 return this != null && this.fixed instanceof Coding; 7262 } 7263 7264 /** 7265 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7266 */ 7267 public ContactPoint getFixedContactPoint() throws FHIRException { 7268 if (this.fixed == null) 7269 this.fixed = new ContactPoint(); 7270 if (!(this.fixed instanceof ContactPoint)) 7271 throw new FHIRException("Type mismatch: the type ContactPoint was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7272 return (ContactPoint) this.fixed; 7273 } 7274 7275 public boolean hasFixedContactPoint() { 7276 return this != null && this.fixed instanceof ContactPoint; 7277 } 7278 7279 /** 7280 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7281 */ 7282 public Count getFixedCount() throws FHIRException { 7283 if (this.fixed == null) 7284 this.fixed = new Count(); 7285 if (!(this.fixed instanceof Count)) 7286 throw new FHIRException("Type mismatch: the type Count was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7287 return (Count) this.fixed; 7288 } 7289 7290 public boolean hasFixedCount() { 7291 return this != null && this.fixed instanceof Count; 7292 } 7293 7294 /** 7295 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7296 */ 7297 public Distance getFixedDistance() throws FHIRException { 7298 if (this.fixed == null) 7299 this.fixed = new Distance(); 7300 if (!(this.fixed instanceof Distance)) 7301 throw new FHIRException("Type mismatch: the type Distance was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7302 return (Distance) this.fixed; 7303 } 7304 7305 public boolean hasFixedDistance() { 7306 return this != null && this.fixed instanceof Distance; 7307 } 7308 7309 /** 7310 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7311 */ 7312 public Duration getFixedDuration() throws FHIRException { 7313 if (this.fixed == null) 7314 this.fixed = new Duration(); 7315 if (!(this.fixed instanceof Duration)) 7316 throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7317 return (Duration) this.fixed; 7318 } 7319 7320 public boolean hasFixedDuration() { 7321 return this != null && this.fixed instanceof Duration; 7322 } 7323 7324 /** 7325 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7326 */ 7327 public HumanName getFixedHumanName() throws FHIRException { 7328 if (this.fixed == null) 7329 this.fixed = new HumanName(); 7330 if (!(this.fixed instanceof HumanName)) 7331 throw new FHIRException("Type mismatch: the type HumanName was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7332 return (HumanName) this.fixed; 7333 } 7334 7335 public boolean hasFixedHumanName() { 7336 return this != null && this.fixed instanceof HumanName; 7337 } 7338 7339 /** 7340 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7341 */ 7342 public Identifier getFixedIdentifier() throws FHIRException { 7343 if (this.fixed == null) 7344 this.fixed = new Identifier(); 7345 if (!(this.fixed instanceof Identifier)) 7346 throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7347 return (Identifier) this.fixed; 7348 } 7349 7350 public boolean hasFixedIdentifier() { 7351 return this != null && this.fixed instanceof Identifier; 7352 } 7353 7354 /** 7355 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7356 */ 7357 public Money getFixedMoney() throws FHIRException { 7358 if (this.fixed == null) 7359 this.fixed = new Money(); 7360 if (!(this.fixed instanceof Money)) 7361 throw new FHIRException("Type mismatch: the type Money was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7362 return (Money) this.fixed; 7363 } 7364 7365 public boolean hasFixedMoney() { 7366 return this != null && this.fixed instanceof Money; 7367 } 7368 7369 /** 7370 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7371 */ 7372 public Period getFixedPeriod() throws FHIRException { 7373 if (this.fixed == null) 7374 this.fixed = new Period(); 7375 if (!(this.fixed instanceof Period)) 7376 throw new FHIRException("Type mismatch: the type Period was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7377 return (Period) this.fixed; 7378 } 7379 7380 public boolean hasFixedPeriod() { 7381 return this != null && this.fixed instanceof Period; 7382 } 7383 7384 /** 7385 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7386 */ 7387 public Quantity getFixedQuantity() throws FHIRException { 7388 if (this.fixed == null) 7389 this.fixed = new Quantity(); 7390 if (!(this.fixed instanceof Quantity)) 7391 throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7392 return (Quantity) this.fixed; 7393 } 7394 7395 public boolean hasFixedQuantity() { 7396 return this != null && this.fixed instanceof Quantity; 7397 } 7398 7399 /** 7400 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7401 */ 7402 public Range getFixedRange() throws FHIRException { 7403 if (this.fixed == null) 7404 this.fixed = new Range(); 7405 if (!(this.fixed instanceof Range)) 7406 throw new FHIRException("Type mismatch: the type Range was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7407 return (Range) this.fixed; 7408 } 7409 7410 public boolean hasFixedRange() { 7411 return this != null && this.fixed instanceof Range; 7412 } 7413 7414 /** 7415 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7416 */ 7417 public Ratio getFixedRatio() throws FHIRException { 7418 if (this.fixed == null) 7419 this.fixed = new Ratio(); 7420 if (!(this.fixed instanceof Ratio)) 7421 throw new FHIRException("Type mismatch: the type Ratio was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7422 return (Ratio) this.fixed; 7423 } 7424 7425 public boolean hasFixedRatio() { 7426 return this != null && this.fixed instanceof Ratio; 7427 } 7428 7429 /** 7430 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7431 */ 7432 public Reference getFixedReference() throws FHIRException { 7433 if (this.fixed == null) 7434 this.fixed = new Reference(); 7435 if (!(this.fixed instanceof Reference)) 7436 throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7437 return (Reference) this.fixed; 7438 } 7439 7440 public boolean hasFixedReference() { 7441 return this != null && this.fixed instanceof Reference; 7442 } 7443 7444 /** 7445 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7446 */ 7447 public SampledData getFixedSampledData() throws FHIRException { 7448 if (this.fixed == null) 7449 this.fixed = new SampledData(); 7450 if (!(this.fixed instanceof SampledData)) 7451 throw new FHIRException("Type mismatch: the type SampledData was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7452 return (SampledData) this.fixed; 7453 } 7454 7455 public boolean hasFixedSampledData() { 7456 return this != null && this.fixed instanceof SampledData; 7457 } 7458 7459 /** 7460 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7461 */ 7462 public Signature getFixedSignature() throws FHIRException { 7463 if (this.fixed == null) 7464 this.fixed = new Signature(); 7465 if (!(this.fixed instanceof Signature)) 7466 throw new FHIRException("Type mismatch: the type Signature was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7467 return (Signature) this.fixed; 7468 } 7469 7470 public boolean hasFixedSignature() { 7471 return this != null && this.fixed instanceof Signature; 7472 } 7473 7474 /** 7475 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7476 */ 7477 public Timing getFixedTiming() throws FHIRException { 7478 if (this.fixed == null) 7479 this.fixed = new Timing(); 7480 if (!(this.fixed instanceof Timing)) 7481 throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7482 return (Timing) this.fixed; 7483 } 7484 7485 public boolean hasFixedTiming() { 7486 return this != null && this.fixed instanceof Timing; 7487 } 7488 7489 /** 7490 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7491 */ 7492 public ContactDetail getFixedContactDetail() throws FHIRException { 7493 if (this.fixed == null) 7494 this.fixed = new ContactDetail(); 7495 if (!(this.fixed instanceof ContactDetail)) 7496 throw new FHIRException("Type mismatch: the type ContactDetail was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7497 return (ContactDetail) this.fixed; 7498 } 7499 7500 public boolean hasFixedContactDetail() { 7501 return this != null && this.fixed instanceof ContactDetail; 7502 } 7503 7504 /** 7505 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7506 */ 7507 public Contributor getFixedContributor() throws FHIRException { 7508 if (this.fixed == null) 7509 this.fixed = new Contributor(); 7510 if (!(this.fixed instanceof Contributor)) 7511 throw new FHIRException("Type mismatch: the type Contributor was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7512 return (Contributor) this.fixed; 7513 } 7514 7515 public boolean hasFixedContributor() { 7516 return this != null && this.fixed instanceof Contributor; 7517 } 7518 7519 /** 7520 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7521 */ 7522 public DataRequirement getFixedDataRequirement() throws FHIRException { 7523 if (this.fixed == null) 7524 this.fixed = new DataRequirement(); 7525 if (!(this.fixed instanceof DataRequirement)) 7526 throw new FHIRException("Type mismatch: the type DataRequirement was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7527 return (DataRequirement) this.fixed; 7528 } 7529 7530 public boolean hasFixedDataRequirement() { 7531 return this != null && this.fixed instanceof DataRequirement; 7532 } 7533 7534 /** 7535 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7536 */ 7537 public Expression getFixedExpression() throws FHIRException { 7538 if (this.fixed == null) 7539 this.fixed = new Expression(); 7540 if (!(this.fixed instanceof Expression)) 7541 throw new FHIRException("Type mismatch: the type Expression was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7542 return (Expression) this.fixed; 7543 } 7544 7545 public boolean hasFixedExpression() { 7546 return this != null && this.fixed instanceof Expression; 7547 } 7548 7549 /** 7550 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7551 */ 7552 public ParameterDefinition getFixedParameterDefinition() throws FHIRException { 7553 if (this.fixed == null) 7554 this.fixed = new ParameterDefinition(); 7555 if (!(this.fixed instanceof ParameterDefinition)) 7556 throw new FHIRException("Type mismatch: the type ParameterDefinition was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7557 return (ParameterDefinition) this.fixed; 7558 } 7559 7560 public boolean hasFixedParameterDefinition() { 7561 return this != null && this.fixed instanceof ParameterDefinition; 7562 } 7563 7564 /** 7565 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7566 */ 7567 public RelatedArtifact getFixedRelatedArtifact() throws FHIRException { 7568 if (this.fixed == null) 7569 this.fixed = new RelatedArtifact(); 7570 if (!(this.fixed instanceof RelatedArtifact)) 7571 throw new FHIRException("Type mismatch: the type RelatedArtifact was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7572 return (RelatedArtifact) this.fixed; 7573 } 7574 7575 public boolean hasFixedRelatedArtifact() { 7576 return this != null && this.fixed instanceof RelatedArtifact; 7577 } 7578 7579 /** 7580 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7581 */ 7582 public TriggerDefinition getFixedTriggerDefinition() throws FHIRException { 7583 if (this.fixed == null) 7584 this.fixed = new TriggerDefinition(); 7585 if (!(this.fixed instanceof TriggerDefinition)) 7586 throw new FHIRException("Type mismatch: the type TriggerDefinition was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7587 return (TriggerDefinition) this.fixed; 7588 } 7589 7590 public boolean hasFixedTriggerDefinition() { 7591 return this != null && this.fixed instanceof TriggerDefinition; 7592 } 7593 7594 /** 7595 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7596 */ 7597 public UsageContext getFixedUsageContext() throws FHIRException { 7598 if (this.fixed == null) 7599 this.fixed = new UsageContext(); 7600 if (!(this.fixed instanceof UsageContext)) 7601 throw new FHIRException("Type mismatch: the type UsageContext was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7602 return (UsageContext) this.fixed; 7603 } 7604 7605 public boolean hasFixedUsageContext() { 7606 return this != null && this.fixed instanceof UsageContext; 7607 } 7608 7609 /** 7610 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7611 */ 7612 public Dosage getFixedDosage() throws FHIRException { 7613 if (this.fixed == null) 7614 this.fixed = new Dosage(); 7615 if (!(this.fixed instanceof Dosage)) 7616 throw new FHIRException("Type mismatch: the type Dosage was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7617 return (Dosage) this.fixed; 7618 } 7619 7620 public boolean hasFixedDosage() { 7621 return this != null && this.fixed instanceof Dosage; 7622 } 7623 7624 /** 7625 * @return {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7626 */ 7627 public Meta getFixedMeta() throws FHIRException { 7628 if (this.fixed == null) 7629 this.fixed = new Meta(); 7630 if (!(this.fixed instanceof Meta)) 7631 throw new FHIRException("Type mismatch: the type Meta was expected, but "+this.fixed.getClass().getName()+" was encountered"); 7632 return (Meta) this.fixed; 7633 } 7634 7635 public boolean hasFixedMeta() { 7636 return this != null && this.fixed instanceof Meta; 7637 } 7638 7639 public boolean hasFixed() { 7640 return this.fixed != null && !this.fixed.isEmpty(); 7641 } 7642 7643 /** 7644 * @param value {@link #fixed} (Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.) 7645 */ 7646 public ElementDefinition setFixed(DataType value) { 7647 if (value != null && !(value instanceof Base64BinaryType || value instanceof BooleanType || value instanceof CanonicalType || value instanceof CodeType || value instanceof DateType || value instanceof DateTimeType || value instanceof DecimalType || value instanceof IdType || value instanceof InstantType || value instanceof IntegerType || value instanceof Integer64Type || value instanceof MarkdownType || value instanceof OidType || value instanceof PositiveIntType || value instanceof StringType || value instanceof TimeType || value instanceof UnsignedIntType || value instanceof UriType || value instanceof UrlType || value instanceof UuidType || value instanceof Address || value instanceof Age || value instanceof Annotation || value instanceof Attachment || value instanceof CodeableConcept || value instanceof Coding || value instanceof ContactPoint || value instanceof Count || value instanceof Distance || value instanceof Duration || value instanceof HumanName || value instanceof Identifier || value instanceof Money || value instanceof Period || value instanceof Quantity || value instanceof Range || value instanceof Ratio || value instanceof Reference || value instanceof SampledData || value instanceof Signature || value instanceof Timing || value instanceof ContactDetail || value instanceof Contributor || value instanceof DataRequirement || value instanceof Expression || value instanceof ParameterDefinition || value instanceof RelatedArtifact || value instanceof TriggerDefinition || value instanceof UsageContext || value instanceof Dosage || value instanceof Meta)) 7648 throw new Error("Not the right type for ElementDefinition.fixed[x]: "+value.fhirType()); 7649 this.fixed = value; 7650 return this; 7651 } 7652 7653 /** 7654 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7655 7656When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7657 7658When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7659 7660When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7661 76621. If primitive: it must match exactly the pattern value 76632. If a complex object: it must match (recursively) the pattern value 76643. If an array: it must match (recursively) the pattern value.) 7665 */ 7666 public DataType getPattern() { 7667 return this.pattern; 7668 } 7669 7670 /** 7671 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7672 7673When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7674 7675When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7676 7677When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7678 76791. If primitive: it must match exactly the pattern value 76802. If a complex object: it must match (recursively) the pattern value 76813. If an array: it must match (recursively) the pattern value.) 7682 */ 7683 public Base64BinaryType getPatternBase64BinaryType() throws FHIRException { 7684 if (this.pattern == null) 7685 this.pattern = new Base64BinaryType(); 7686 if (!(this.pattern instanceof Base64BinaryType)) 7687 throw new FHIRException("Type mismatch: the type Base64BinaryType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7688 return (Base64BinaryType) this.pattern; 7689 } 7690 7691 public boolean hasPatternBase64BinaryType() { 7692 return this != null && this.pattern instanceof Base64BinaryType; 7693 } 7694 7695 /** 7696 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7697 7698When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7699 7700When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7701 7702When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7703 77041. If primitive: it must match exactly the pattern value 77052. If a complex object: it must match (recursively) the pattern value 77063. If an array: it must match (recursively) the pattern value.) 7707 */ 7708 public BooleanType getPatternBooleanType() throws FHIRException { 7709 if (this.pattern == null) 7710 this.pattern = new BooleanType(); 7711 if (!(this.pattern instanceof BooleanType)) 7712 throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7713 return (BooleanType) this.pattern; 7714 } 7715 7716 public boolean hasPatternBooleanType() { 7717 return this != null && this.pattern instanceof BooleanType; 7718 } 7719 7720 /** 7721 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7722 7723When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7724 7725When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7726 7727When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7728 77291. If primitive: it must match exactly the pattern value 77302. If a complex object: it must match (recursively) the pattern value 77313. If an array: it must match (recursively) the pattern value.) 7732 */ 7733 public CanonicalType getPatternCanonicalType() throws FHIRException { 7734 if (this.pattern == null) 7735 this.pattern = new CanonicalType(); 7736 if (!(this.pattern instanceof CanonicalType)) 7737 throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7738 return (CanonicalType) this.pattern; 7739 } 7740 7741 public boolean hasPatternCanonicalType() { 7742 return this != null && this.pattern instanceof CanonicalType; 7743 } 7744 7745 /** 7746 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7747 7748When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7749 7750When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7751 7752When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7753 77541. If primitive: it must match exactly the pattern value 77552. If a complex object: it must match (recursively) the pattern value 77563. If an array: it must match (recursively) the pattern value.) 7757 */ 7758 public CodeType getPatternCodeType() throws FHIRException { 7759 if (this.pattern == null) 7760 this.pattern = new CodeType(); 7761 if (!(this.pattern instanceof CodeType)) 7762 throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7763 return (CodeType) this.pattern; 7764 } 7765 7766 public boolean hasPatternCodeType() { 7767 return this != null && this.pattern instanceof CodeType; 7768 } 7769 7770 /** 7771 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7772 7773When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7774 7775When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7776 7777When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7778 77791. If primitive: it must match exactly the pattern value 77802. If a complex object: it must match (recursively) the pattern value 77813. If an array: it must match (recursively) the pattern value.) 7782 */ 7783 public DateType getPatternDateType() throws FHIRException { 7784 if (this.pattern == null) 7785 this.pattern = new DateType(); 7786 if (!(this.pattern instanceof DateType)) 7787 throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7788 return (DateType) this.pattern; 7789 } 7790 7791 public boolean hasPatternDateType() { 7792 return this != null && this.pattern instanceof DateType; 7793 } 7794 7795 /** 7796 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7797 7798When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7799 7800When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7801 7802When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7803 78041. If primitive: it must match exactly the pattern value 78052. If a complex object: it must match (recursively) the pattern value 78063. If an array: it must match (recursively) the pattern value.) 7807 */ 7808 public DateTimeType getPatternDateTimeType() throws FHIRException { 7809 if (this.pattern == null) 7810 this.pattern = new DateTimeType(); 7811 if (!(this.pattern instanceof DateTimeType)) 7812 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7813 return (DateTimeType) this.pattern; 7814 } 7815 7816 public boolean hasPatternDateTimeType() { 7817 return this != null && this.pattern instanceof DateTimeType; 7818 } 7819 7820 /** 7821 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7822 7823When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7824 7825When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7826 7827When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7828 78291. If primitive: it must match exactly the pattern value 78302. If a complex object: it must match (recursively) the pattern value 78313. If an array: it must match (recursively) the pattern value.) 7832 */ 7833 public DecimalType getPatternDecimalType() throws FHIRException { 7834 if (this.pattern == null) 7835 this.pattern = new DecimalType(); 7836 if (!(this.pattern instanceof DecimalType)) 7837 throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7838 return (DecimalType) this.pattern; 7839 } 7840 7841 public boolean hasPatternDecimalType() { 7842 return this != null && this.pattern instanceof DecimalType; 7843 } 7844 7845 /** 7846 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7847 7848When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7849 7850When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7851 7852When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7853 78541. If primitive: it must match exactly the pattern value 78552. If a complex object: it must match (recursively) the pattern value 78563. If an array: it must match (recursively) the pattern value.) 7857 */ 7858 public IdType getPatternIdType() throws FHIRException { 7859 if (this.pattern == null) 7860 this.pattern = new IdType(); 7861 if (!(this.pattern instanceof IdType)) 7862 throw new FHIRException("Type mismatch: the type IdType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7863 return (IdType) this.pattern; 7864 } 7865 7866 public boolean hasPatternIdType() { 7867 return this != null && this.pattern instanceof IdType; 7868 } 7869 7870 /** 7871 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7872 7873When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7874 7875When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7876 7877When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7878 78791. If primitive: it must match exactly the pattern value 78802. If a complex object: it must match (recursively) the pattern value 78813. If an array: it must match (recursively) the pattern value.) 7882 */ 7883 public InstantType getPatternInstantType() throws FHIRException { 7884 if (this.pattern == null) 7885 this.pattern = new InstantType(); 7886 if (!(this.pattern instanceof InstantType)) 7887 throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7888 return (InstantType) this.pattern; 7889 } 7890 7891 public boolean hasPatternInstantType() { 7892 return this != null && this.pattern instanceof InstantType; 7893 } 7894 7895 /** 7896 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7897 7898When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7899 7900When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7901 7902When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7903 79041. If primitive: it must match exactly the pattern value 79052. If a complex object: it must match (recursively) the pattern value 79063. If an array: it must match (recursively) the pattern value.) 7907 */ 7908 public IntegerType getPatternIntegerType() throws FHIRException { 7909 if (this.pattern == null) 7910 this.pattern = new IntegerType(); 7911 if (!(this.pattern instanceof IntegerType)) 7912 throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7913 return (IntegerType) this.pattern; 7914 } 7915 7916 public boolean hasPatternIntegerType() { 7917 return this != null && this.pattern instanceof IntegerType; 7918 } 7919 7920 /** 7921 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7922 7923When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7924 7925When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7926 7927When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7928 79291. If primitive: it must match exactly the pattern value 79302. If a complex object: it must match (recursively) the pattern value 79313. If an array: it must match (recursively) the pattern value.) 7932 */ 7933 public Integer64Type getPatternInteger64Type() throws FHIRException { 7934 if (this.pattern == null) 7935 this.pattern = new Integer64Type(); 7936 if (!(this.pattern instanceof Integer64Type)) 7937 throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7938 return (Integer64Type) this.pattern; 7939 } 7940 7941 public boolean hasPatternInteger64Type() { 7942 return this != null && this.pattern instanceof Integer64Type; 7943 } 7944 7945 /** 7946 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7947 7948When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7949 7950When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7951 7952When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7953 79541. If primitive: it must match exactly the pattern value 79552. If a complex object: it must match (recursively) the pattern value 79563. If an array: it must match (recursively) the pattern value.) 7957 */ 7958 public MarkdownType getPatternMarkdownType() throws FHIRException { 7959 if (this.pattern == null) 7960 this.pattern = new MarkdownType(); 7961 if (!(this.pattern instanceof MarkdownType)) 7962 throw new FHIRException("Type mismatch: the type MarkdownType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7963 return (MarkdownType) this.pattern; 7964 } 7965 7966 public boolean hasPatternMarkdownType() { 7967 return this != null && this.pattern instanceof MarkdownType; 7968 } 7969 7970 /** 7971 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7972 7973When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7974 7975When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 7976 7977When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 7978 79791. If primitive: it must match exactly the pattern value 79802. If a complex object: it must match (recursively) the pattern value 79813. If an array: it must match (recursively) the pattern value.) 7982 */ 7983 public OidType getPatternOidType() throws FHIRException { 7984 if (this.pattern == null) 7985 this.pattern = new OidType(); 7986 if (!(this.pattern instanceof OidType)) 7987 throw new FHIRException("Type mismatch: the type OidType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 7988 return (OidType) this.pattern; 7989 } 7990 7991 public boolean hasPatternOidType() { 7992 return this != null && this.pattern instanceof OidType; 7993 } 7994 7995 /** 7996 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 7997 7998When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 7999 8000When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8001 8002When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8003 80041. If primitive: it must match exactly the pattern value 80052. If a complex object: it must match (recursively) the pattern value 80063. If an array: it must match (recursively) the pattern value.) 8007 */ 8008 public PositiveIntType getPatternPositiveIntType() throws FHIRException { 8009 if (this.pattern == null) 8010 this.pattern = new PositiveIntType(); 8011 if (!(this.pattern instanceof PositiveIntType)) 8012 throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8013 return (PositiveIntType) this.pattern; 8014 } 8015 8016 public boolean hasPatternPositiveIntType() { 8017 return this != null && this.pattern instanceof PositiveIntType; 8018 } 8019 8020 /** 8021 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8022 8023When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8024 8025When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8026 8027When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8028 80291. If primitive: it must match exactly the pattern value 80302. If a complex object: it must match (recursively) the pattern value 80313. If an array: it must match (recursively) the pattern value.) 8032 */ 8033 public StringType getPatternStringType() throws FHIRException { 8034 if (this.pattern == null) 8035 this.pattern = new StringType(); 8036 if (!(this.pattern instanceof StringType)) 8037 throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8038 return (StringType) this.pattern; 8039 } 8040 8041 public boolean hasPatternStringType() { 8042 return this != null && this.pattern instanceof StringType; 8043 } 8044 8045 /** 8046 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8047 8048When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8049 8050When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8051 8052When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8053 80541. If primitive: it must match exactly the pattern value 80552. If a complex object: it must match (recursively) the pattern value 80563. If an array: it must match (recursively) the pattern value.) 8057 */ 8058 public TimeType getPatternTimeType() throws FHIRException { 8059 if (this.pattern == null) 8060 this.pattern = new TimeType(); 8061 if (!(this.pattern instanceof TimeType)) 8062 throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8063 return (TimeType) this.pattern; 8064 } 8065 8066 public boolean hasPatternTimeType() { 8067 return this != null && this.pattern instanceof TimeType; 8068 } 8069 8070 /** 8071 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8072 8073When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8074 8075When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8076 8077When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8078 80791. If primitive: it must match exactly the pattern value 80802. If a complex object: it must match (recursively) the pattern value 80813. If an array: it must match (recursively) the pattern value.) 8082 */ 8083 public UnsignedIntType getPatternUnsignedIntType() throws FHIRException { 8084 if (this.pattern == null) 8085 this.pattern = new UnsignedIntType(); 8086 if (!(this.pattern instanceof UnsignedIntType)) 8087 throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8088 return (UnsignedIntType) this.pattern; 8089 } 8090 8091 public boolean hasPatternUnsignedIntType() { 8092 return this != null && this.pattern instanceof UnsignedIntType; 8093 } 8094 8095 /** 8096 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8097 8098When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8099 8100When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8101 8102When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8103 81041. If primitive: it must match exactly the pattern value 81052. If a complex object: it must match (recursively) the pattern value 81063. If an array: it must match (recursively) the pattern value.) 8107 */ 8108 public UriType getPatternUriType() throws FHIRException { 8109 if (this.pattern == null) 8110 this.pattern = new UriType(); 8111 if (!(this.pattern instanceof UriType)) 8112 throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8113 return (UriType) this.pattern; 8114 } 8115 8116 public boolean hasPatternUriType() { 8117 return this != null && this.pattern instanceof UriType; 8118 } 8119 8120 /** 8121 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8122 8123When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8124 8125When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8126 8127When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8128 81291. If primitive: it must match exactly the pattern value 81302. If a complex object: it must match (recursively) the pattern value 81313. If an array: it must match (recursively) the pattern value.) 8132 */ 8133 public UrlType getPatternUrlType() throws FHIRException { 8134 if (this.pattern == null) 8135 this.pattern = new UrlType(); 8136 if (!(this.pattern instanceof UrlType)) 8137 throw new FHIRException("Type mismatch: the type UrlType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8138 return (UrlType) this.pattern; 8139 } 8140 8141 public boolean hasPatternUrlType() { 8142 return this != null && this.pattern instanceof UrlType; 8143 } 8144 8145 /** 8146 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8147 8148When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8149 8150When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8151 8152When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8153 81541. If primitive: it must match exactly the pattern value 81552. If a complex object: it must match (recursively) the pattern value 81563. If an array: it must match (recursively) the pattern value.) 8157 */ 8158 public UuidType getPatternUuidType() throws FHIRException { 8159 if (this.pattern == null) 8160 this.pattern = new UuidType(); 8161 if (!(this.pattern instanceof UuidType)) 8162 throw new FHIRException("Type mismatch: the type UuidType was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8163 return (UuidType) this.pattern; 8164 } 8165 8166 public boolean hasPatternUuidType() { 8167 return this != null && this.pattern instanceof UuidType; 8168 } 8169 8170 /** 8171 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8172 8173When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8174 8175When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8176 8177When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8178 81791. If primitive: it must match exactly the pattern value 81802. If a complex object: it must match (recursively) the pattern value 81813. If an array: it must match (recursively) the pattern value.) 8182 */ 8183 public Address getPatternAddress() throws FHIRException { 8184 if (this.pattern == null) 8185 this.pattern = new Address(); 8186 if (!(this.pattern instanceof Address)) 8187 throw new FHIRException("Type mismatch: the type Address was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8188 return (Address) this.pattern; 8189 } 8190 8191 public boolean hasPatternAddress() { 8192 return this != null && this.pattern instanceof Address; 8193 } 8194 8195 /** 8196 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8197 8198When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8199 8200When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8201 8202When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8203 82041. If primitive: it must match exactly the pattern value 82052. If a complex object: it must match (recursively) the pattern value 82063. If an array: it must match (recursively) the pattern value.) 8207 */ 8208 public Age getPatternAge() throws FHIRException { 8209 if (this.pattern == null) 8210 this.pattern = new Age(); 8211 if (!(this.pattern instanceof Age)) 8212 throw new FHIRException("Type mismatch: the type Age was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8213 return (Age) this.pattern; 8214 } 8215 8216 public boolean hasPatternAge() { 8217 return this != null && this.pattern instanceof Age; 8218 } 8219 8220 /** 8221 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8222 8223When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8224 8225When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8226 8227When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8228 82291. If primitive: it must match exactly the pattern value 82302. If a complex object: it must match (recursively) the pattern value 82313. If an array: it must match (recursively) the pattern value.) 8232 */ 8233 public Annotation getPatternAnnotation() throws FHIRException { 8234 if (this.pattern == null) 8235 this.pattern = new Annotation(); 8236 if (!(this.pattern instanceof Annotation)) 8237 throw new FHIRException("Type mismatch: the type Annotation was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8238 return (Annotation) this.pattern; 8239 } 8240 8241 public boolean hasPatternAnnotation() { 8242 return this != null && this.pattern instanceof Annotation; 8243 } 8244 8245 /** 8246 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8247 8248When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8249 8250When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8251 8252When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8253 82541. If primitive: it must match exactly the pattern value 82552. If a complex object: it must match (recursively) the pattern value 82563. If an array: it must match (recursively) the pattern value.) 8257 */ 8258 public Attachment getPatternAttachment() throws FHIRException { 8259 if (this.pattern == null) 8260 this.pattern = new Attachment(); 8261 if (!(this.pattern instanceof Attachment)) 8262 throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8263 return (Attachment) this.pattern; 8264 } 8265 8266 public boolean hasPatternAttachment() { 8267 return this != null && this.pattern instanceof Attachment; 8268 } 8269 8270 /** 8271 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8272 8273When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8274 8275When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8276 8277When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8278 82791. If primitive: it must match exactly the pattern value 82802. If a complex object: it must match (recursively) the pattern value 82813. If an array: it must match (recursively) the pattern value.) 8282 */ 8283 public CodeableConcept getPatternCodeableConcept() throws FHIRException { 8284 if (this.pattern == null) 8285 this.pattern = new CodeableConcept(); 8286 if (!(this.pattern instanceof CodeableConcept)) 8287 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8288 return (CodeableConcept) this.pattern; 8289 } 8290 8291 public boolean hasPatternCodeableConcept() { 8292 return this != null && this.pattern instanceof CodeableConcept; 8293 } 8294 8295 /** 8296 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8297 8298When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8299 8300When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8301 8302When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8303 83041. If primitive: it must match exactly the pattern value 83052. If a complex object: it must match (recursively) the pattern value 83063. If an array: it must match (recursively) the pattern value.) 8307 */ 8308 public Coding getPatternCoding() throws FHIRException { 8309 if (this.pattern == null) 8310 this.pattern = new Coding(); 8311 if (!(this.pattern instanceof Coding)) 8312 throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8313 return (Coding) this.pattern; 8314 } 8315 8316 public boolean hasPatternCoding() { 8317 return this != null && this.pattern instanceof Coding; 8318 } 8319 8320 /** 8321 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8322 8323When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8324 8325When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8326 8327When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8328 83291. If primitive: it must match exactly the pattern value 83302. If a complex object: it must match (recursively) the pattern value 83313. If an array: it must match (recursively) the pattern value.) 8332 */ 8333 public ContactPoint getPatternContactPoint() throws FHIRException { 8334 if (this.pattern == null) 8335 this.pattern = new ContactPoint(); 8336 if (!(this.pattern instanceof ContactPoint)) 8337 throw new FHIRException("Type mismatch: the type ContactPoint was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8338 return (ContactPoint) this.pattern; 8339 } 8340 8341 public boolean hasPatternContactPoint() { 8342 return this != null && this.pattern instanceof ContactPoint; 8343 } 8344 8345 /** 8346 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8347 8348When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8349 8350When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8351 8352When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8353 83541. If primitive: it must match exactly the pattern value 83552. If a complex object: it must match (recursively) the pattern value 83563. If an array: it must match (recursively) the pattern value.) 8357 */ 8358 public Count getPatternCount() throws FHIRException { 8359 if (this.pattern == null) 8360 this.pattern = new Count(); 8361 if (!(this.pattern instanceof Count)) 8362 throw new FHIRException("Type mismatch: the type Count was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8363 return (Count) this.pattern; 8364 } 8365 8366 public boolean hasPatternCount() { 8367 return this != null && this.pattern instanceof Count; 8368 } 8369 8370 /** 8371 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8372 8373When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8374 8375When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8376 8377When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8378 83791. If primitive: it must match exactly the pattern value 83802. If a complex object: it must match (recursively) the pattern value 83813. If an array: it must match (recursively) the pattern value.) 8382 */ 8383 public Distance getPatternDistance() throws FHIRException { 8384 if (this.pattern == null) 8385 this.pattern = new Distance(); 8386 if (!(this.pattern instanceof Distance)) 8387 throw new FHIRException("Type mismatch: the type Distance was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8388 return (Distance) this.pattern; 8389 } 8390 8391 public boolean hasPatternDistance() { 8392 return this != null && this.pattern instanceof Distance; 8393 } 8394 8395 /** 8396 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8397 8398When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8399 8400When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8401 8402When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8403 84041. If primitive: it must match exactly the pattern value 84052. If a complex object: it must match (recursively) the pattern value 84063. If an array: it must match (recursively) the pattern value.) 8407 */ 8408 public Duration getPatternDuration() throws FHIRException { 8409 if (this.pattern == null) 8410 this.pattern = new Duration(); 8411 if (!(this.pattern instanceof Duration)) 8412 throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8413 return (Duration) this.pattern; 8414 } 8415 8416 public boolean hasPatternDuration() { 8417 return this != null && this.pattern instanceof Duration; 8418 } 8419 8420 /** 8421 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8422 8423When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8424 8425When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8426 8427When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8428 84291. If primitive: it must match exactly the pattern value 84302. If a complex object: it must match (recursively) the pattern value 84313. If an array: it must match (recursively) the pattern value.) 8432 */ 8433 public HumanName getPatternHumanName() throws FHIRException { 8434 if (this.pattern == null) 8435 this.pattern = new HumanName(); 8436 if (!(this.pattern instanceof HumanName)) 8437 throw new FHIRException("Type mismatch: the type HumanName was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8438 return (HumanName) this.pattern; 8439 } 8440 8441 public boolean hasPatternHumanName() { 8442 return this != null && this.pattern instanceof HumanName; 8443 } 8444 8445 /** 8446 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8447 8448When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8449 8450When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8451 8452When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8453 84541. If primitive: it must match exactly the pattern value 84552. If a complex object: it must match (recursively) the pattern value 84563. If an array: it must match (recursively) the pattern value.) 8457 */ 8458 public Identifier getPatternIdentifier() throws FHIRException { 8459 if (this.pattern == null) 8460 this.pattern = new Identifier(); 8461 if (!(this.pattern instanceof Identifier)) 8462 throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8463 return (Identifier) this.pattern; 8464 } 8465 8466 public boolean hasPatternIdentifier() { 8467 return this != null && this.pattern instanceof Identifier; 8468 } 8469 8470 /** 8471 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8472 8473When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8474 8475When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8476 8477When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8478 84791. If primitive: it must match exactly the pattern value 84802. If a complex object: it must match (recursively) the pattern value 84813. If an array: it must match (recursively) the pattern value.) 8482 */ 8483 public Money getPatternMoney() throws FHIRException { 8484 if (this.pattern == null) 8485 this.pattern = new Money(); 8486 if (!(this.pattern instanceof Money)) 8487 throw new FHIRException("Type mismatch: the type Money was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8488 return (Money) this.pattern; 8489 } 8490 8491 public boolean hasPatternMoney() { 8492 return this != null && this.pattern instanceof Money; 8493 } 8494 8495 /** 8496 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8497 8498When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8499 8500When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8501 8502When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8503 85041. If primitive: it must match exactly the pattern value 85052. If a complex object: it must match (recursively) the pattern value 85063. If an array: it must match (recursively) the pattern value.) 8507 */ 8508 public Period getPatternPeriod() throws FHIRException { 8509 if (this.pattern == null) 8510 this.pattern = new Period(); 8511 if (!(this.pattern instanceof Period)) 8512 throw new FHIRException("Type mismatch: the type Period was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8513 return (Period) this.pattern; 8514 } 8515 8516 public boolean hasPatternPeriod() { 8517 return this != null && this.pattern instanceof Period; 8518 } 8519 8520 /** 8521 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8522 8523When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8524 8525When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8526 8527When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8528 85291. If primitive: it must match exactly the pattern value 85302. If a complex object: it must match (recursively) the pattern value 85313. If an array: it must match (recursively) the pattern value.) 8532 */ 8533 public Quantity getPatternQuantity() throws FHIRException { 8534 if (this.pattern == null) 8535 this.pattern = new Quantity(); 8536 if (!(this.pattern instanceof Quantity)) 8537 throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8538 return (Quantity) this.pattern; 8539 } 8540 8541 public boolean hasPatternQuantity() { 8542 return this != null && this.pattern instanceof Quantity; 8543 } 8544 8545 /** 8546 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8547 8548When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8549 8550When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8551 8552When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8553 85541. If primitive: it must match exactly the pattern value 85552. If a complex object: it must match (recursively) the pattern value 85563. If an array: it must match (recursively) the pattern value.) 8557 */ 8558 public Range getPatternRange() throws FHIRException { 8559 if (this.pattern == null) 8560 this.pattern = new Range(); 8561 if (!(this.pattern instanceof Range)) 8562 throw new FHIRException("Type mismatch: the type Range was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8563 return (Range) this.pattern; 8564 } 8565 8566 public boolean hasPatternRange() { 8567 return this != null && this.pattern instanceof Range; 8568 } 8569 8570 /** 8571 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8572 8573When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8574 8575When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8576 8577When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8578 85791. If primitive: it must match exactly the pattern value 85802. If a complex object: it must match (recursively) the pattern value 85813. If an array: it must match (recursively) the pattern value.) 8582 */ 8583 public Ratio getPatternRatio() throws FHIRException { 8584 if (this.pattern == null) 8585 this.pattern = new Ratio(); 8586 if (!(this.pattern instanceof Ratio)) 8587 throw new FHIRException("Type mismatch: the type Ratio was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8588 return (Ratio) this.pattern; 8589 } 8590 8591 public boolean hasPatternRatio() { 8592 return this != null && this.pattern instanceof Ratio; 8593 } 8594 8595 /** 8596 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8597 8598When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8599 8600When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8601 8602When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8603 86041. If primitive: it must match exactly the pattern value 86052. If a complex object: it must match (recursively) the pattern value 86063. If an array: it must match (recursively) the pattern value.) 8607 */ 8608 public Reference getPatternReference() throws FHIRException { 8609 if (this.pattern == null) 8610 this.pattern = new Reference(); 8611 if (!(this.pattern instanceof Reference)) 8612 throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8613 return (Reference) this.pattern; 8614 } 8615 8616 public boolean hasPatternReference() { 8617 return this != null && this.pattern instanceof Reference; 8618 } 8619 8620 /** 8621 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8622 8623When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8624 8625When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8626 8627When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8628 86291. If primitive: it must match exactly the pattern value 86302. If a complex object: it must match (recursively) the pattern value 86313. If an array: it must match (recursively) the pattern value.) 8632 */ 8633 public SampledData getPatternSampledData() throws FHIRException { 8634 if (this.pattern == null) 8635 this.pattern = new SampledData(); 8636 if (!(this.pattern instanceof SampledData)) 8637 throw new FHIRException("Type mismatch: the type SampledData was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8638 return (SampledData) this.pattern; 8639 } 8640 8641 public boolean hasPatternSampledData() { 8642 return this != null && this.pattern instanceof SampledData; 8643 } 8644 8645 /** 8646 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8647 8648When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8649 8650When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8651 8652When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8653 86541. If primitive: it must match exactly the pattern value 86552. If a complex object: it must match (recursively) the pattern value 86563. If an array: it must match (recursively) the pattern value.) 8657 */ 8658 public Signature getPatternSignature() throws FHIRException { 8659 if (this.pattern == null) 8660 this.pattern = new Signature(); 8661 if (!(this.pattern instanceof Signature)) 8662 throw new FHIRException("Type mismatch: the type Signature was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8663 return (Signature) this.pattern; 8664 } 8665 8666 public boolean hasPatternSignature() { 8667 return this != null && this.pattern instanceof Signature; 8668 } 8669 8670 /** 8671 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8672 8673When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8674 8675When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8676 8677When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8678 86791. If primitive: it must match exactly the pattern value 86802. If a complex object: it must match (recursively) the pattern value 86813. If an array: it must match (recursively) the pattern value.) 8682 */ 8683 public Timing getPatternTiming() throws FHIRException { 8684 if (this.pattern == null) 8685 this.pattern = new Timing(); 8686 if (!(this.pattern instanceof Timing)) 8687 throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8688 return (Timing) this.pattern; 8689 } 8690 8691 public boolean hasPatternTiming() { 8692 return this != null && this.pattern instanceof Timing; 8693 } 8694 8695 /** 8696 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8697 8698When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8699 8700When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8701 8702When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8703 87041. If primitive: it must match exactly the pattern value 87052. If a complex object: it must match (recursively) the pattern value 87063. If an array: it must match (recursively) the pattern value.) 8707 */ 8708 public ContactDetail getPatternContactDetail() throws FHIRException { 8709 if (this.pattern == null) 8710 this.pattern = new ContactDetail(); 8711 if (!(this.pattern instanceof ContactDetail)) 8712 throw new FHIRException("Type mismatch: the type ContactDetail was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8713 return (ContactDetail) this.pattern; 8714 } 8715 8716 public boolean hasPatternContactDetail() { 8717 return this != null && this.pattern instanceof ContactDetail; 8718 } 8719 8720 /** 8721 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8722 8723When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8724 8725When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8726 8727When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8728 87291. If primitive: it must match exactly the pattern value 87302. If a complex object: it must match (recursively) the pattern value 87313. If an array: it must match (recursively) the pattern value.) 8732 */ 8733 public Contributor getPatternContributor() throws FHIRException { 8734 if (this.pattern == null) 8735 this.pattern = new Contributor(); 8736 if (!(this.pattern instanceof Contributor)) 8737 throw new FHIRException("Type mismatch: the type Contributor was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8738 return (Contributor) this.pattern; 8739 } 8740 8741 public boolean hasPatternContributor() { 8742 return this != null && this.pattern instanceof Contributor; 8743 } 8744 8745 /** 8746 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8747 8748When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8749 8750When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8751 8752When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8753 87541. If primitive: it must match exactly the pattern value 87552. If a complex object: it must match (recursively) the pattern value 87563. If an array: it must match (recursively) the pattern value.) 8757 */ 8758 public DataRequirement getPatternDataRequirement() throws FHIRException { 8759 if (this.pattern == null) 8760 this.pattern = new DataRequirement(); 8761 if (!(this.pattern instanceof DataRequirement)) 8762 throw new FHIRException("Type mismatch: the type DataRequirement was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8763 return (DataRequirement) this.pattern; 8764 } 8765 8766 public boolean hasPatternDataRequirement() { 8767 return this != null && this.pattern instanceof DataRequirement; 8768 } 8769 8770 /** 8771 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8772 8773When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8774 8775When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8776 8777When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8778 87791. If primitive: it must match exactly the pattern value 87802. If a complex object: it must match (recursively) the pattern value 87813. If an array: it must match (recursively) the pattern value.) 8782 */ 8783 public Expression getPatternExpression() throws FHIRException { 8784 if (this.pattern == null) 8785 this.pattern = new Expression(); 8786 if (!(this.pattern instanceof Expression)) 8787 throw new FHIRException("Type mismatch: the type Expression was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8788 return (Expression) this.pattern; 8789 } 8790 8791 public boolean hasPatternExpression() { 8792 return this != null && this.pattern instanceof Expression; 8793 } 8794 8795 /** 8796 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8797 8798When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8799 8800When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8801 8802When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8803 88041. If primitive: it must match exactly the pattern value 88052. If a complex object: it must match (recursively) the pattern value 88063. If an array: it must match (recursively) the pattern value.) 8807 */ 8808 public ParameterDefinition getPatternParameterDefinition() throws FHIRException { 8809 if (this.pattern == null) 8810 this.pattern = new ParameterDefinition(); 8811 if (!(this.pattern instanceof ParameterDefinition)) 8812 throw new FHIRException("Type mismatch: the type ParameterDefinition was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8813 return (ParameterDefinition) this.pattern; 8814 } 8815 8816 public boolean hasPatternParameterDefinition() { 8817 return this != null && this.pattern instanceof ParameterDefinition; 8818 } 8819 8820 /** 8821 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8822 8823When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8824 8825When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8826 8827When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8828 88291. If primitive: it must match exactly the pattern value 88302. If a complex object: it must match (recursively) the pattern value 88313. If an array: it must match (recursively) the pattern value.) 8832 */ 8833 public RelatedArtifact getPatternRelatedArtifact() throws FHIRException { 8834 if (this.pattern == null) 8835 this.pattern = new RelatedArtifact(); 8836 if (!(this.pattern instanceof RelatedArtifact)) 8837 throw new FHIRException("Type mismatch: the type RelatedArtifact was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8838 return (RelatedArtifact) this.pattern; 8839 } 8840 8841 public boolean hasPatternRelatedArtifact() { 8842 return this != null && this.pattern instanceof RelatedArtifact; 8843 } 8844 8845 /** 8846 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8847 8848When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8849 8850When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8851 8852When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8853 88541. If primitive: it must match exactly the pattern value 88552. If a complex object: it must match (recursively) the pattern value 88563. If an array: it must match (recursively) the pattern value.) 8857 */ 8858 public TriggerDefinition getPatternTriggerDefinition() throws FHIRException { 8859 if (this.pattern == null) 8860 this.pattern = new TriggerDefinition(); 8861 if (!(this.pattern instanceof TriggerDefinition)) 8862 throw new FHIRException("Type mismatch: the type TriggerDefinition was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8863 return (TriggerDefinition) this.pattern; 8864 } 8865 8866 public boolean hasPatternTriggerDefinition() { 8867 return this != null && this.pattern instanceof TriggerDefinition; 8868 } 8869 8870 /** 8871 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8872 8873When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8874 8875When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8876 8877When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8878 88791. If primitive: it must match exactly the pattern value 88802. If a complex object: it must match (recursively) the pattern value 88813. If an array: it must match (recursively) the pattern value.) 8882 */ 8883 public UsageContext getPatternUsageContext() throws FHIRException { 8884 if (this.pattern == null) 8885 this.pattern = new UsageContext(); 8886 if (!(this.pattern instanceof UsageContext)) 8887 throw new FHIRException("Type mismatch: the type UsageContext was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8888 return (UsageContext) this.pattern; 8889 } 8890 8891 public boolean hasPatternUsageContext() { 8892 return this != null && this.pattern instanceof UsageContext; 8893 } 8894 8895 /** 8896 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8897 8898When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8899 8900When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8901 8902When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8903 89041. If primitive: it must match exactly the pattern value 89052. If a complex object: it must match (recursively) the pattern value 89063. If an array: it must match (recursively) the pattern value.) 8907 */ 8908 public Dosage getPatternDosage() throws FHIRException { 8909 if (this.pattern == null) 8910 this.pattern = new Dosage(); 8911 if (!(this.pattern instanceof Dosage)) 8912 throw new FHIRException("Type mismatch: the type Dosage was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8913 return (Dosage) this.pattern; 8914 } 8915 8916 public boolean hasPatternDosage() { 8917 return this != null && this.pattern instanceof Dosage; 8918 } 8919 8920 /** 8921 * @return {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8922 8923When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8924 8925When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8926 8927When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8928 89291. If primitive: it must match exactly the pattern value 89302. If a complex object: it must match (recursively) the pattern value 89313. If an array: it must match (recursively) the pattern value.) 8932 */ 8933 public Meta getPatternMeta() throws FHIRException { 8934 if (this.pattern == null) 8935 this.pattern = new Meta(); 8936 if (!(this.pattern instanceof Meta)) 8937 throw new FHIRException("Type mismatch: the type Meta was expected, but "+this.pattern.getClass().getName()+" was encountered"); 8938 return (Meta) this.pattern; 8939 } 8940 8941 public boolean hasPatternMeta() { 8942 return this != null && this.pattern instanceof Meta; 8943 } 8944 8945 public boolean hasPattern() { 8946 return this.pattern != null && !this.pattern.isEmpty(); 8947 } 8948 8949 /** 8950 * @param value {@link #pattern} (Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. 8951 8952When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly. 8953 8954When pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array. 8955 8956When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e., 8957 89581. If primitive: it must match exactly the pattern value 89592. If a complex object: it must match (recursively) the pattern value 89603. If an array: it must match (recursively) the pattern value.) 8961 */ 8962 public ElementDefinition setPattern(DataType value) { 8963 if (value != null && !(value instanceof Base64BinaryType || value instanceof BooleanType || value instanceof CanonicalType || value instanceof CodeType || value instanceof DateType || value instanceof DateTimeType || value instanceof DecimalType || value instanceof IdType || value instanceof InstantType || value instanceof IntegerType || value instanceof Integer64Type || value instanceof MarkdownType || value instanceof OidType || value instanceof PositiveIntType || value instanceof StringType || value instanceof TimeType || value instanceof UnsignedIntType || value instanceof UriType || value instanceof UrlType || value instanceof UuidType || value instanceof Address || value instanceof Age || value instanceof Annotation || value instanceof Attachment || value instanceof CodeableConcept || value instanceof Coding || value instanceof ContactPoint || value instanceof Count || value instanceof Distance || value instanceof Duration || value instanceof HumanName || value instanceof Identifier || value instanceof Money || value instanceof Period || value instanceof Quantity || value instanceof Range || value instanceof Ratio || value instanceof Reference || value instanceof SampledData || value instanceof Signature || value instanceof Timing || value instanceof ContactDetail || value instanceof Contributor || value instanceof DataRequirement || value instanceof Expression || value instanceof ParameterDefinition || value instanceof RelatedArtifact || value instanceof TriggerDefinition || value instanceof UsageContext || value instanceof Dosage || value instanceof Meta)) 8964 throw new Error("Not the right type for ElementDefinition.pattern[x]: "+value.fhirType()); 8965 this.pattern = value; 8966 return this; 8967 } 8968 8969 /** 8970 * @return {@link #example} (A sample value for this element demonstrating the type of information that would typically be found in the element.) 8971 */ 8972 public List<ElementDefinitionExampleComponent> getExample() { 8973 if (this.example == null) 8974 this.example = new ArrayList<ElementDefinitionExampleComponent>(); 8975 return this.example; 8976 } 8977 8978 /** 8979 * @return Returns a reference to <code>this</code> for easy method chaining 8980 */ 8981 public ElementDefinition setExample(List<ElementDefinitionExampleComponent> theExample) { 8982 this.example = theExample; 8983 return this; 8984 } 8985 8986 public boolean hasExample() { 8987 if (this.example == null) 8988 return false; 8989 for (ElementDefinitionExampleComponent item : this.example) 8990 if (!item.isEmpty()) 8991 return true; 8992 return false; 8993 } 8994 8995 public ElementDefinitionExampleComponent addExample() { //3 8996 ElementDefinitionExampleComponent t = new ElementDefinitionExampleComponent(); 8997 if (this.example == null) 8998 this.example = new ArrayList<ElementDefinitionExampleComponent>(); 8999 this.example.add(t); 9000 return t; 9001 } 9002 9003 public ElementDefinition addExample(ElementDefinitionExampleComponent t) { //3 9004 if (t == null) 9005 return this; 9006 if (this.example == null) 9007 this.example = new ArrayList<ElementDefinitionExampleComponent>(); 9008 this.example.add(t); 9009 return this; 9010 } 9011 9012 /** 9013 * @return The first repetition of repeating field {@link #example}, creating it if it does not already exist {3} 9014 */ 9015 public ElementDefinitionExampleComponent getExampleFirstRep() { 9016 if (getExample().isEmpty()) { 9017 addExample(); 9018 } 9019 return getExample().get(0); 9020 } 9021 9022 /** 9023 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9024 */ 9025 public DataType getMinValue() { 9026 return this.minValue; 9027 } 9028 9029 /** 9030 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9031 */ 9032 public DateType getMinValueDateType() throws FHIRException { 9033 if (this.minValue == null) 9034 this.minValue = new DateType(); 9035 if (!(this.minValue instanceof DateType)) 9036 throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9037 return (DateType) this.minValue; 9038 } 9039 9040 public boolean hasMinValueDateType() { 9041 return this != null && this.minValue instanceof DateType; 9042 } 9043 9044 /** 9045 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9046 */ 9047 public DateTimeType getMinValueDateTimeType() throws FHIRException { 9048 if (this.minValue == null) 9049 this.minValue = new DateTimeType(); 9050 if (!(this.minValue instanceof DateTimeType)) 9051 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9052 return (DateTimeType) this.minValue; 9053 } 9054 9055 public boolean hasMinValueDateTimeType() { 9056 return this != null && this.minValue instanceof DateTimeType; 9057 } 9058 9059 /** 9060 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9061 */ 9062 public InstantType getMinValueInstantType() throws FHIRException { 9063 if (this.minValue == null) 9064 this.minValue = new InstantType(); 9065 if (!(this.minValue instanceof InstantType)) 9066 throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9067 return (InstantType) this.minValue; 9068 } 9069 9070 public boolean hasMinValueInstantType() { 9071 return this != null && this.minValue instanceof InstantType; 9072 } 9073 9074 /** 9075 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9076 */ 9077 public TimeType getMinValueTimeType() throws FHIRException { 9078 if (this.minValue == null) 9079 this.minValue = new TimeType(); 9080 if (!(this.minValue instanceof TimeType)) 9081 throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9082 return (TimeType) this.minValue; 9083 } 9084 9085 public boolean hasMinValueTimeType() { 9086 return this != null && this.minValue instanceof TimeType; 9087 } 9088 9089 /** 9090 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9091 */ 9092 public DecimalType getMinValueDecimalType() throws FHIRException { 9093 if (this.minValue == null) 9094 this.minValue = new DecimalType(); 9095 if (!(this.minValue instanceof DecimalType)) 9096 throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9097 return (DecimalType) this.minValue; 9098 } 9099 9100 public boolean hasMinValueDecimalType() { 9101 return this != null && this.minValue instanceof DecimalType; 9102 } 9103 9104 /** 9105 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9106 */ 9107 public IntegerType getMinValueIntegerType() throws FHIRException { 9108 if (this.minValue == null) 9109 this.minValue = new IntegerType(); 9110 if (!(this.minValue instanceof IntegerType)) 9111 throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9112 return (IntegerType) this.minValue; 9113 } 9114 9115 public boolean hasMinValueIntegerType() { 9116 return this != null && this.minValue instanceof IntegerType; 9117 } 9118 9119 /** 9120 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9121 */ 9122 public Integer64Type getMinValueInteger64Type() throws FHIRException { 9123 if (this.minValue == null) 9124 this.minValue = new Integer64Type(); 9125 if (!(this.minValue instanceof Integer64Type)) 9126 throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9127 return (Integer64Type) this.minValue; 9128 } 9129 9130 public boolean hasMinValueInteger64Type() { 9131 return this != null && this.minValue instanceof Integer64Type; 9132 } 9133 9134 /** 9135 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9136 */ 9137 public PositiveIntType getMinValuePositiveIntType() throws FHIRException { 9138 if (this.minValue == null) 9139 this.minValue = new PositiveIntType(); 9140 if (!(this.minValue instanceof PositiveIntType)) 9141 throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9142 return (PositiveIntType) this.minValue; 9143 } 9144 9145 public boolean hasMinValuePositiveIntType() { 9146 return this != null && this.minValue instanceof PositiveIntType; 9147 } 9148 9149 /** 9150 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9151 */ 9152 public UnsignedIntType getMinValueUnsignedIntType() throws FHIRException { 9153 if (this.minValue == null) 9154 this.minValue = new UnsignedIntType(); 9155 if (!(this.minValue instanceof UnsignedIntType)) 9156 throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9157 return (UnsignedIntType) this.minValue; 9158 } 9159 9160 public boolean hasMinValueUnsignedIntType() { 9161 return this != null && this.minValue instanceof UnsignedIntType; 9162 } 9163 9164 /** 9165 * @return {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9166 */ 9167 public Quantity getMinValueQuantity() throws FHIRException { 9168 if (this.minValue == null) 9169 this.minValue = new Quantity(); 9170 if (!(this.minValue instanceof Quantity)) 9171 throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.minValue.getClass().getName()+" was encountered"); 9172 return (Quantity) this.minValue; 9173 } 9174 9175 public boolean hasMinValueQuantity() { 9176 return this != null && this.minValue instanceof Quantity; 9177 } 9178 9179 public boolean hasMinValue() { 9180 return this.minValue != null && !this.minValue.isEmpty(); 9181 } 9182 9183 /** 9184 * @param value {@link #minValue} (The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9185 */ 9186 public ElementDefinition setMinValue(DataType value) { 9187 if (value != null && !(value instanceof DateType || value instanceof DateTimeType || value instanceof InstantType || value instanceof TimeType || value instanceof DecimalType || value instanceof IntegerType || value instanceof Integer64Type || value instanceof PositiveIntType || value instanceof UnsignedIntType || value instanceof Quantity)) 9188 throw new Error("Not the right type for ElementDefinition.minValue[x]: "+value.fhirType()); 9189 this.minValue = value; 9190 return this; 9191 } 9192 9193 /** 9194 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9195 */ 9196 public DataType getMaxValue() { 9197 return this.maxValue; 9198 } 9199 9200 /** 9201 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9202 */ 9203 public DateType getMaxValueDateType() throws FHIRException { 9204 if (this.maxValue == null) 9205 this.maxValue = new DateType(); 9206 if (!(this.maxValue instanceof DateType)) 9207 throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9208 return (DateType) this.maxValue; 9209 } 9210 9211 public boolean hasMaxValueDateType() { 9212 return this != null && this.maxValue instanceof DateType; 9213 } 9214 9215 /** 9216 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9217 */ 9218 public DateTimeType getMaxValueDateTimeType() throws FHIRException { 9219 if (this.maxValue == null) 9220 this.maxValue = new DateTimeType(); 9221 if (!(this.maxValue instanceof DateTimeType)) 9222 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9223 return (DateTimeType) this.maxValue; 9224 } 9225 9226 public boolean hasMaxValueDateTimeType() { 9227 return this != null && this.maxValue instanceof DateTimeType; 9228 } 9229 9230 /** 9231 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9232 */ 9233 public InstantType getMaxValueInstantType() throws FHIRException { 9234 if (this.maxValue == null) 9235 this.maxValue = new InstantType(); 9236 if (!(this.maxValue instanceof InstantType)) 9237 throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9238 return (InstantType) this.maxValue; 9239 } 9240 9241 public boolean hasMaxValueInstantType() { 9242 return this != null && this.maxValue instanceof InstantType; 9243 } 9244 9245 /** 9246 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9247 */ 9248 public TimeType getMaxValueTimeType() throws FHIRException { 9249 if (this.maxValue == null) 9250 this.maxValue = new TimeType(); 9251 if (!(this.maxValue instanceof TimeType)) 9252 throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9253 return (TimeType) this.maxValue; 9254 } 9255 9256 public boolean hasMaxValueTimeType() { 9257 return this != null && this.maxValue instanceof TimeType; 9258 } 9259 9260 /** 9261 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9262 */ 9263 public DecimalType getMaxValueDecimalType() throws FHIRException { 9264 if (this.maxValue == null) 9265 this.maxValue = new DecimalType(); 9266 if (!(this.maxValue instanceof DecimalType)) 9267 throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9268 return (DecimalType) this.maxValue; 9269 } 9270 9271 public boolean hasMaxValueDecimalType() { 9272 return this != null && this.maxValue instanceof DecimalType; 9273 } 9274 9275 /** 9276 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9277 */ 9278 public IntegerType getMaxValueIntegerType() throws FHIRException { 9279 if (this.maxValue == null) 9280 this.maxValue = new IntegerType(); 9281 if (!(this.maxValue instanceof IntegerType)) 9282 throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9283 return (IntegerType) this.maxValue; 9284 } 9285 9286 public boolean hasMaxValueIntegerType() { 9287 return this != null && this.maxValue instanceof IntegerType; 9288 } 9289 9290 /** 9291 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9292 */ 9293 public Integer64Type getMaxValueInteger64Type() throws FHIRException { 9294 if (this.maxValue == null) 9295 this.maxValue = new Integer64Type(); 9296 if (!(this.maxValue instanceof Integer64Type)) 9297 throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9298 return (Integer64Type) this.maxValue; 9299 } 9300 9301 public boolean hasMaxValueInteger64Type() { 9302 return this != null && this.maxValue instanceof Integer64Type; 9303 } 9304 9305 /** 9306 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9307 */ 9308 public PositiveIntType getMaxValuePositiveIntType() throws FHIRException { 9309 if (this.maxValue == null) 9310 this.maxValue = new PositiveIntType(); 9311 if (!(this.maxValue instanceof PositiveIntType)) 9312 throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9313 return (PositiveIntType) this.maxValue; 9314 } 9315 9316 public boolean hasMaxValuePositiveIntType() { 9317 return this != null && this.maxValue instanceof PositiveIntType; 9318 } 9319 9320 /** 9321 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9322 */ 9323 public UnsignedIntType getMaxValueUnsignedIntType() throws FHIRException { 9324 if (this.maxValue == null) 9325 this.maxValue = new UnsignedIntType(); 9326 if (!(this.maxValue instanceof UnsignedIntType)) 9327 throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9328 return (UnsignedIntType) this.maxValue; 9329 } 9330 9331 public boolean hasMaxValueUnsignedIntType() { 9332 return this != null && this.maxValue instanceof UnsignedIntType; 9333 } 9334 9335 /** 9336 * @return {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9337 */ 9338 public Quantity getMaxValueQuantity() throws FHIRException { 9339 if (this.maxValue == null) 9340 this.maxValue = new Quantity(); 9341 if (!(this.maxValue instanceof Quantity)) 9342 throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.maxValue.getClass().getName()+" was encountered"); 9343 return (Quantity) this.maxValue; 9344 } 9345 9346 public boolean hasMaxValueQuantity() { 9347 return this != null && this.maxValue instanceof Quantity; 9348 } 9349 9350 public boolean hasMaxValue() { 9351 return this.maxValue != null && !this.maxValue.isEmpty(); 9352 } 9353 9354 /** 9355 * @param value {@link #maxValue} (The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.) 9356 */ 9357 public ElementDefinition setMaxValue(DataType value) { 9358 if (value != null && !(value instanceof DateType || value instanceof DateTimeType || value instanceof InstantType || value instanceof TimeType || value instanceof DecimalType || value instanceof IntegerType || value instanceof Integer64Type || value instanceof PositiveIntType || value instanceof UnsignedIntType || value instanceof Quantity)) 9359 throw new Error("Not the right type for ElementDefinition.maxValue[x]: "+value.fhirType()); 9360 this.maxValue = value; 9361 return this; 9362 } 9363 9364 /** 9365 * @return {@link #maxLength} (Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element.). This is the underlying object with id, value and extensions. The accessor "getMaxLength" gives direct access to the value 9366 */ 9367 public IntegerType getMaxLengthElement() { 9368 if (this.maxLength == null) 9369 if (Configuration.errorOnAutoCreate()) 9370 throw new Error("Attempt to auto-create ElementDefinition.maxLength"); 9371 else if (Configuration.doAutoCreate()) 9372 this.maxLength = new IntegerType(); // bb 9373 return this.maxLength; 9374 } 9375 9376 public boolean hasMaxLengthElement() { 9377 return this.maxLength != null && !this.maxLength.isEmpty(); 9378 } 9379 9380 public boolean hasMaxLength() { 9381 return this.maxLength != null && !this.maxLength.isEmpty(); 9382 } 9383 9384 /** 9385 * @param value {@link #maxLength} (Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element.). This is the underlying object with id, value and extensions. The accessor "getMaxLength" gives direct access to the value 9386 */ 9387 public ElementDefinition setMaxLengthElement(IntegerType value) { 9388 this.maxLength = value; 9389 return this; 9390 } 9391 9392 /** 9393 * @return Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element. 9394 */ 9395 public int getMaxLength() { 9396 return this.maxLength == null || this.maxLength.isEmpty() ? 0 : this.maxLength.getValue(); 9397 } 9398 9399 /** 9400 * @param value Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element. 9401 */ 9402 public ElementDefinition setMaxLength(int value) { 9403 if (this.maxLength == null) 9404 this.maxLength = new IntegerType(); 9405 this.maxLength.setValue(value); 9406 return this; 9407 } 9408 9409 /** 9410 * @return {@link #condition} (A reference to an invariant that may make additional statements about the cardinality or value in the instance.) 9411 */ 9412 public List<IdType> getCondition() { 9413 if (this.condition == null) 9414 this.condition = new ArrayList<IdType>(); 9415 return this.condition; 9416 } 9417 9418 /** 9419 * @return Returns a reference to <code>this</code> for easy method chaining 9420 */ 9421 public ElementDefinition setCondition(List<IdType> theCondition) { 9422 this.condition = theCondition; 9423 return this; 9424 } 9425 9426 public boolean hasCondition() { 9427 if (this.condition == null) 9428 return false; 9429 for (IdType item : this.condition) 9430 if (!item.isEmpty()) 9431 return true; 9432 return false; 9433 } 9434 9435 /** 9436 * @return {@link #condition} (A reference to an invariant that may make additional statements about the cardinality or value in the instance.) 9437 */ 9438 public IdType addConditionElement() {//2 9439 IdType t = new IdType(); 9440 if (this.condition == null) 9441 this.condition = new ArrayList<IdType>(); 9442 this.condition.add(t); 9443 return t; 9444 } 9445 9446 /** 9447 * @param value {@link #condition} (A reference to an invariant that may make additional statements about the cardinality or value in the instance.) 9448 */ 9449 public ElementDefinition addCondition(String value) { //1 9450 IdType t = new IdType(); 9451 t.setValue(value); 9452 if (this.condition == null) 9453 this.condition = new ArrayList<IdType>(); 9454 this.condition.add(t); 9455 return this; 9456 } 9457 9458 /** 9459 * @param value {@link #condition} (A reference to an invariant that may make additional statements about the cardinality or value in the instance.) 9460 */ 9461 public boolean hasCondition(String value) { 9462 if (this.condition == null) 9463 return false; 9464 for (IdType v : this.condition) 9465 if (v.getValue().equals(value)) // id 9466 return true; 9467 return false; 9468 } 9469 9470 /** 9471 * @return {@link #constraint} (Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.) 9472 */ 9473 public List<ElementDefinitionConstraintComponent> getConstraint() { 9474 if (this.constraint == null) 9475 this.constraint = new ArrayList<ElementDefinitionConstraintComponent>(); 9476 return this.constraint; 9477 } 9478 9479 /** 9480 * @return Returns a reference to <code>this</code> for easy method chaining 9481 */ 9482 public ElementDefinition setConstraint(List<ElementDefinitionConstraintComponent> theConstraint) { 9483 this.constraint = theConstraint; 9484 return this; 9485 } 9486 9487 public boolean hasConstraint() { 9488 if (this.constraint == null) 9489 return false; 9490 for (ElementDefinitionConstraintComponent item : this.constraint) 9491 if (!item.isEmpty()) 9492 return true; 9493 return false; 9494 } 9495 9496 public ElementDefinitionConstraintComponent addConstraint() { //3 9497 ElementDefinitionConstraintComponent t = new ElementDefinitionConstraintComponent(); 9498 if (this.constraint == null) 9499 this.constraint = new ArrayList<ElementDefinitionConstraintComponent>(); 9500 this.constraint.add(t); 9501 return t; 9502 } 9503 9504 public ElementDefinition addConstraint(ElementDefinitionConstraintComponent t) { //3 9505 if (t == null) 9506 return this; 9507 if (this.constraint == null) 9508 this.constraint = new ArrayList<ElementDefinitionConstraintComponent>(); 9509 this.constraint.add(t); 9510 return this; 9511 } 9512 9513 /** 9514 * @return The first repetition of repeating field {@link #constraint}, creating it if it does not already exist {3} 9515 */ 9516 public ElementDefinitionConstraintComponent getConstraintFirstRep() { 9517 if (getConstraint().isEmpty()) { 9518 addConstraint(); 9519 } 9520 return getConstraint().get(0); 9521 } 9522 9523 /** 9524 * @return {@link #mustSupport} (If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.). This is the underlying object with id, value and extensions. The accessor "getMustSupport" gives direct access to the value 9525 */ 9526 public BooleanType getMustSupportElement() { 9527 if (this.mustSupport == null) 9528 if (Configuration.errorOnAutoCreate()) 9529 throw new Error("Attempt to auto-create ElementDefinition.mustSupport"); 9530 else if (Configuration.doAutoCreate()) 9531 this.mustSupport = new BooleanType(); // bb 9532 return this.mustSupport; 9533 } 9534 9535 public boolean hasMustSupportElement() { 9536 return this.mustSupport != null && !this.mustSupport.isEmpty(); 9537 } 9538 9539 public boolean hasMustSupport() { 9540 return this.mustSupport != null && !this.mustSupport.isEmpty(); 9541 } 9542 9543 /** 9544 * @param value {@link #mustSupport} (If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.). This is the underlying object with id, value and extensions. The accessor "getMustSupport" gives direct access to the value 9545 */ 9546 public ElementDefinition setMustSupportElement(BooleanType value) { 9547 this.mustSupport = value; 9548 return this; 9549 } 9550 9551 /** 9552 * @return If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation. 9553 */ 9554 public boolean getMustSupport() { 9555 return this.mustSupport == null || this.mustSupport.isEmpty() ? false : this.mustSupport.getValue(); 9556 } 9557 9558 /** 9559 * @param value If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation. 9560 */ 9561 public ElementDefinition setMustSupport(boolean value) { 9562 if (this.mustSupport == null) 9563 this.mustSupport = new BooleanType(); 9564 this.mustSupport.setValue(value); 9565 return this; 9566 } 9567 9568 /** 9569 * @return {@link #isModifier} (If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system.). This is the underlying object with id, value and extensions. The accessor "getIsModifier" gives direct access to the value 9570 */ 9571 public BooleanType getIsModifierElement() { 9572 if (this.isModifier == null) 9573 if (Configuration.errorOnAutoCreate()) 9574 throw new Error("Attempt to auto-create ElementDefinition.isModifier"); 9575 else if (Configuration.doAutoCreate()) 9576 this.isModifier = new BooleanType(); // bb 9577 return this.isModifier; 9578 } 9579 9580 public boolean hasIsModifierElement() { 9581 return this.isModifier != null && !this.isModifier.isEmpty(); 9582 } 9583 9584 public boolean hasIsModifier() { 9585 return this.isModifier != null && !this.isModifier.isEmpty(); 9586 } 9587 9588 /** 9589 * @param value {@link #isModifier} (If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system.). This is the underlying object with id, value and extensions. The accessor "getIsModifier" gives direct access to the value 9590 */ 9591 public ElementDefinition setIsModifierElement(BooleanType value) { 9592 this.isModifier = value; 9593 return this; 9594 } 9595 9596 /** 9597 * @return If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system. 9598 */ 9599 public boolean getIsModifier() { 9600 return this.isModifier == null || this.isModifier.isEmpty() ? false : this.isModifier.getValue(); 9601 } 9602 9603 /** 9604 * @param value If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system. 9605 */ 9606 public ElementDefinition setIsModifier(boolean value) { 9607 if (this.isModifier == null) 9608 this.isModifier = new BooleanType(); 9609 this.isModifier.setValue(value); 9610 return this; 9611 } 9612 9613 /** 9614 * @return {@link #isModifierReason} (Explains how that element affects the interpretation of the resource or element that contains it.). This is the underlying object with id, value and extensions. The accessor "getIsModifierReason" gives direct access to the value 9615 */ 9616 public StringType getIsModifierReasonElement() { 9617 if (this.isModifierReason == null) 9618 if (Configuration.errorOnAutoCreate()) 9619 throw new Error("Attempt to auto-create ElementDefinition.isModifierReason"); 9620 else if (Configuration.doAutoCreate()) 9621 this.isModifierReason = new StringType(); // bb 9622 return this.isModifierReason; 9623 } 9624 9625 public boolean hasIsModifierReasonElement() { 9626 return this.isModifierReason != null && !this.isModifierReason.isEmpty(); 9627 } 9628 9629 public boolean hasIsModifierReason() { 9630 return this.isModifierReason != null && !this.isModifierReason.isEmpty(); 9631 } 9632 9633 /** 9634 * @param value {@link #isModifierReason} (Explains how that element affects the interpretation of the resource or element that contains it.). This is the underlying object with id, value and extensions. The accessor "getIsModifierReason" gives direct access to the value 9635 */ 9636 public ElementDefinition setIsModifierReasonElement(StringType value) { 9637 this.isModifierReason = value; 9638 return this; 9639 } 9640 9641 /** 9642 * @return Explains how that element affects the interpretation of the resource or element that contains it. 9643 */ 9644 public String getIsModifierReason() { 9645 return this.isModifierReason == null ? null : this.isModifierReason.getValue(); 9646 } 9647 9648 /** 9649 * @param value Explains how that element affects the interpretation of the resource or element that contains it. 9650 */ 9651 public ElementDefinition setIsModifierReason(String value) { 9652 if (Utilities.noString(value)) 9653 this.isModifierReason = null; 9654 else { 9655 if (this.isModifierReason == null) 9656 this.isModifierReason = new StringType(); 9657 this.isModifierReason.setValue(value); 9658 } 9659 return this; 9660 } 9661 9662 /** 9663 * @return {@link #isSummary} (Whether the element should be included if a client requests a search with the parameter _summary=true.). This is the underlying object with id, value and extensions. The accessor "getIsSummary" gives direct access to the value 9664 */ 9665 public BooleanType getIsSummaryElement() { 9666 if (this.isSummary == null) 9667 if (Configuration.errorOnAutoCreate()) 9668 throw new Error("Attempt to auto-create ElementDefinition.isSummary"); 9669 else if (Configuration.doAutoCreate()) 9670 this.isSummary = new BooleanType(); // bb 9671 return this.isSummary; 9672 } 9673 9674 public boolean hasIsSummaryElement() { 9675 return this.isSummary != null && !this.isSummary.isEmpty(); 9676 } 9677 9678 public boolean hasIsSummary() { 9679 return this.isSummary != null && !this.isSummary.isEmpty(); 9680 } 9681 9682 /** 9683 * @param value {@link #isSummary} (Whether the element should be included if a client requests a search with the parameter _summary=true.). This is the underlying object with id, value and extensions. The accessor "getIsSummary" gives direct access to the value 9684 */ 9685 public ElementDefinition setIsSummaryElement(BooleanType value) { 9686 this.isSummary = value; 9687 return this; 9688 } 9689 9690 /** 9691 * @return Whether the element should be included if a client requests a search with the parameter _summary=true. 9692 */ 9693 public boolean getIsSummary() { 9694 return this.isSummary == null || this.isSummary.isEmpty() ? false : this.isSummary.getValue(); 9695 } 9696 9697 /** 9698 * @param value Whether the element should be included if a client requests a search with the parameter _summary=true. 9699 */ 9700 public ElementDefinition setIsSummary(boolean value) { 9701 if (this.isSummary == null) 9702 this.isSummary = new BooleanType(); 9703 this.isSummary.setValue(value); 9704 return this; 9705 } 9706 9707 /** 9708 * @return {@link #binding} (Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).) 9709 */ 9710 public ElementDefinitionBindingComponent getBinding() { 9711 if (this.binding == null) 9712 if (Configuration.errorOnAutoCreate()) 9713 throw new Error("Attempt to auto-create ElementDefinition.binding"); 9714 else if (Configuration.doAutoCreate()) 9715 this.binding = new ElementDefinitionBindingComponent(); // cc 9716 return this.binding; 9717 } 9718 9719 public boolean hasBinding() { 9720 return this.binding != null && !this.binding.isEmpty(); 9721 } 9722 9723 /** 9724 * @param value {@link #binding} (Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).) 9725 */ 9726 public ElementDefinition setBinding(ElementDefinitionBindingComponent value) { 9727 this.binding = value; 9728 return this; 9729 } 9730 9731 /** 9732 * @return {@link #mapping} (Identifies a concept from an external specification that roughly corresponds to this element.) 9733 */ 9734 public List<ElementDefinitionMappingComponent> getMapping() { 9735 if (this.mapping == null) 9736 this.mapping = new ArrayList<ElementDefinitionMappingComponent>(); 9737 return this.mapping; 9738 } 9739 9740 /** 9741 * @return Returns a reference to <code>this</code> for easy method chaining 9742 */ 9743 public ElementDefinition setMapping(List<ElementDefinitionMappingComponent> theMapping) { 9744 this.mapping = theMapping; 9745 return this; 9746 } 9747 9748 public boolean hasMapping() { 9749 if (this.mapping == null) 9750 return false; 9751 for (ElementDefinitionMappingComponent item : this.mapping) 9752 if (!item.isEmpty()) 9753 return true; 9754 return false; 9755 } 9756 9757 public ElementDefinitionMappingComponent addMapping() { //3 9758 ElementDefinitionMappingComponent t = new ElementDefinitionMappingComponent(); 9759 if (this.mapping == null) 9760 this.mapping = new ArrayList<ElementDefinitionMappingComponent>(); 9761 this.mapping.add(t); 9762 return t; 9763 } 9764 9765 public ElementDefinition addMapping(ElementDefinitionMappingComponent t) { //3 9766 if (t == null) 9767 return this; 9768 if (this.mapping == null) 9769 this.mapping = new ArrayList<ElementDefinitionMappingComponent>(); 9770 this.mapping.add(t); 9771 return this; 9772 } 9773 9774 /** 9775 * @return The first repetition of repeating field {@link #mapping}, creating it if it does not already exist {3} 9776 */ 9777 public ElementDefinitionMappingComponent getMappingFirstRep() { 9778 if (getMapping().isEmpty()) { 9779 addMapping(); 9780 } 9781 return getMapping().get(0); 9782 } 9783 9784 protected void listChildren(List<Property> children) { 9785 super.listChildren(children); 9786 children.add(new Property("path", "string", "The path identifies the element and is expressed as a \".\"-separated list of ancestor elements, beginning with the name of the resource or extension.", 0, 1, path)); 9787 children.add(new Property("representation", "code", "Codes that define how this element is represented in instances, when the deviation varies from the normal case.", 0, java.lang.Integer.MAX_VALUE, representation)); 9788 children.add(new Property("sliceName", "string", "The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.", 0, 1, sliceName)); 9789 children.add(new Property("sliceIsConstraining", "boolean", "If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.", 0, 1, sliceIsConstraining)); 9790 children.add(new Property("label", "string", "A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.", 0, 1, label)); 9791 children.add(new Property("code", "Coding", "A code that has the same meaning as the element in a particular terminology.", 0, java.lang.Integer.MAX_VALUE, code)); 9792 children.add(new Property("slicing", "", "Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set).", 0, 1, slicing)); 9793 children.add(new Property("short", "string", "A concise description of what this element means (e.g. for use in autogenerated summaries).", 0, 1, short_)); 9794 children.add(new Property("definition", "markdown", "Provides a complete explanation of the meaning of the data element for human readability. For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).", 0, 1, definition)); 9795 children.add(new Property("comment", "markdown", "Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).", 0, 1, comment)); 9796 children.add(new Property("requirements", "markdown", "This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.", 0, 1, requirements)); 9797 children.add(new Property("alias", "string", "Identifies additional names by which this element might also be known.", 0, java.lang.Integer.MAX_VALUE, alias)); 9798 children.add(new Property("min", "unsignedInt", "The minimum number of times this element SHALL appear in the instance.", 0, 1, min)); 9799 children.add(new Property("max", "string", "The maximum number of times this element is permitted to appear in the instance.", 0, 1, max)); 9800 children.add(new Property("base", "", "Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - i.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same.", 0, 1, base)); 9801 children.add(new Property("contentReference", "uri", "Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.", 0, 1, contentReference)); 9802 children.add(new Property("type", "", "The data type or resource that the value of this element is permitted to be.", 0, java.lang.Integer.MAX_VALUE, type)); 9803 children.add(new Property("defaultValue[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue)); 9804 children.add(new Property("meaningWhenMissing", "markdown", "The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').", 0, 1, meaningWhenMissing)); 9805 children.add(new Property("orderMeaning", "string", "If present, indicates that the order of the repeating element has meaning and describes what that meaning is. If absent, it means that the order of the element has no meaning.", 0, 1, orderMeaning)); 9806 children.add(new Property("fixed[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed)); 9807 children.add(new Property("pattern[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern)); 9808 children.add(new Property("example", "", "A sample value for this element demonstrating the type of information that would typically be found in the element.", 0, java.lang.Integer.MAX_VALUE, example)); 9809 children.add(new Property("minValue[x]", "date|dateTime|instant|time|decimal|integer|integer64|positiveInt|unsignedInt|Quantity", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue)); 9810 children.add(new Property("maxValue[x]", "date|dateTime|instant|time|decimal|integer|integer64|positiveInt|unsignedInt|Quantity", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue)); 9811 children.add(new Property("maxLength", "integer", "Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element.", 0, 1, maxLength)); 9812 children.add(new Property("condition", "id", "A reference to an invariant that may make additional statements about the cardinality or value in the instance.", 0, java.lang.Integer.MAX_VALUE, condition)); 9813 children.add(new Property("constraint", "", "Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.", 0, java.lang.Integer.MAX_VALUE, constraint)); 9814 children.add(new Property("mustSupport", "boolean", "If true, implementations that produce or consume resources SHALL provide \"support\" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.", 0, 1, mustSupport)); 9815 children.add(new Property("isModifier", "boolean", "If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system.", 0, 1, isModifier)); 9816 children.add(new Property("isModifierReason", "string", "Explains how that element affects the interpretation of the resource or element that contains it.", 0, 1, isModifierReason)); 9817 children.add(new Property("isSummary", "boolean", "Whether the element should be included if a client requests a search with the parameter _summary=true.", 0, 1, isSummary)); 9818 children.add(new Property("binding", "", "Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).", 0, 1, binding)); 9819 children.add(new Property("mapping", "", "Identifies a concept from an external specification that roughly corresponds to this element.", 0, java.lang.Integer.MAX_VALUE, mapping)); 9820 } 9821 9822 @Override 9823 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 9824 switch (_hash) { 9825 case 3433509: /*path*/ return new Property("path", "string", "The path identifies the element and is expressed as a \".\"-separated list of ancestor elements, beginning with the name of the resource or extension.", 0, 1, path); 9826 case -671065907: /*representation*/ return new Property("representation", "code", "Codes that define how this element is represented in instances, when the deviation varies from the normal case.", 0, java.lang.Integer.MAX_VALUE, representation); 9827 case -825289923: /*sliceName*/ return new Property("sliceName", "string", "The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.", 0, 1, sliceName); 9828 case 333040519: /*sliceIsConstraining*/ return new Property("sliceIsConstraining", "boolean", "If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.", 0, 1, sliceIsConstraining); 9829 case 102727412: /*label*/ return new Property("label", "string", "A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.", 0, 1, label); 9830 case 3059181: /*code*/ return new Property("code", "Coding", "A code that has the same meaning as the element in a particular terminology.", 0, java.lang.Integer.MAX_VALUE, code); 9831 case -2119287345: /*slicing*/ return new Property("slicing", "", "Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set).", 0, 1, slicing); 9832 case 109413500: /*short*/ return new Property("short", "string", "A concise description of what this element means (e.g. for use in autogenerated summaries).", 0, 1, short_); 9833 case -1014418093: /*definition*/ return new Property("definition", "markdown", "Provides a complete explanation of the meaning of the data element for human readability. For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).", 0, 1, definition); 9834 case 950398559: /*comment*/ return new Property("comment", "markdown", "Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).", 0, 1, comment); 9835 case -1619874672: /*requirements*/ return new Property("requirements", "markdown", "This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.", 0, 1, requirements); 9836 case 92902992: /*alias*/ return new Property("alias", "string", "Identifies additional names by which this element might also be known.", 0, java.lang.Integer.MAX_VALUE, alias); 9837 case 108114: /*min*/ return new Property("min", "unsignedInt", "The minimum number of times this element SHALL appear in the instance.", 0, 1, min); 9838 case 107876: /*max*/ return new Property("max", "string", "The maximum number of times this element is permitted to appear in the instance.", 0, 1, max); 9839 case 3016401: /*base*/ return new Property("base", "", "Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - i.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same.", 0, 1, base); 9840 case 1193747154: /*contentReference*/ return new Property("contentReference", "uri", "Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.", 0, 1, contentReference); 9841 case 3575610: /*type*/ return new Property("type", "", "The data type or resource that the value of this element is permitted to be.", 0, java.lang.Integer.MAX_VALUE, type); 9842 case 587922128: /*defaultValue[x]*/ return new Property("defaultValue[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9843 case -659125328: /*defaultValue*/ return new Property("defaultValue[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9844 case 1470297600: /*defaultValueBase64Binary*/ return new Property("defaultValue[x]", "base64Binary", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9845 case 600437336: /*defaultValueBoolean*/ return new Property("defaultValue[x]", "boolean", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9846 case 264593188: /*defaultValueCanonical*/ return new Property("defaultValue[x]", "canonical", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9847 case 1044993469: /*defaultValueCode*/ return new Property("defaultValue[x]", "code", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9848 case 1045010302: /*defaultValueDate*/ return new Property("defaultValue[x]", "date", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9849 case 1220374379: /*defaultValueDateTime*/ return new Property("defaultValue[x]", "dateTime", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9850 case 2077989249: /*defaultValueDecimal*/ return new Property("defaultValue[x]", "decimal", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9851 case -2059245333: /*defaultValueId*/ return new Property("defaultValue[x]", "id", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9852 case -1801671663: /*defaultValueInstant*/ return new Property("defaultValue[x]", "instant", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9853 case -1801189522: /*defaultValueInteger*/ return new Property("defaultValue[x]", "integer", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9854 case -71308628: /*defaultValueInteger64*/ return new Property("defaultValue[x]", "integer64", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9855 case -325436225: /*defaultValueMarkdown*/ return new Property("defaultValue[x]", "markdown", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9856 case 587910138: /*defaultValueOid*/ return new Property("defaultValue[x]", "oid", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9857 case -737344154: /*defaultValuePositiveInt*/ return new Property("defaultValue[x]", "positiveInt", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9858 case -320515103: /*defaultValueString*/ return new Property("defaultValue[x]", "string", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9859 case 1045494429: /*defaultValueTime*/ return new Property("defaultValue[x]", "time", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9860 case 539117290: /*defaultValueUnsignedInt*/ return new Property("defaultValue[x]", "unsignedInt", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9861 case 587916188: /*defaultValueUri*/ return new Property("defaultValue[x]", "uri", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9862 case 587916191: /*defaultValueUrl*/ return new Property("defaultValue[x]", "url", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9863 case 1045535627: /*defaultValueUuid*/ return new Property("defaultValue[x]", "uuid", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9864 case -611966428: /*defaultValueAddress*/ return new Property("defaultValue[x]", "Address", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9865 case 587896623: /*defaultValueAge*/ return new Property("defaultValue[x]", "Age", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9866 case -1851689217: /*defaultValueAnnotation*/ return new Property("defaultValue[x]", "Annotation", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9867 case 2034820339: /*defaultValueAttachment*/ return new Property("defaultValue[x]", "Attachment", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9868 case -410434095: /*defaultValueCodeableConcept*/ return new Property("defaultValue[x]", "CodeableConcept", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9869 case -783616198: /*defaultValueCoding*/ return new Property("defaultValue[x]", "Coding", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9870 case -344740576: /*defaultValueContactPoint*/ return new Property("defaultValue[x]", "ContactPoint", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9871 case -1964924097: /*defaultValueCount*/ return new Property("defaultValue[x]", "Count", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9872 case -283915323: /*defaultValueDistance*/ return new Property("defaultValue[x]", "Distance", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9873 case 1730579812: /*defaultValueDuration*/ return new Property("defaultValue[x]", "Duration", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9874 case -975393912: /*defaultValueHumanName*/ return new Property("defaultValue[x]", "HumanName", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9875 case -1915078535: /*defaultValueIdentifier*/ return new Property("defaultValue[x]", "Identifier", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9876 case -1955695888: /*defaultValueMoney*/ return new Property("defaultValue[x]", "Money", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9877 case -420255343: /*defaultValuePeriod*/ return new Property("defaultValue[x]", "Period", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9878 case -1857379237: /*defaultValueQuantity*/ return new Property("defaultValue[x]", "Quantity", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9879 case -1951495315: /*defaultValueRange*/ return new Property("defaultValue[x]", "Range", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9880 case -1951489477: /*defaultValueRatio*/ return new Property("defaultValue[x]", "Ratio", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9881 case -1488914053: /*defaultValueReference*/ return new Property("defaultValue[x]", "Reference", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9882 case -449641228: /*defaultValueSampledData*/ return new Property("defaultValue[x]", "SampledData", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9883 case 509825768: /*defaultValueSignature*/ return new Property("defaultValue[x]", "Signature", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9884 case -302193638: /*defaultValueTiming*/ return new Property("defaultValue[x]", "Timing", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9885 case 1845473985: /*defaultValueContactDetail*/ return new Property("defaultValue[x]", "ContactDetail", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9886 case 1793609483: /*defaultValueContributor*/ return new Property("defaultValue[x]", "Contributor", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9887 case 375217257: /*defaultValueDataRequirement*/ return new Property("defaultValue[x]", "DataRequirement", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9888 case -2092097944: /*defaultValueExpression*/ return new Property("defaultValue[x]", "Expression", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9889 case -701053940: /*defaultValueParameterDefinition*/ return new Property("defaultValue[x]", "ParameterDefinition", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9890 case 412877133: /*defaultValueRelatedArtifact*/ return new Property("defaultValue[x]", "RelatedArtifact", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9891 case 1913203547: /*defaultValueTriggerDefinition*/ return new Property("defaultValue[x]", "TriggerDefinition", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9892 case -701644642: /*defaultValueUsageContext*/ return new Property("defaultValue[x]", "UsageContext", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9893 case -754548089: /*defaultValueDosage*/ return new Property("defaultValue[x]", "Dosage", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9894 case 1045282261: /*defaultValueMeta*/ return new Property("defaultValue[x]", "Meta", "The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').", 0, 1, defaultValue); 9895 case 1857257103: /*meaningWhenMissing*/ return new Property("meaningWhenMissing", "markdown", "The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').", 0, 1, meaningWhenMissing); 9896 case 1828196047: /*orderMeaning*/ return new Property("orderMeaning", "string", "If present, indicates that the order of the repeating element has meaning and describes what that meaning is. If absent, it means that the order of the element has no meaning.", 0, 1, orderMeaning); 9897 case -391522164: /*fixed[x]*/ return new Property("fixed[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9898 case 97445748: /*fixed*/ return new Property("fixed[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9899 case -799290428: /*fixedBase64Binary*/ return new Property("fixed[x]", "base64Binary", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9900 case 520851988: /*fixedBoolean*/ return new Property("fixed[x]", "boolean", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9901 case 1092485088: /*fixedCanonical*/ return new Property("fixed[x]", "canonical", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9902 case 746991489: /*fixedCode*/ return new Property("fixed[x]", "code", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9903 case 747008322: /*fixedDate*/ return new Property("fixed[x]", "date", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9904 case -1246771409: /*fixedDateTime*/ return new Property("fixed[x]", "dateTime", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9905 case 1998403901: /*fixedDecimal*/ return new Property("fixed[x]", "decimal", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9906 case -843914321: /*fixedId*/ return new Property("fixed[x]", "id", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9907 case -1881257011: /*fixedInstant*/ return new Property("fixed[x]", "instant", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9908 case -1880774870: /*fixedInteger*/ return new Property("fixed[x]", "integer", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9909 case 756583272: /*fixedInteger64*/ return new Property("fixed[x]", "integer64", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9910 case 1502385283: /*fixedMarkdown*/ return new Property("fixed[x]", "markdown", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9911 case -391534154: /*fixedOid*/ return new Property("fixed[x]", "oid", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9912 case 297821986: /*fixedPositiveInt*/ return new Property("fixed[x]", "positiveInt", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9913 case 1062390949: /*fixedString*/ return new Property("fixed[x]", "string", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9914 case 747492449: /*fixedTime*/ return new Property("fixed[x]", "time", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9915 case 1574283430: /*fixedUnsignedInt*/ return new Property("fixed[x]", "unsignedInt", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9916 case -391528104: /*fixedUri*/ return new Property("fixed[x]", "uri", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9917 case -391528101: /*fixedUrl*/ return new Property("fixed[x]", "url", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9918 case 747533647: /*fixedUuid*/ return new Property("fixed[x]", "uuid", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9919 case -691551776: /*fixedAddress*/ return new Property("fixed[x]", "Address", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9920 case -391547669: /*fixedAge*/ return new Property("fixed[x]", "Age", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9921 case -1956844093: /*fixedAnnotation*/ return new Property("fixed[x]", "Annotation", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9922 case 1929665463: /*fixedAttachment*/ return new Property("fixed[x]", "Attachment", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9923 case 1962764685: /*fixedCodeableConcept*/ return new Property("fixed[x]", "CodeableConcept", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9924 case 599289854: /*fixedCoding*/ return new Property("fixed[x]", "Coding", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9925 case 1680638692: /*fixedContactPoint*/ return new Property("fixed[x]", "ContactPoint", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9926 case 1681916411: /*fixedCount*/ return new Property("fixed[x]", "Count", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9927 case 1543906185: /*fixedDistance*/ return new Property("fixed[x]", "Distance", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9928 case -736565976: /*fixedDuration*/ return new Property("fixed[x]", "Duration", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9929 case -147502012: /*fixedHumanName*/ return new Property("fixed[x]", "HumanName", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9930 case -2020233411: /*fixedIdentifier*/ return new Property("fixed[x]", "Identifier", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9931 case 1691144620: /*fixedMoney*/ return new Property("fixed[x]", "Money", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9932 case 962650709: /*fixedPeriod*/ return new Property("fixed[x]", "Period", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9933 case -29557729: /*fixedQuantity*/ return new Property("fixed[x]", "Quantity", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9934 case 1695345193: /*fixedRange*/ return new Property("fixed[x]", "Range", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9935 case 1695351031: /*fixedRatio*/ return new Property("fixed[x]", "Ratio", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9936 case -661022153: /*fixedReference*/ return new Property("fixed[x]", "Reference", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9937 case 585524912: /*fixedSampledData*/ return new Property("fixed[x]", "SampledData", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9938 case 1337717668: /*fixedSignature*/ return new Property("fixed[x]", "Signature", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9939 case 1080712414: /*fixedTiming*/ return new Property("fixed[x]", "Timing", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9940 case 207721853: /*fixedContactDetail*/ return new Property("fixed[x]", "ContactDetail", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9941 case -1466191673: /*fixedContributor*/ return new Property("fixed[x]", "Contributor", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9942 case -1546551259: /*fixedDataRequirement*/ return new Property("fixed[x]", "DataRequirement", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9943 case 2097714476: /*fixedExpression*/ return new Property("fixed[x]", "Expression", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9944 case -2126861880: /*fixedParameterDefinition*/ return new Property("fixed[x]", "ParameterDefinition", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9945 case -1508891383: /*fixedRelatedArtifact*/ return new Property("fixed[x]", "RelatedArtifact", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9946 case 1929596951: /*fixedTriggerDefinition*/ return new Property("fixed[x]", "TriggerDefinition", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9947 case 1323734626: /*fixedUsageContext*/ return new Property("fixed[x]", "UsageContext", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9948 case 628357963: /*fixedDosage*/ return new Property("fixed[x]", "Dosage", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9949 case 747280281: /*fixedMeta*/ return new Property("fixed[x]", "Meta", "Specifies a value that SHALL be exactly the value for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.", 0, 1, fixed); 9950 case -885125392: /*pattern[x]*/ return new Property("pattern[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9951 case -791090288: /*pattern*/ return new Property("pattern[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|Reference|SampledData|Signature|Timing|ContactDetail|Contributor|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Dosage|Meta", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9952 case 2127857120: /*patternBase64Binary*/ return new Property("pattern[x]", "base64Binary", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9953 case -1776945544: /*patternBoolean*/ return new Property("pattern[x]", "boolean", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9954 case 522246980: /*patternCanonical*/ return new Property("pattern[x]", "canonical", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9955 case -1669806691: /*patternCode*/ return new Property("pattern[x]", "code", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9956 case -1669789858: /*patternDate*/ return new Property("pattern[x]", "date", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9957 case 535949131: /*patternDateTime*/ return new Property("pattern[x]", "dateTime", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9958 case -299393631: /*patternDecimal*/ return new Property("pattern[x]", "decimal", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9959 case -28553013: /*patternId*/ return new Property("pattern[x]", "id", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9960 case 115912753: /*patternInstant*/ return new Property("pattern[x]", "instant", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9961 case 116394894: /*patternInteger*/ return new Property("pattern[x]", "integer", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9962 case 186345164: /*patternInteger64*/ return new Property("pattern[x]", "integer64", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9963 case -1009861473: /*patternMarkdown*/ return new Property("pattern[x]", "markdown", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9964 case -885137382: /*patternOid*/ return new Property("pattern[x]", "oid", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9965 case 2054814086: /*patternPositiveInt*/ return new Property("pattern[x]", "positiveInt", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9966 case 2096647105: /*patternString*/ return new Property("pattern[x]", "string", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9967 case -1669305731: /*patternTime*/ return new Property("pattern[x]", "time", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9968 case -963691766: /*patternUnsignedInt*/ return new Property("pattern[x]", "unsignedInt", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9969 case -885131332: /*patternUri*/ return new Property("pattern[x]", "uri", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9970 case -885131329: /*patternUrl*/ return new Property("pattern[x]", "url", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9971 case -1669264533: /*patternUuid*/ return new Property("pattern[x]", "uuid", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9972 case 1305617988: /*patternAddress*/ return new Property("pattern[x]", "Address", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9973 case -885150897: /*patternAge*/ return new Property("pattern[x]", "Age", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9974 case 1840611039: /*patternAnnotation*/ return new Property("pattern[x]", "Annotation", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9975 case 1432153299: /*patternAttachment*/ return new Property("pattern[x]", "Attachment", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9976 case -400610831: /*patternCodeableConcept*/ return new Property("pattern[x]", "CodeableConcept", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9977 case 1633546010: /*patternCoding*/ return new Property("pattern[x]", "Coding", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9978 case 312818944: /*patternContactPoint*/ return new Property("pattern[x]", "ContactPoint", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9979 case -224383137: /*patternCount*/ return new Property("pattern[x]", "Count", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9980 case -968340571: /*patternDistance*/ return new Property("pattern[x]", "Distance", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9981 case 1046154564: /*patternDuration*/ return new Property("pattern[x]", "Duration", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9982 case -717740120: /*patternHumanName*/ return new Property("pattern[x]", "HumanName", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9983 case 1777221721: /*patternIdentifier*/ return new Property("pattern[x]", "Identifier", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9984 case -215154928: /*patternMoney*/ return new Property("pattern[x]", "Money", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9985 case 1996906865: /*patternPeriod*/ return new Property("pattern[x]", "Period", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9986 case 1753162811: /*patternQuantity*/ return new Property("pattern[x]", "Quantity", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9987 case -210954355: /*patternRange*/ return new Property("pattern[x]", "Range", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9988 case -210948517: /*patternRatio*/ return new Property("pattern[x]", "Ratio", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9989 case -1231260261: /*patternReference*/ return new Property("pattern[x]", "Reference", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9990 case -1952450284: /*patternSampledData*/ return new Property("pattern[x]", "SampledData", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9991 case 767479560: /*patternSignature*/ return new Property("pattern[x]", "Signature", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9992 case 2114968570: /*patternTiming*/ return new Property("pattern[x]", "Timing", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9993 case 754982625: /*patternContactDetail*/ return new Property("pattern[x]", "ContactDetail", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9994 case 290800427: /*patternContributor*/ return new Property("pattern[x]", "Contributor", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9995 case 385040521: /*patternDataRequirement*/ return new Property("pattern[x]", "DataRequirement", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9996 case 1600202312: /*patternExpression*/ return new Property("pattern[x]", "Expression", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9997 case 318609452: /*patternParameterDefinition*/ return new Property("pattern[x]", "ParameterDefinition", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9998 case 422700397: /*patternRelatedArtifact*/ return new Property("pattern[x]", "RelatedArtifact", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 9999 case -1531541637: /*patternTriggerDefinition*/ return new Property("pattern[x]", "TriggerDefinition", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 10000 case -44085122: /*patternUsageContext*/ return new Property("pattern[x]", "UsageContext", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 10001 case 1662614119: /*patternDosage*/ return new Property("pattern[x]", "Dosage", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 10002 case -1669517899: /*patternMeta*/ return new Property("pattern[x]", "Meta", "Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example. \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] array must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value.", 0, 1, pattern); 10003 case -1322970774: /*example*/ return new Property("example", "", "A sample value for this element demonstrating the type of information that would typically be found in the element.", 0, java.lang.Integer.MAX_VALUE, example); 10004 case -55301663: /*minValue[x]*/ return new Property("minValue[x]", "date|dateTime|instant|time|decimal|integer|integer64|positiveInt|unsignedInt|Quantity", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10005 case -1376969153: /*minValue*/ return new Property("minValue[x]", "date|dateTime|instant|time|decimal|integer|integer64|positiveInt|unsignedInt|Quantity", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10006 case -1715058035: /*minValueDate*/ return new Property("minValue[x]", "date", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10007 case 1635517178: /*minValueDateTime*/ return new Property("minValue[x]", "dateTime", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10008 case 151382690: /*minValueInstant*/ return new Property("minValue[x]", "instant", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10009 case -1714573908: /*minValueTime*/ return new Property("minValue[x]", "time", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10010 case -263923694: /*minValueDecimal*/ return new Property("minValue[x]", "decimal", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10011 case 151864831: /*minValueInteger*/ return new Property("minValue[x]", "integer", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10012 case -86783747: /*minValueInteger64*/ return new Property("minValue[x]", "integer64", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10013 case 1570935671: /*minValuePositiveInt*/ return new Property("minValue[x]", "positiveInt", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10014 case -1447570181: /*minValueUnsignedInt*/ return new Property("minValue[x]", "unsignedInt", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10015 case -1442236438: /*minValueQuantity*/ return new Property("minValue[x]", "Quantity", "The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, minValue); 10016 case 622130931: /*maxValue[x]*/ return new Property("maxValue[x]", "date|dateTime|instant|time|decimal|integer|integer64|positiveInt|unsignedInt|Quantity", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10017 case 399227501: /*maxValue*/ return new Property("maxValue[x]", "date|dateTime|instant|time|decimal|integer|integer64|positiveInt|unsignedInt|Quantity", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10018 case 2105483195: /*maxValueDate*/ return new Property("maxValue[x]", "date", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10019 case 1699385640: /*maxValueDateTime*/ return new Property("maxValue[x]", "dateTime", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10020 case 1261821620: /*maxValueInstant*/ return new Property("maxValue[x]", "instant", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10021 case 2105967322: /*maxValueTime*/ return new Property("maxValue[x]", "time", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10022 case 846515236: /*maxValueDecimal*/ return new Property("maxValue[x]", "decimal", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10023 case 1262303761: /*maxValueInteger*/ return new Property("maxValue[x]", "integer", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10024 case 1893138575: /*maxValueInteger64*/ return new Property("maxValue[x]", "integer64", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10025 case 1605774985: /*maxValuePositiveInt*/ return new Property("maxValue[x]", "positiveInt", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10026 case -1412730867: /*maxValueUnsignedInt*/ return new Property("maxValue[x]", "unsignedInt", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10027 case -1378367976: /*maxValueQuantity*/ return new Property("maxValue[x]", "Quantity", "The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.", 0, 1, maxValue); 10028 case -791400086: /*maxLength*/ return new Property("maxLength", "integer", "Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element.", 0, 1, maxLength); 10029 case -861311717: /*condition*/ return new Property("condition", "id", "A reference to an invariant that may make additional statements about the cardinality or value in the instance.", 0, java.lang.Integer.MAX_VALUE, condition); 10030 case -190376483: /*constraint*/ return new Property("constraint", "", "Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.", 0, java.lang.Integer.MAX_VALUE, constraint); 10031 case -1402857082: /*mustSupport*/ return new Property("mustSupport", "boolean", "If true, implementations that produce or consume resources SHALL provide \"support\" for the element in some meaningful way. If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.", 0, 1, mustSupport); 10032 case -1408783839: /*isModifier*/ return new Property("isModifier", "boolean", "If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system.", 0, 1, isModifier); 10033 case -1854387259: /*isModifierReason*/ return new Property("isModifierReason", "string", "Explains how that element affects the interpretation of the resource or element that contains it.", 0, 1, isModifierReason); 10034 case 1857548060: /*isSummary*/ return new Property("isSummary", "boolean", "Whether the element should be included if a client requests a search with the parameter _summary=true.", 0, 1, isSummary); 10035 case -108220795: /*binding*/ return new Property("binding", "", "Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).", 0, 1, binding); 10036 case 837556430: /*mapping*/ return new Property("mapping", "", "Identifies a concept from an external specification that roughly corresponds to this element.", 0, java.lang.Integer.MAX_VALUE, mapping); 10037 default: return super.getNamedProperty(_hash, _name, _checkValid); 10038 } 10039 10040 } 10041 10042 @Override 10043 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 10044 switch (hash) { 10045 case 3433509: /*path*/ return this.path == null ? new Base[0] : new Base[] {this.path}; // StringType 10046 case -671065907: /*representation*/ return this.representation == null ? new Base[0] : this.representation.toArray(new Base[this.representation.size()]); // Enumeration<PropertyRepresentation> 10047 case -825289923: /*sliceName*/ return this.sliceName == null ? new Base[0] : new Base[] {this.sliceName}; // StringType 10048 case 333040519: /*sliceIsConstraining*/ return this.sliceIsConstraining == null ? new Base[0] : new Base[] {this.sliceIsConstraining}; // BooleanType 10049 case 102727412: /*label*/ return this.label == null ? new Base[0] : new Base[] {this.label}; // StringType 10050 case 3059181: /*code*/ return this.code == null ? new Base[0] : this.code.toArray(new Base[this.code.size()]); // Coding 10051 case -2119287345: /*slicing*/ return this.slicing == null ? new Base[0] : new Base[] {this.slicing}; // ElementDefinitionSlicingComponent 10052 case 109413500: /*short*/ return this.short_ == null ? new Base[0] : new Base[] {this.short_}; // StringType 10053 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // MarkdownType 10054 case 950398559: /*comment*/ return this.comment == null ? new Base[0] : new Base[] {this.comment}; // MarkdownType 10055 case -1619874672: /*requirements*/ return this.requirements == null ? new Base[0] : new Base[] {this.requirements}; // MarkdownType 10056 case 92902992: /*alias*/ return this.alias == null ? new Base[0] : this.alias.toArray(new Base[this.alias.size()]); // StringType 10057 case 108114: /*min*/ return this.min == null ? new Base[0] : new Base[] {this.min}; // UnsignedIntType 10058 case 107876: /*max*/ return this.max == null ? new Base[0] : new Base[] {this.max}; // StringType 10059 case 3016401: /*base*/ return this.base == null ? new Base[0] : new Base[] {this.base}; // ElementDefinitionBaseComponent 10060 case 1193747154: /*contentReference*/ return this.contentReference == null ? new Base[0] : new Base[] {this.contentReference}; // UriType 10061 case 3575610: /*type*/ return this.type == null ? new Base[0] : this.type.toArray(new Base[this.type.size()]); // TypeRefComponent 10062 case -659125328: /*defaultValue*/ return this.defaultValue == null ? new Base[0] : new Base[] {this.defaultValue}; // DataType 10063 case 1857257103: /*meaningWhenMissing*/ return this.meaningWhenMissing == null ? new Base[0] : new Base[] {this.meaningWhenMissing}; // MarkdownType 10064 case 1828196047: /*orderMeaning*/ return this.orderMeaning == null ? new Base[0] : new Base[] {this.orderMeaning}; // StringType 10065 case 97445748: /*fixed*/ return this.fixed == null ? new Base[0] : new Base[] {this.fixed}; // DataType 10066 case -791090288: /*pattern*/ return this.pattern == null ? new Base[0] : new Base[] {this.pattern}; // DataType 10067 case -1322970774: /*example*/ return this.example == null ? new Base[0] : this.example.toArray(new Base[this.example.size()]); // ElementDefinitionExampleComponent 10068 case -1376969153: /*minValue*/ return this.minValue == null ? new Base[0] : new Base[] {this.minValue}; // DataType 10069 case 399227501: /*maxValue*/ return this.maxValue == null ? new Base[0] : new Base[] {this.maxValue}; // DataType 10070 case -791400086: /*maxLength*/ return this.maxLength == null ? new Base[0] : new Base[] {this.maxLength}; // IntegerType 10071 case -861311717: /*condition*/ return this.condition == null ? new Base[0] : this.condition.toArray(new Base[this.condition.size()]); // IdType 10072 case -190376483: /*constraint*/ return this.constraint == null ? new Base[0] : this.constraint.toArray(new Base[this.constraint.size()]); // ElementDefinitionConstraintComponent 10073 case -1402857082: /*mustSupport*/ return this.mustSupport == null ? new Base[0] : new Base[] {this.mustSupport}; // BooleanType 10074 case -1408783839: /*isModifier*/ return this.isModifier == null ? new Base[0] : new Base[] {this.isModifier}; // BooleanType 10075 case -1854387259: /*isModifierReason*/ return this.isModifierReason == null ? new Base[0] : new Base[] {this.isModifierReason}; // StringType 10076 case 1857548060: /*isSummary*/ return this.isSummary == null ? new Base[0] : new Base[] {this.isSummary}; // BooleanType 10077 case -108220795: /*binding*/ return this.binding == null ? new Base[0] : new Base[] {this.binding}; // ElementDefinitionBindingComponent 10078 case 837556430: /*mapping*/ return this.mapping == null ? new Base[0] : this.mapping.toArray(new Base[this.mapping.size()]); // ElementDefinitionMappingComponent 10079 default: return super.getProperty(hash, name, checkValid); 10080 } 10081 10082 } 10083 10084 @Override 10085 public Base setProperty(int hash, String name, Base value) throws FHIRException { 10086 switch (hash) { 10087 case 3433509: // path 10088 this.path = TypeConvertor.castToString(value); // StringType 10089 return value; 10090 case -671065907: // representation 10091 value = new PropertyRepresentationEnumFactory().fromType(TypeConvertor.castToCode(value)); 10092 this.getRepresentation().add((Enumeration) value); // Enumeration<PropertyRepresentation> 10093 return value; 10094 case -825289923: // sliceName 10095 this.sliceName = TypeConvertor.castToString(value); // StringType 10096 return value; 10097 case 333040519: // sliceIsConstraining 10098 this.sliceIsConstraining = TypeConvertor.castToBoolean(value); // BooleanType 10099 return value; 10100 case 102727412: // label 10101 this.label = TypeConvertor.castToString(value); // StringType 10102 return value; 10103 case 3059181: // code 10104 this.getCode().add(TypeConvertor.castToCoding(value)); // Coding 10105 return value; 10106 case -2119287345: // slicing 10107 this.slicing = (ElementDefinitionSlicingComponent) value; // ElementDefinitionSlicingComponent 10108 return value; 10109 case 109413500: // short 10110 this.short_ = TypeConvertor.castToString(value); // StringType 10111 return value; 10112 case -1014418093: // definition 10113 this.definition = TypeConvertor.castToMarkdown(value); // MarkdownType 10114 return value; 10115 case 950398559: // comment 10116 this.comment = TypeConvertor.castToMarkdown(value); // MarkdownType 10117 return value; 10118 case -1619874672: // requirements 10119 this.requirements = TypeConvertor.castToMarkdown(value); // MarkdownType 10120 return value; 10121 case 92902992: // alias 10122 this.getAlias().add(TypeConvertor.castToString(value)); // StringType 10123 return value; 10124 case 108114: // min 10125 this.min = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType 10126 return value; 10127 case 107876: // max 10128 this.max = TypeConvertor.castToString(value); // StringType 10129 return value; 10130 case 3016401: // base 10131 this.base = (ElementDefinitionBaseComponent) value; // ElementDefinitionBaseComponent 10132 return value; 10133 case 1193747154: // contentReference 10134 this.contentReference = TypeConvertor.castToUri(value); // UriType 10135 return value; 10136 case 3575610: // type 10137 this.getType().add((TypeRefComponent) value); // TypeRefComponent 10138 return value; 10139 case -659125328: // defaultValue 10140 this.defaultValue = TypeConvertor.castToType(value); // DataType 10141 return value; 10142 case 1857257103: // meaningWhenMissing 10143 this.meaningWhenMissing = TypeConvertor.castToMarkdown(value); // MarkdownType 10144 return value; 10145 case 1828196047: // orderMeaning 10146 this.orderMeaning = TypeConvertor.castToString(value); // StringType 10147 return value; 10148 case 97445748: // fixed 10149 this.fixed = TypeConvertor.castToType(value); // DataType 10150 return value; 10151 case -791090288: // pattern 10152 this.pattern = TypeConvertor.castToType(value); // DataType 10153 return value; 10154 case -1322970774: // example 10155 this.getExample().add((ElementDefinitionExampleComponent) value); // ElementDefinitionExampleComponent 10156 return value; 10157 case -1376969153: // minValue 10158 this.minValue = TypeConvertor.castToType(value); // DataType 10159 return value; 10160 case 399227501: // maxValue 10161 this.maxValue = TypeConvertor.castToType(value); // DataType 10162 return value; 10163 case -791400086: // maxLength 10164 this.maxLength = TypeConvertor.castToInteger(value); // IntegerType 10165 return value; 10166 case -861311717: // condition 10167 this.getCondition().add(TypeConvertor.castToId(value)); // IdType 10168 return value; 10169 case -190376483: // constraint 10170 this.getConstraint().add((ElementDefinitionConstraintComponent) value); // ElementDefinitionConstraintComponent 10171 return value; 10172 case -1402857082: // mustSupport 10173 this.mustSupport = TypeConvertor.castToBoolean(value); // BooleanType 10174 return value; 10175 case -1408783839: // isModifier 10176 this.isModifier = TypeConvertor.castToBoolean(value); // BooleanType 10177 return value; 10178 case -1854387259: // isModifierReason 10179 this.isModifierReason = TypeConvertor.castToString(value); // StringType 10180 return value; 10181 case 1857548060: // isSummary 10182 this.isSummary = TypeConvertor.castToBoolean(value); // BooleanType 10183 return value; 10184 case -108220795: // binding 10185 this.binding = (ElementDefinitionBindingComponent) value; // ElementDefinitionBindingComponent 10186 return value; 10187 case 837556430: // mapping 10188 this.getMapping().add((ElementDefinitionMappingComponent) value); // ElementDefinitionMappingComponent 10189 return value; 10190 default: return super.setProperty(hash, name, value); 10191 } 10192 10193 } 10194 10195 @Override 10196 public Base setProperty(String name, Base value) throws FHIRException { 10197 if (name.equals("path")) { 10198 this.path = TypeConvertor.castToString(value); // StringType 10199 } else if (name.equals("representation")) { 10200 value = new PropertyRepresentationEnumFactory().fromType(TypeConvertor.castToCode(value)); 10201 this.getRepresentation().add((Enumeration) value); 10202 } else if (name.equals("sliceName")) { 10203 this.sliceName = TypeConvertor.castToString(value); // StringType 10204 } else if (name.equals("sliceIsConstraining")) { 10205 this.sliceIsConstraining = TypeConvertor.castToBoolean(value); // BooleanType 10206 } else if (name.equals("label")) { 10207 this.label = TypeConvertor.castToString(value); // StringType 10208 } else if (name.equals("code")) { 10209 this.getCode().add(TypeConvertor.castToCoding(value)); 10210 } else if (name.equals("slicing")) { 10211 this.slicing = (ElementDefinitionSlicingComponent) value; // ElementDefinitionSlicingComponent 10212 } else if (name.equals("short")) { 10213 this.short_ = TypeConvertor.castToString(value); // StringType 10214 } else if (name.equals("definition")) { 10215 this.definition = TypeConvertor.castToMarkdown(value); // MarkdownType 10216 } else if (name.equals("comment")) { 10217 this.comment = TypeConvertor.castToMarkdown(value); // MarkdownType 10218 } else if (name.equals("requirements")) { 10219 this.requirements = TypeConvertor.castToMarkdown(value); // MarkdownType 10220 } else if (name.equals("alias")) { 10221 this.getAlias().add(TypeConvertor.castToString(value)); 10222 } else if (name.equals("min")) { 10223 this.min = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType 10224 } else if (name.equals("max")) { 10225 this.max = TypeConvertor.castToString(value); // StringType 10226 } else if (name.equals("base")) { 10227 this.base = (ElementDefinitionBaseComponent) value; // ElementDefinitionBaseComponent 10228 } else if (name.equals("contentReference")) { 10229 this.contentReference = TypeConvertor.castToUri(value); // UriType 10230 } else if (name.equals("type")) { 10231 this.getType().add((TypeRefComponent) value); 10232 } else if (name.equals("defaultValue[x]")) { 10233 this.defaultValue = TypeConvertor.castToType(value); // DataType 10234 } else if (name.equals("meaningWhenMissing")) { 10235 this.meaningWhenMissing = TypeConvertor.castToMarkdown(value); // MarkdownType 10236 } else if (name.equals("orderMeaning")) { 10237 this.orderMeaning = TypeConvertor.castToString(value); // StringType 10238 } else if (name.equals("fixed[x]")) { 10239 this.fixed = TypeConvertor.castToType(value); // DataType 10240 } else if (name.equals("pattern[x]")) { 10241 this.pattern = TypeConvertor.castToType(value); // DataType 10242 } else if (name.equals("example")) { 10243 this.getExample().add((ElementDefinitionExampleComponent) value); 10244 } else if (name.equals("minValue[x]")) { 10245 this.minValue = TypeConvertor.castToType(value); // DataType 10246 } else if (name.equals("maxValue[x]")) { 10247 this.maxValue = TypeConvertor.castToType(value); // DataType 10248 } else if (name.equals("maxLength")) { 10249 this.maxLength = TypeConvertor.castToInteger(value); // IntegerType 10250 } else if (name.equals("condition")) { 10251 this.getCondition().add(TypeConvertor.castToId(value)); 10252 } else if (name.equals("constraint")) { 10253 this.getConstraint().add((ElementDefinitionConstraintComponent) value); 10254 } else if (name.equals("mustSupport")) { 10255 this.mustSupport = TypeConvertor.castToBoolean(value); // BooleanType 10256 } else if (name.equals("isModifier")) { 10257 this.isModifier = TypeConvertor.castToBoolean(value); // BooleanType 10258 } else if (name.equals("isModifierReason")) { 10259 this.isModifierReason = TypeConvertor.castToString(value); // StringType 10260 } else if (name.equals("isSummary")) { 10261 this.isSummary = TypeConvertor.castToBoolean(value); // BooleanType 10262 } else if (name.equals("binding")) { 10263 this.binding = (ElementDefinitionBindingComponent) value; // ElementDefinitionBindingComponent 10264 } else if (name.equals("mapping")) { 10265 this.getMapping().add((ElementDefinitionMappingComponent) value); 10266 } else 10267 return super.setProperty(name, value); 10268 return value; 10269 } 10270 10271 @Override 10272 public Base makeProperty(int hash, String name) throws FHIRException { 10273 switch (hash) { 10274 case 3433509: return getPathElement(); 10275 case -671065907: return addRepresentationElement(); 10276 case -825289923: return getSliceNameElement(); 10277 case 333040519: return getSliceIsConstrainingElement(); 10278 case 102727412: return getLabelElement(); 10279 case 3059181: return addCode(); 10280 case -2119287345: return getSlicing(); 10281 case 109413500: return getShortElement(); 10282 case -1014418093: return getDefinitionElement(); 10283 case 950398559: return getCommentElement(); 10284 case -1619874672: return getRequirementsElement(); 10285 case 92902992: return addAliasElement(); 10286 case 108114: return getMinElement(); 10287 case 107876: return getMaxElement(); 10288 case 3016401: return getBase(); 10289 case 1193747154: return getContentReferenceElement(); 10290 case 3575610: return addType(); 10291 case 587922128: return getDefaultValue(); 10292 case -659125328: return getDefaultValue(); 10293 case 1857257103: return getMeaningWhenMissingElement(); 10294 case 1828196047: return getOrderMeaningElement(); 10295 case -391522164: return getFixed(); 10296 case 97445748: return getFixed(); 10297 case -885125392: return getPattern(); 10298 case -791090288: return getPattern(); 10299 case -1322970774: return addExample(); 10300 case -55301663: return getMinValue(); 10301 case -1376969153: return getMinValue(); 10302 case 622130931: return getMaxValue(); 10303 case 399227501: return getMaxValue(); 10304 case -791400086: return getMaxLengthElement(); 10305 case -861311717: return addConditionElement(); 10306 case -190376483: return addConstraint(); 10307 case -1402857082: return getMustSupportElement(); 10308 case -1408783839: return getIsModifierElement(); 10309 case -1854387259: return getIsModifierReasonElement(); 10310 case 1857548060: return getIsSummaryElement(); 10311 case -108220795: return getBinding(); 10312 case 837556430: return addMapping(); 10313 default: return super.makeProperty(hash, name); 10314 } 10315 10316 } 10317 10318 @Override 10319 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 10320 switch (hash) { 10321 case 3433509: /*path*/ return new String[] {"string"}; 10322 case -671065907: /*representation*/ return new String[] {"code"}; 10323 case -825289923: /*sliceName*/ return new String[] {"string"}; 10324 case 333040519: /*sliceIsConstraining*/ return new String[] {"boolean"}; 10325 case 102727412: /*label*/ return new String[] {"string"}; 10326 case 3059181: /*code*/ return new String[] {"Coding"}; 10327 case -2119287345: /*slicing*/ return new String[] {}; 10328 case 109413500: /*short*/ return new String[] {"string"}; 10329 case -1014418093: /*definition*/ return new String[] {"markdown"}; 10330 case 950398559: /*comment*/ return new String[] {"markdown"}; 10331 case -1619874672: /*requirements*/ return new String[] {"markdown"}; 10332 case 92902992: /*alias*/ return new String[] {"string"}; 10333 case 108114: /*min*/ return new String[] {"unsignedInt"}; 10334 case 107876: /*max*/ return new String[] {"string"}; 10335 case 3016401: /*base*/ return new String[] {}; 10336 case 1193747154: /*contentReference*/ return new String[] {"uri"}; 10337 case 3575610: /*type*/ return new String[] {}; 10338 case -659125328: /*defaultValue*/ return new String[] {"base64Binary", "boolean", "canonical", "code", "date", "dateTime", "decimal", "id", "instant", "integer", "integer64", "markdown", "oid", "positiveInt", "string", "time", "unsignedInt", "uri", "url", "uuid", "Address", "Age", "Annotation", "Attachment", "CodeableConcept", "Coding", "ContactPoint", "Count", "Distance", "Duration", "HumanName", "Identifier", "Money", "Period", "Quantity", "Range", "Ratio", "Reference", "SampledData", "Signature", "Timing", "ContactDetail", "Contributor", "DataRequirement", "Expression", "ParameterDefinition", "RelatedArtifact", "TriggerDefinition", "UsageContext", "Dosage", "Meta"}; 10339 case 1857257103: /*meaningWhenMissing*/ return new String[] {"markdown"}; 10340 case 1828196047: /*orderMeaning*/ return new String[] {"string"}; 10341 case 97445748: /*fixed*/ return new String[] {"base64Binary", "boolean", "canonical", "code", "date", "dateTime", "decimal", "id", "instant", "integer", "integer64", "markdown", "oid", "positiveInt", "string", "time", "unsignedInt", "uri", "url", "uuid", "Address", "Age", "Annotation", "Attachment", "CodeableConcept", "Coding", "ContactPoint", "Count", "Distance", "Duration", "HumanName", "Identifier", "Money", "Period", "Quantity", "Range", "Ratio", "Reference", "SampledData", "Signature", "Timing", "ContactDetail", "Contributor", "DataRequirement", "Expression", "ParameterDefinition", "RelatedArtifact", "TriggerDefinition", "UsageContext", "Dosage", "Meta"}; 10342 case -791090288: /*pattern*/ return new String[] {"base64Binary", "boolean", "canonical", "code", "date", "dateTime", "decimal", "id", "instant", "integer", "integer64", "markdown", "oid", "positiveInt", "string", "time", "unsignedInt", "uri", "url", "uuid", "Address", "Age", "Annotation", "Attachment", "CodeableConcept", "Coding", "ContactPoint", "Count", "Distance", "Duration", "HumanName", "Identifier", "Money", "Period", "Quantity", "Range", "Ratio", "Reference", "SampledData", "Signature", "Timing", "ContactDetail", "Contributor", "DataRequirement", "Expression", "ParameterDefinition", "RelatedArtifact", "TriggerDefinition", "UsageContext", "Dosage", "Meta"}; 10343 case -1322970774: /*example*/ return new String[] {}; 10344 case -1376969153: /*minValue*/ return new String[] {"date", "dateTime", "instant", "time", "decimal", "integer", "integer64", "positiveInt", "unsignedInt", "Quantity"}; 10345 case 399227501: /*maxValue*/ return new String[] {"date", "dateTime", "instant", "time", "decimal", "integer", "integer64", "positiveInt", "unsignedInt", "Quantity"}; 10346 case -791400086: /*maxLength*/ return new String[] {"integer"}; 10347 case -861311717: /*condition*/ return new String[] {"id"}; 10348 case -190376483: /*constraint*/ return new String[] {}; 10349 case -1402857082: /*mustSupport*/ return new String[] {"boolean"}; 10350 case -1408783839: /*isModifier*/ return new String[] {"boolean"}; 10351 case -1854387259: /*isModifierReason*/ return new String[] {"string"}; 10352 case 1857548060: /*isSummary*/ return new String[] {"boolean"}; 10353 case -108220795: /*binding*/ return new String[] {}; 10354 case 837556430: /*mapping*/ return new String[] {}; 10355 default: return super.getTypesForProperty(hash, name); 10356 } 10357 10358 } 10359 10360 @Override 10361 public Base addChild(String name) throws FHIRException { 10362 if (name.equals("path")) { 10363 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.path"); 10364 } 10365 else if (name.equals("representation")) { 10366 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.representation"); 10367 } 10368 else if (name.equals("sliceName")) { 10369 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.sliceName"); 10370 } 10371 else if (name.equals("sliceIsConstraining")) { 10372 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.sliceIsConstraining"); 10373 } 10374 else if (name.equals("label")) { 10375 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.label"); 10376 } 10377 else if (name.equals("code")) { 10378 return addCode(); 10379 } 10380 else if (name.equals("slicing")) { 10381 this.slicing = new ElementDefinitionSlicingComponent(); 10382 return this.slicing; 10383 } 10384 else if (name.equals("short")) { 10385 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.short"); 10386 } 10387 else if (name.equals("definition")) { 10388 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.definition"); 10389 } 10390 else if (name.equals("comment")) { 10391 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.comment"); 10392 } 10393 else if (name.equals("requirements")) { 10394 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.requirements"); 10395 } 10396 else if (name.equals("alias")) { 10397 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.alias"); 10398 } 10399 else if (name.equals("min")) { 10400 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.min"); 10401 } 10402 else if (name.equals("max")) { 10403 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.max"); 10404 } 10405 else if (name.equals("base")) { 10406 this.base = new ElementDefinitionBaseComponent(); 10407 return this.base; 10408 } 10409 else if (name.equals("contentReference")) { 10410 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.contentReference"); 10411 } 10412 else if (name.equals("type")) { 10413 return addType(); 10414 } 10415 else if (name.equals("defaultValueBase64Binary")) { 10416 this.defaultValue = new Base64BinaryType(); 10417 return this.defaultValue; 10418 } 10419 else if (name.equals("defaultValueBoolean")) { 10420 this.defaultValue = new BooleanType(); 10421 return this.defaultValue; 10422 } 10423 else if (name.equals("defaultValueCanonical")) { 10424 this.defaultValue = new CanonicalType(); 10425 return this.defaultValue; 10426 } 10427 else if (name.equals("defaultValueCode")) { 10428 this.defaultValue = new CodeType(); 10429 return this.defaultValue; 10430 } 10431 else if (name.equals("defaultValueDate")) { 10432 this.defaultValue = new DateType(); 10433 return this.defaultValue; 10434 } 10435 else if (name.equals("defaultValueDateTime")) { 10436 this.defaultValue = new DateTimeType(); 10437 return this.defaultValue; 10438 } 10439 else if (name.equals("defaultValueDecimal")) { 10440 this.defaultValue = new DecimalType(); 10441 return this.defaultValue; 10442 } 10443 else if (name.equals("defaultValueId")) { 10444 this.defaultValue = new IdType(); 10445 return this.defaultValue; 10446 } 10447 else if (name.equals("defaultValueInstant")) { 10448 this.defaultValue = new InstantType(); 10449 return this.defaultValue; 10450 } 10451 else if (name.equals("defaultValueInteger")) { 10452 this.defaultValue = new IntegerType(); 10453 return this.defaultValue; 10454 } 10455 else if (name.equals("defaultValueInteger64")) { 10456 this.defaultValue = new Integer64Type(); 10457 return this.defaultValue; 10458 } 10459 else if (name.equals("defaultValueMarkdown")) { 10460 this.defaultValue = new MarkdownType(); 10461 return this.defaultValue; 10462 } 10463 else if (name.equals("defaultValueOid")) { 10464 this.defaultValue = new OidType(); 10465 return this.defaultValue; 10466 } 10467 else if (name.equals("defaultValuePositiveInt")) { 10468 this.defaultValue = new PositiveIntType(); 10469 return this.defaultValue; 10470 } 10471 else if (name.equals("defaultValueString")) { 10472 this.defaultValue = new StringType(); 10473 return this.defaultValue; 10474 } 10475 else if (name.equals("defaultValueTime")) { 10476 this.defaultValue = new TimeType(); 10477 return this.defaultValue; 10478 } 10479 else if (name.equals("defaultValueUnsignedInt")) { 10480 this.defaultValue = new UnsignedIntType(); 10481 return this.defaultValue; 10482 } 10483 else if (name.equals("defaultValueUri")) { 10484 this.defaultValue = new UriType(); 10485 return this.defaultValue; 10486 } 10487 else if (name.equals("defaultValueUrl")) { 10488 this.defaultValue = new UrlType(); 10489 return this.defaultValue; 10490 } 10491 else if (name.equals("defaultValueUuid")) { 10492 this.defaultValue = new UuidType(); 10493 return this.defaultValue; 10494 } 10495 else if (name.equals("defaultValueAddress")) { 10496 this.defaultValue = new Address(); 10497 return this.defaultValue; 10498 } 10499 else if (name.equals("defaultValueAge")) { 10500 this.defaultValue = new Age(); 10501 return this.defaultValue; 10502 } 10503 else if (name.equals("defaultValueAnnotation")) { 10504 this.defaultValue = new Annotation(); 10505 return this.defaultValue; 10506 } 10507 else if (name.equals("defaultValueAttachment")) { 10508 this.defaultValue = new Attachment(); 10509 return this.defaultValue; 10510 } 10511 else if (name.equals("defaultValueCodeableConcept")) { 10512 this.defaultValue = new CodeableConcept(); 10513 return this.defaultValue; 10514 } 10515 else if (name.equals("defaultValueCoding")) { 10516 this.defaultValue = new Coding(); 10517 return this.defaultValue; 10518 } 10519 else if (name.equals("defaultValueContactPoint")) { 10520 this.defaultValue = new ContactPoint(); 10521 return this.defaultValue; 10522 } 10523 else if (name.equals("defaultValueCount")) { 10524 this.defaultValue = new Count(); 10525 return this.defaultValue; 10526 } 10527 else if (name.equals("defaultValueDistance")) { 10528 this.defaultValue = new Distance(); 10529 return this.defaultValue; 10530 } 10531 else if (name.equals("defaultValueDuration")) { 10532 this.defaultValue = new Duration(); 10533 return this.defaultValue; 10534 } 10535 else if (name.equals("defaultValueHumanName")) { 10536 this.defaultValue = new HumanName(); 10537 return this.defaultValue; 10538 } 10539 else if (name.equals("defaultValueIdentifier")) { 10540 this.defaultValue = new Identifier(); 10541 return this.defaultValue; 10542 } 10543 else if (name.equals("defaultValueMoney")) { 10544 this.defaultValue = new Money(); 10545 return this.defaultValue; 10546 } 10547 else if (name.equals("defaultValuePeriod")) { 10548 this.defaultValue = new Period(); 10549 return this.defaultValue; 10550 } 10551 else if (name.equals("defaultValueQuantity")) { 10552 this.defaultValue = new Quantity(); 10553 return this.defaultValue; 10554 } 10555 else if (name.equals("defaultValueRange")) { 10556 this.defaultValue = new Range(); 10557 return this.defaultValue; 10558 } 10559 else if (name.equals("defaultValueRatio")) { 10560 this.defaultValue = new Ratio(); 10561 return this.defaultValue; 10562 } 10563 else if (name.equals("defaultValueReference")) { 10564 this.defaultValue = new Reference(); 10565 return this.defaultValue; 10566 } 10567 else if (name.equals("defaultValueSampledData")) { 10568 this.defaultValue = new SampledData(); 10569 return this.defaultValue; 10570 } 10571 else if (name.equals("defaultValueSignature")) { 10572 this.defaultValue = new Signature(); 10573 return this.defaultValue; 10574 } 10575 else if (name.equals("defaultValueTiming")) { 10576 this.defaultValue = new Timing(); 10577 return this.defaultValue; 10578 } 10579 else if (name.equals("defaultValueContactDetail")) { 10580 this.defaultValue = new ContactDetail(); 10581 return this.defaultValue; 10582 } 10583 else if (name.equals("defaultValueContributor")) { 10584 this.defaultValue = new Contributor(); 10585 return this.defaultValue; 10586 } 10587 else if (name.equals("defaultValueDataRequirement")) { 10588 this.defaultValue = new DataRequirement(); 10589 return this.defaultValue; 10590 } 10591 else if (name.equals("defaultValueExpression")) { 10592 this.defaultValue = new Expression(); 10593 return this.defaultValue; 10594 } 10595 else if (name.equals("defaultValueParameterDefinition")) { 10596 this.defaultValue = new ParameterDefinition(); 10597 return this.defaultValue; 10598 } 10599 else if (name.equals("defaultValueRelatedArtifact")) { 10600 this.defaultValue = new RelatedArtifact(); 10601 return this.defaultValue; 10602 } 10603 else if (name.equals("defaultValueTriggerDefinition")) { 10604 this.defaultValue = new TriggerDefinition(); 10605 return this.defaultValue; 10606 } 10607 else if (name.equals("defaultValueUsageContext")) { 10608 this.defaultValue = new UsageContext(); 10609 return this.defaultValue; 10610 } 10611 else if (name.equals("defaultValueDosage")) { 10612 this.defaultValue = new Dosage(); 10613 return this.defaultValue; 10614 } 10615 else if (name.equals("defaultValueMeta")) { 10616 this.defaultValue = new Meta(); 10617 return this.defaultValue; 10618 } 10619 else if (name.equals("meaningWhenMissing")) { 10620 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.meaningWhenMissing"); 10621 } 10622 else if (name.equals("orderMeaning")) { 10623 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.orderMeaning"); 10624 } 10625 else if (name.equals("fixedBase64Binary")) { 10626 this.fixed = new Base64BinaryType(); 10627 return this.fixed; 10628 } 10629 else if (name.equals("fixedBoolean")) { 10630 this.fixed = new BooleanType(); 10631 return this.fixed; 10632 } 10633 else if (name.equals("fixedCanonical")) { 10634 this.fixed = new CanonicalType(); 10635 return this.fixed; 10636 } 10637 else if (name.equals("fixedCode")) { 10638 this.fixed = new CodeType(); 10639 return this.fixed; 10640 } 10641 else if (name.equals("fixedDate")) { 10642 this.fixed = new DateType(); 10643 return this.fixed; 10644 } 10645 else if (name.equals("fixedDateTime")) { 10646 this.fixed = new DateTimeType(); 10647 return this.fixed; 10648 } 10649 else if (name.equals("fixedDecimal")) { 10650 this.fixed = new DecimalType(); 10651 return this.fixed; 10652 } 10653 else if (name.equals("fixedId")) { 10654 this.fixed = new IdType(); 10655 return this.fixed; 10656 } 10657 else if (name.equals("fixedInstant")) { 10658 this.fixed = new InstantType(); 10659 return this.fixed; 10660 } 10661 else if (name.equals("fixedInteger")) { 10662 this.fixed = new IntegerType(); 10663 return this.fixed; 10664 } 10665 else if (name.equals("fixedInteger64")) { 10666 this.fixed = new Integer64Type(); 10667 return this.fixed; 10668 } 10669 else if (name.equals("fixedMarkdown")) { 10670 this.fixed = new MarkdownType(); 10671 return this.fixed; 10672 } 10673 else if (name.equals("fixedOid")) { 10674 this.fixed = new OidType(); 10675 return this.fixed; 10676 } 10677 else if (name.equals("fixedPositiveInt")) { 10678 this.fixed = new PositiveIntType(); 10679 return this.fixed; 10680 } 10681 else if (name.equals("fixedString")) { 10682 this.fixed = new StringType(); 10683 return this.fixed; 10684 } 10685 else if (name.equals("fixedTime")) { 10686 this.fixed = new TimeType(); 10687 return this.fixed; 10688 } 10689 else if (name.equals("fixedUnsignedInt")) { 10690 this.fixed = new UnsignedIntType(); 10691 return this.fixed; 10692 } 10693 else if (name.equals("fixedUri")) { 10694 this.fixed = new UriType(); 10695 return this.fixed; 10696 } 10697 else if (name.equals("fixedUrl")) { 10698 this.fixed = new UrlType(); 10699 return this.fixed; 10700 } 10701 else if (name.equals("fixedUuid")) { 10702 this.fixed = new UuidType(); 10703 return this.fixed; 10704 } 10705 else if (name.equals("fixedAddress")) { 10706 this.fixed = new Address(); 10707 return this.fixed; 10708 } 10709 else if (name.equals("fixedAge")) { 10710 this.fixed = new Age(); 10711 return this.fixed; 10712 } 10713 else if (name.equals("fixedAnnotation")) { 10714 this.fixed = new Annotation(); 10715 return this.fixed; 10716 } 10717 else if (name.equals("fixedAttachment")) { 10718 this.fixed = new Attachment(); 10719 return this.fixed; 10720 } 10721 else if (name.equals("fixedCodeableConcept")) { 10722 this.fixed = new CodeableConcept(); 10723 return this.fixed; 10724 } 10725 else if (name.equals("fixedCoding")) { 10726 this.fixed = new Coding(); 10727 return this.fixed; 10728 } 10729 else if (name.equals("fixedContactPoint")) { 10730 this.fixed = new ContactPoint(); 10731 return this.fixed; 10732 } 10733 else if (name.equals("fixedCount")) { 10734 this.fixed = new Count(); 10735 return this.fixed; 10736 } 10737 else if (name.equals("fixedDistance")) { 10738 this.fixed = new Distance(); 10739 return this.fixed; 10740 } 10741 else if (name.equals("fixedDuration")) { 10742 this.fixed = new Duration(); 10743 return this.fixed; 10744 } 10745 else if (name.equals("fixedHumanName")) { 10746 this.fixed = new HumanName(); 10747 return this.fixed; 10748 } 10749 else if (name.equals("fixedIdentifier")) { 10750 this.fixed = new Identifier(); 10751 return this.fixed; 10752 } 10753 else if (name.equals("fixedMoney")) { 10754 this.fixed = new Money(); 10755 return this.fixed; 10756 } 10757 else if (name.equals("fixedPeriod")) { 10758 this.fixed = new Period(); 10759 return this.fixed; 10760 } 10761 else if (name.equals("fixedQuantity")) { 10762 this.fixed = new Quantity(); 10763 return this.fixed; 10764 } 10765 else if (name.equals("fixedRange")) { 10766 this.fixed = new Range(); 10767 return this.fixed; 10768 } 10769 else if (name.equals("fixedRatio")) { 10770 this.fixed = new Ratio(); 10771 return this.fixed; 10772 } 10773 else if (name.equals("fixedReference")) { 10774 this.fixed = new Reference(); 10775 return this.fixed; 10776 } 10777 else if (name.equals("fixedSampledData")) { 10778 this.fixed = new SampledData(); 10779 return this.fixed; 10780 } 10781 else if (name.equals("fixedSignature")) { 10782 this.fixed = new Signature(); 10783 return this.fixed; 10784 } 10785 else if (name.equals("fixedTiming")) { 10786 this.fixed = new Timing(); 10787 return this.fixed; 10788 } 10789 else if (name.equals("fixedContactDetail")) { 10790 this.fixed = new ContactDetail(); 10791 return this.fixed; 10792 } 10793 else if (name.equals("fixedContributor")) { 10794 this.fixed = new Contributor(); 10795 return this.fixed; 10796 } 10797 else if (name.equals("fixedDataRequirement")) { 10798 this.fixed = new DataRequirement(); 10799 return this.fixed; 10800 } 10801 else if (name.equals("fixedExpression")) { 10802 this.fixed = new Expression(); 10803 return this.fixed; 10804 } 10805 else if (name.equals("fixedParameterDefinition")) { 10806 this.fixed = new ParameterDefinition(); 10807 return this.fixed; 10808 } 10809 else if (name.equals("fixedRelatedArtifact")) { 10810 this.fixed = new RelatedArtifact(); 10811 return this.fixed; 10812 } 10813 else if (name.equals("fixedTriggerDefinition")) { 10814 this.fixed = new TriggerDefinition(); 10815 return this.fixed; 10816 } 10817 else if (name.equals("fixedUsageContext")) { 10818 this.fixed = new UsageContext(); 10819 return this.fixed; 10820 } 10821 else if (name.equals("fixedDosage")) { 10822 this.fixed = new Dosage(); 10823 return this.fixed; 10824 } 10825 else if (name.equals("fixedMeta")) { 10826 this.fixed = new Meta(); 10827 return this.fixed; 10828 } 10829 else if (name.equals("patternBase64Binary")) { 10830 this.pattern = new Base64BinaryType(); 10831 return this.pattern; 10832 } 10833 else if (name.equals("patternBoolean")) { 10834 this.pattern = new BooleanType(); 10835 return this.pattern; 10836 } 10837 else if (name.equals("patternCanonical")) { 10838 this.pattern = new CanonicalType(); 10839 return this.pattern; 10840 } 10841 else if (name.equals("patternCode")) { 10842 this.pattern = new CodeType(); 10843 return this.pattern; 10844 } 10845 else if (name.equals("patternDate")) { 10846 this.pattern = new DateType(); 10847 return this.pattern; 10848 } 10849 else if (name.equals("patternDateTime")) { 10850 this.pattern = new DateTimeType(); 10851 return this.pattern; 10852 } 10853 else if (name.equals("patternDecimal")) { 10854 this.pattern = new DecimalType(); 10855 return this.pattern; 10856 } 10857 else if (name.equals("patternId")) { 10858 this.pattern = new IdType(); 10859 return this.pattern; 10860 } 10861 else if (name.equals("patternInstant")) { 10862 this.pattern = new InstantType(); 10863 return this.pattern; 10864 } 10865 else if (name.equals("patternInteger")) { 10866 this.pattern = new IntegerType(); 10867 return this.pattern; 10868 } 10869 else if (name.equals("patternInteger64")) { 10870 this.pattern = new Integer64Type(); 10871 return this.pattern; 10872 } 10873 else if (name.equals("patternMarkdown")) { 10874 this.pattern = new MarkdownType(); 10875 return this.pattern; 10876 } 10877 else if (name.equals("patternOid")) { 10878 this.pattern = new OidType(); 10879 return this.pattern; 10880 } 10881 else if (name.equals("patternPositiveInt")) { 10882 this.pattern = new PositiveIntType(); 10883 return this.pattern; 10884 } 10885 else if (name.equals("patternString")) { 10886 this.pattern = new StringType(); 10887 return this.pattern; 10888 } 10889 else if (name.equals("patternTime")) { 10890 this.pattern = new TimeType(); 10891 return this.pattern; 10892 } 10893 else if (name.equals("patternUnsignedInt")) { 10894 this.pattern = new UnsignedIntType(); 10895 return this.pattern; 10896 } 10897 else if (name.equals("patternUri")) { 10898 this.pattern = new UriType(); 10899 return this.pattern; 10900 } 10901 else if (name.equals("patternUrl")) { 10902 this.pattern = new UrlType(); 10903 return this.pattern; 10904 } 10905 else if (name.equals("patternUuid")) { 10906 this.pattern = new UuidType(); 10907 return this.pattern; 10908 } 10909 else if (name.equals("patternAddress")) { 10910 this.pattern = new Address(); 10911 return this.pattern; 10912 } 10913 else if (name.equals("patternAge")) { 10914 this.pattern = new Age(); 10915 return this.pattern; 10916 } 10917 else if (name.equals("patternAnnotation")) { 10918 this.pattern = new Annotation(); 10919 return this.pattern; 10920 } 10921 else if (name.equals("patternAttachment")) { 10922 this.pattern = new Attachment(); 10923 return this.pattern; 10924 } 10925 else if (name.equals("patternCodeableConcept")) { 10926 this.pattern = new CodeableConcept(); 10927 return this.pattern; 10928 } 10929 else if (name.equals("patternCoding")) { 10930 this.pattern = new Coding(); 10931 return this.pattern; 10932 } 10933 else if (name.equals("patternContactPoint")) { 10934 this.pattern = new ContactPoint(); 10935 return this.pattern; 10936 } 10937 else if (name.equals("patternCount")) { 10938 this.pattern = new Count(); 10939 return this.pattern; 10940 } 10941 else if (name.equals("patternDistance")) { 10942 this.pattern = new Distance(); 10943 return this.pattern; 10944 } 10945 else if (name.equals("patternDuration")) { 10946 this.pattern = new Duration(); 10947 return this.pattern; 10948 } 10949 else if (name.equals("patternHumanName")) { 10950 this.pattern = new HumanName(); 10951 return this.pattern; 10952 } 10953 else if (name.equals("patternIdentifier")) { 10954 this.pattern = new Identifier(); 10955 return this.pattern; 10956 } 10957 else if (name.equals("patternMoney")) { 10958 this.pattern = new Money(); 10959 return this.pattern; 10960 } 10961 else if (name.equals("patternPeriod")) { 10962 this.pattern = new Period(); 10963 return this.pattern; 10964 } 10965 else if (name.equals("patternQuantity")) { 10966 this.pattern = new Quantity(); 10967 return this.pattern; 10968 } 10969 else if (name.equals("patternRange")) { 10970 this.pattern = new Range(); 10971 return this.pattern; 10972 } 10973 else if (name.equals("patternRatio")) { 10974 this.pattern = new Ratio(); 10975 return this.pattern; 10976 } 10977 else if (name.equals("patternReference")) { 10978 this.pattern = new Reference(); 10979 return this.pattern; 10980 } 10981 else if (name.equals("patternSampledData")) { 10982 this.pattern = new SampledData(); 10983 return this.pattern; 10984 } 10985 else if (name.equals("patternSignature")) { 10986 this.pattern = new Signature(); 10987 return this.pattern; 10988 } 10989 else if (name.equals("patternTiming")) { 10990 this.pattern = new Timing(); 10991 return this.pattern; 10992 } 10993 else if (name.equals("patternContactDetail")) { 10994 this.pattern = new ContactDetail(); 10995 return this.pattern; 10996 } 10997 else if (name.equals("patternContributor")) { 10998 this.pattern = new Contributor(); 10999 return this.pattern; 11000 } 11001 else if (name.equals("patternDataRequirement")) { 11002 this.pattern = new DataRequirement(); 11003 return this.pattern; 11004 } 11005 else if (name.equals("patternExpression")) { 11006 this.pattern = new Expression(); 11007 return this.pattern; 11008 } 11009 else if (name.equals("patternParameterDefinition")) { 11010 this.pattern = new ParameterDefinition(); 11011 return this.pattern; 11012 } 11013 else if (name.equals("patternRelatedArtifact")) { 11014 this.pattern = new RelatedArtifact(); 11015 return this.pattern; 11016 } 11017 else if (name.equals("patternTriggerDefinition")) { 11018 this.pattern = new TriggerDefinition(); 11019 return this.pattern; 11020 } 11021 else if (name.equals("patternUsageContext")) { 11022 this.pattern = new UsageContext(); 11023 return this.pattern; 11024 } 11025 else if (name.equals("patternDosage")) { 11026 this.pattern = new Dosage(); 11027 return this.pattern; 11028 } 11029 else if (name.equals("patternMeta")) { 11030 this.pattern = new Meta(); 11031 return this.pattern; 11032 } 11033 else if (name.equals("example")) { 11034 return addExample(); 11035 } 11036 else if (name.equals("minValueDate")) { 11037 this.minValue = new DateType(); 11038 return this.minValue; 11039 } 11040 else if (name.equals("minValueDateTime")) { 11041 this.minValue = new DateTimeType(); 11042 return this.minValue; 11043 } 11044 else if (name.equals("minValueInstant")) { 11045 this.minValue = new InstantType(); 11046 return this.minValue; 11047 } 11048 else if (name.equals("minValueTime")) { 11049 this.minValue = new TimeType(); 11050 return this.minValue; 11051 } 11052 else if (name.equals("minValueDecimal")) { 11053 this.minValue = new DecimalType(); 11054 return this.minValue; 11055 } 11056 else if (name.equals("minValueInteger")) { 11057 this.minValue = new IntegerType(); 11058 return this.minValue; 11059 } 11060 else if (name.equals("minValueInteger64")) { 11061 this.minValue = new Integer64Type(); 11062 return this.minValue; 11063 } 11064 else if (name.equals("minValuePositiveInt")) { 11065 this.minValue = new PositiveIntType(); 11066 return this.minValue; 11067 } 11068 else if (name.equals("minValueUnsignedInt")) { 11069 this.minValue = new UnsignedIntType(); 11070 return this.minValue; 11071 } 11072 else if (name.equals("minValueQuantity")) { 11073 this.minValue = new Quantity(); 11074 return this.minValue; 11075 } 11076 else if (name.equals("maxValueDate")) { 11077 this.maxValue = new DateType(); 11078 return this.maxValue; 11079 } 11080 else if (name.equals("maxValueDateTime")) { 11081 this.maxValue = new DateTimeType(); 11082 return this.maxValue; 11083 } 11084 else if (name.equals("maxValueInstant")) { 11085 this.maxValue = new InstantType(); 11086 return this.maxValue; 11087 } 11088 else if (name.equals("maxValueTime")) { 11089 this.maxValue = new TimeType(); 11090 return this.maxValue; 11091 } 11092 else if (name.equals("maxValueDecimal")) { 11093 this.maxValue = new DecimalType(); 11094 return this.maxValue; 11095 } 11096 else if (name.equals("maxValueInteger")) { 11097 this.maxValue = new IntegerType(); 11098 return this.maxValue; 11099 } 11100 else if (name.equals("maxValueInteger64")) { 11101 this.maxValue = new Integer64Type(); 11102 return this.maxValue; 11103 } 11104 else if (name.equals("maxValuePositiveInt")) { 11105 this.maxValue = new PositiveIntType(); 11106 return this.maxValue; 11107 } 11108 else if (name.equals("maxValueUnsignedInt")) { 11109 this.maxValue = new UnsignedIntType(); 11110 return this.maxValue; 11111 } 11112 else if (name.equals("maxValueQuantity")) { 11113 this.maxValue = new Quantity(); 11114 return this.maxValue; 11115 } 11116 else if (name.equals("maxLength")) { 11117 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.maxLength"); 11118 } 11119 else if (name.equals("condition")) { 11120 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.condition"); 11121 } 11122 else if (name.equals("constraint")) { 11123 return addConstraint(); 11124 } 11125 else if (name.equals("mustSupport")) { 11126 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.mustSupport"); 11127 } 11128 else if (name.equals("isModifier")) { 11129 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.isModifier"); 11130 } 11131 else if (name.equals("isModifierReason")) { 11132 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.isModifierReason"); 11133 } 11134 else if (name.equals("isSummary")) { 11135 throw new FHIRException("Cannot call addChild on a primitive type ElementDefinition.isSummary"); 11136 } 11137 else if (name.equals("binding")) { 11138 this.binding = new ElementDefinitionBindingComponent(); 11139 return this.binding; 11140 } 11141 else if (name.equals("mapping")) { 11142 return addMapping(); 11143 } 11144 else 11145 return super.addChild(name); 11146 } 11147 11148 public String fhirType() { 11149 return "ElementDefinition"; 11150 11151 } 11152 11153 public ElementDefinition copy() { 11154 ElementDefinition dst = new ElementDefinition(); 11155 copyValues(dst); 11156 return dst; 11157 } 11158 11159 public void copyValues(ElementDefinition dst) { 11160 super.copyValues(dst); 11161 dst.path = path == null ? null : path.copy(); 11162 if (representation != null) { 11163 dst.representation = new ArrayList<Enumeration<PropertyRepresentation>>(); 11164 for (Enumeration<PropertyRepresentation> i : representation) 11165 dst.representation.add(i.copy()); 11166 }; 11167 dst.sliceName = sliceName == null ? null : sliceName.copy(); 11168 dst.sliceIsConstraining = sliceIsConstraining == null ? null : sliceIsConstraining.copy(); 11169 dst.label = label == null ? null : label.copy(); 11170 if (code != null) { 11171 dst.code = new ArrayList<Coding>(); 11172 for (Coding i : code) 11173 dst.code.add(i.copy()); 11174 }; 11175 dst.slicing = slicing == null ? null : slicing.copy(); 11176 dst.short_ = short_ == null ? null : short_.copy(); 11177 dst.definition = definition == null ? null : definition.copy(); 11178 dst.comment = comment == null ? null : comment.copy(); 11179 dst.requirements = requirements == null ? null : requirements.copy(); 11180 if (alias != null) { 11181 dst.alias = new ArrayList<StringType>(); 11182 for (StringType i : alias) 11183 dst.alias.add(i.copy()); 11184 }; 11185 dst.min = min == null ? null : min.copy(); 11186 dst.max = max == null ? null : max.copy(); 11187 dst.base = base == null ? null : base.copy(); 11188 dst.contentReference = contentReference == null ? null : contentReference.copy(); 11189 if (type != null) { 11190 dst.type = new ArrayList<TypeRefComponent>(); 11191 for (TypeRefComponent i : type) 11192 dst.type.add(i.copy()); 11193 }; 11194 dst.defaultValue = defaultValue == null ? null : defaultValue.copy(); 11195 dst.meaningWhenMissing = meaningWhenMissing == null ? null : meaningWhenMissing.copy(); 11196 dst.orderMeaning = orderMeaning == null ? null : orderMeaning.copy(); 11197 dst.fixed = fixed == null ? null : fixed.copy(); 11198 dst.pattern = pattern == null ? null : pattern.copy(); 11199 if (example != null) { 11200 dst.example = new ArrayList<ElementDefinitionExampleComponent>(); 11201 for (ElementDefinitionExampleComponent i : example) 11202 dst.example.add(i.copy()); 11203 }; 11204 dst.minValue = minValue == null ? null : minValue.copy(); 11205 dst.maxValue = maxValue == null ? null : maxValue.copy(); 11206 dst.maxLength = maxLength == null ? null : maxLength.copy(); 11207 if (condition != null) { 11208 dst.condition = new ArrayList<IdType>(); 11209 for (IdType i : condition) 11210 dst.condition.add(i.copy()); 11211 }; 11212 if (constraint != null) { 11213 dst.constraint = new ArrayList<ElementDefinitionConstraintComponent>(); 11214 for (ElementDefinitionConstraintComponent i : constraint) 11215 dst.constraint.add(i.copy()); 11216 }; 11217 dst.mustSupport = mustSupport == null ? null : mustSupport.copy(); 11218 dst.isModifier = isModifier == null ? null : isModifier.copy(); 11219 dst.isModifierReason = isModifierReason == null ? null : isModifierReason.copy(); 11220 dst.isSummary = isSummary == null ? null : isSummary.copy(); 11221 dst.binding = binding == null ? null : binding.copy(); 11222 if (mapping != null) { 11223 dst.mapping = new ArrayList<ElementDefinitionMappingComponent>(); 11224 for (ElementDefinitionMappingComponent i : mapping) 11225 dst.mapping.add(i.copy()); 11226 }; 11227 } 11228 11229 protected ElementDefinition typedCopy() { 11230 return copy(); 11231 } 11232 11233 @Override 11234 public boolean equalsDeep(Base other_) { 11235 if (!super.equalsDeep(other_)) 11236 return false; 11237 if (!(other_ instanceof ElementDefinition)) 11238 return false; 11239 ElementDefinition o = (ElementDefinition) other_; 11240 return compareDeep(path, o.path, true) && compareDeep(representation, o.representation, true) && compareDeep(sliceName, o.sliceName, true) 11241 && compareDeep(sliceIsConstraining, o.sliceIsConstraining, true) && compareDeep(label, o.label, true) 11242 && compareDeep(code, o.code, true) && compareDeep(slicing, o.slicing, true) && compareDeep(short_, o.short_, true) 11243 && compareDeep(definition, o.definition, true) && compareDeep(comment, o.comment, true) && compareDeep(requirements, o.requirements, true) 11244 && compareDeep(alias, o.alias, true) && compareDeep(min, o.min, true) && compareDeep(max, o.max, true) 11245 && compareDeep(base, o.base, true) && compareDeep(contentReference, o.contentReference, true) && compareDeep(type, o.type, true) 11246 && compareDeep(defaultValue, o.defaultValue, true) && compareDeep(meaningWhenMissing, o.meaningWhenMissing, true) 11247 && compareDeep(orderMeaning, o.orderMeaning, true) && compareDeep(fixed, o.fixed, true) && compareDeep(pattern, o.pattern, true) 11248 && compareDeep(example, o.example, true) && compareDeep(minValue, o.minValue, true) && compareDeep(maxValue, o.maxValue, true) 11249 && compareDeep(maxLength, o.maxLength, true) && compareDeep(condition, o.condition, true) && compareDeep(constraint, o.constraint, true) 11250 && compareDeep(mustSupport, o.mustSupport, true) && compareDeep(isModifier, o.isModifier, true) 11251 && compareDeep(isModifierReason, o.isModifierReason, true) && compareDeep(isSummary, o.isSummary, true) 11252 && compareDeep(binding, o.binding, true) && compareDeep(mapping, o.mapping, true); 11253 } 11254 11255 @Override 11256 public boolean equalsShallow(Base other_) { 11257 if (!super.equalsShallow(other_)) 11258 return false; 11259 if (!(other_ instanceof ElementDefinition)) 11260 return false; 11261 ElementDefinition o = (ElementDefinition) other_; 11262 return compareValues(path, o.path, true) && compareValues(representation, o.representation, true) && compareValues(sliceName, o.sliceName, true) 11263 && compareValues(sliceIsConstraining, o.sliceIsConstraining, true) && compareValues(label, o.label, true) 11264 && compareValues(short_, o.short_, true) && compareValues(definition, o.definition, true) && compareValues(comment, o.comment, true) 11265 && compareValues(requirements, o.requirements, true) && compareValues(alias, o.alias, true) && compareValues(min, o.min, true) 11266 && compareValues(max, o.max, true) && compareValues(contentReference, o.contentReference, true) && compareValues(meaningWhenMissing, o.meaningWhenMissing, true) 11267 && compareValues(orderMeaning, o.orderMeaning, true) && compareValues(maxLength, o.maxLength, true) 11268 && compareValues(condition, o.condition, true) && compareValues(mustSupport, o.mustSupport, true) && compareValues(isModifier, o.isModifier, true) 11269 && compareValues(isModifierReason, o.isModifierReason, true) && compareValues(isSummary, o.isSummary, true) 11270 ; 11271 } 11272 11273 public boolean isEmpty() { 11274 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(path, representation, sliceName 11275 , sliceIsConstraining, label, code, slicing, short_, definition, comment, requirements 11276 , alias, min, max, base, contentReference, type, defaultValue, meaningWhenMissing 11277 , orderMeaning, fixed, pattern, example, minValue, maxValue, maxLength, condition 11278 , constraint, mustSupport, isModifier, isModifierReason, isSummary, binding, mapping 11279 ); 11280 } 11281 11282// Manual code (from Configuration.txt)t: 11283 11284 public String toString() { 11285 if (hasId()) 11286 return getId(); 11287 if (hasSliceName()) 11288 return getPath()+":"+getSliceName(); 11289 else 11290 return getPath(); 11291 } 11292 11293 public void makeBase(String path, int min, String max) { 11294 ElementDefinitionBaseComponent self = getBase(); 11295 self.setPath(path); 11296 self.setMin(min); 11297 self.setMax(max); 11298 } 11299 11300 public void makeBase() { 11301 ElementDefinitionBaseComponent self = getBase(); 11302 self.setPath(getPath()); 11303 self.setMin(getMin()); 11304 self.setMax(getMax()); 11305 } 11306 11307 11308 public String typeSummary() { 11309 CommaSeparatedStringBuilder b = new CommaSeparatedStringBuilder(); 11310 for (TypeRefComponent tr : getType()) { 11311 if (tr.hasCode()) 11312 b.append(tr.getWorkingCode()); 11313 } 11314 return b.toString(); 11315 } 11316 11317 public String typeSummaryVB() { 11318 CommaSeparatedStringBuilder b = new CommaSeparatedStringBuilder("|"); 11319 for (TypeRefComponent tr : getType()) { 11320 if (tr.hasCode()) 11321 b.append(tr.getWorkingCode()); 11322 } 11323 return b.toString().replace(" ", ""); 11324 } 11325 11326 public TypeRefComponent getType(String code) { 11327 for (TypeRefComponent tr : getType()) 11328 if (tr.getCode().equals(code)) 11329 return tr; 11330 TypeRefComponent tr = new TypeRefComponent(); 11331 tr.setCode(code); 11332 type.add(tr); 11333 return tr; 11334 } 11335 11336 public static final boolean NOT_MODIFIER = false; 11337 public static final boolean NOT_IN_SUMMARY = false; 11338 public static final boolean IS_MODIFIER = true; 11339 public static final boolean IS_IN_SUMMARY = true; 11340 public ElementDefinition(boolean defaults, boolean modifier, boolean inSummary) { 11341 super(); 11342 if (defaults) { 11343 setIsModifier(modifier); 11344 setIsSummary(inSummary); 11345 } 11346 } 11347 11348 public String present() { 11349 return hasId() ? getId() : getPath(); 11350 } 11351 11352 public boolean hasCondition(IdType id) { 11353 for (IdType c : getCondition()) { 11354 if (c.primitiveValue().equals(id.primitiveValue())) 11355 return true; 11356 } 11357 return false; 11358 } 11359 11360 public boolean hasConstraint(String key) { 11361 for (ElementDefinitionConstraintComponent c : getConstraint()) { 11362 if (c.getKey().equals(key)) 11363 return true; 11364 } 11365 return false; 11366 } 11367 11368 public boolean hasCode(Coding c) { 11369 for (Coding t : getCode()) { 11370 if (t.getSystem().equals(c.getSystem()) && t.getCode().equals(c.getCode())) 11371 return true; 11372 } 11373 return false; 11374 } 11375 11376 public boolean isChoice() { 11377 return getPath().endsWith("[x]"); 11378 } 11379 11380 public String getName() { 11381 return hasPath() ? getPath().contains(".") ? getPath().substring(getPath().lastIndexOf(".")+1) : getPath() : null; 11382 } 11383 11384 public boolean unbounded() { 11385 return getMax().equals("*") || Integer.parseInt(getMax()) > 1; 11386 } 11387 11388 public boolean isMandatory() { 11389 return getMin() > 0; 11390 } 11391 11392 public boolean isInlineType() { 11393 return getType().size() == 1 && Utilities.existsInList(getType().get(0).getCode(), "Element", "BackboneElement"); 11394 } 11395 11396 11397 11398 11399// end addition 11400 11401}