
001package org.hl7.fhir.dstu3.model; 002 003 004 005/* 006 Copyright (c) 2011+, HL7, Inc. 007 All rights reserved. 008 009 Redistribution and use in source and binary forms, with or without modification, 010 are permitted provided that the following conditions are met: 011 012 * Redistributions of source code must retain the above copyright notice, this 013 list of conditions and the following disclaimer. 014 * Redistributions in binary form must reproduce the above copyright notice, 015 this list of conditions and the following disclaimer in the documentation 016 and/or other materials provided with the distribution. 017 * Neither the name of HL7 nor the names of its contributors may be used to 018 endorse or promote products derived from this software without specific 019 prior written permission. 020 021 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 022 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 023 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 024 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 025 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 026 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 028 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 029 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 030 POSSIBILITY OF SUCH DAMAGE. 031 032*/ 033 034// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x 035import java.util.ArrayList; 036import java.util.Date; 037import java.util.List; 038 039import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatus; 040import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatusEnumFactory; 041import org.hl7.fhir.exceptions.FHIRException; 042import org.hl7.fhir.exceptions.FHIRFormatError; 043import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 044import org.hl7.fhir.utilities.Utilities; 045 046import ca.uhn.fhir.model.api.annotation.Block; 047import ca.uhn.fhir.model.api.annotation.Child; 048import ca.uhn.fhir.model.api.annotation.ChildOrder; 049import ca.uhn.fhir.model.api.annotation.Description; 050import ca.uhn.fhir.model.api.annotation.ResourceDef; 051import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 052/** 053 * A code system resource specifies a set of codes drawn from one or more code systems. 054 */ 055@ResourceDef(name="CodeSystem", profile="http://hl7.org/fhir/Profile/CodeSystem") 056@ChildOrder(names={"url", "identifier", "version", "name", "title", "status", "experimental", "date", "publisher", "contact", "description", "useContext", "jurisdiction", "purpose", "copyright", "caseSensitive", "valueSet", "hierarchyMeaning", "compositional", "versionNeeded", "content", "count", "filter", "property", "concept"}) 057public class CodeSystem extends MetadataResource { 058 059 public enum CodeSystemHierarchyMeaning { 060 /** 061 * No particular relationship between the concepts can be assumed, except what can be determined by inspection of the definitions of the elements (possible reasons to use this: importing from a source where this is not defined, or where various parts of the hierarchy have different meanings) 062 */ 063 GROUPEDBY, 064 /** 065 * A hierarchy where the child concepts have an IS-A relationship with the parents - that is, all the properties of the parent are also true for its child concepts 066 */ 067 ISA, 068 /** 069 * Child elements list the individual parts of a composite whole (e.g. body site) 070 */ 071 PARTOF, 072 /** 073 * Child concepts in the hierarchy may have only one parent, and there is a presumption that the code system is a "closed world" meaning all things must be in the hierarchy. This results in concepts such as "not otherwise classified." 074 */ 075 CLASSIFIEDWITH, 076 /** 077 * added to help the parsers with the generic types 078 */ 079 NULL; 080 public static CodeSystemHierarchyMeaning fromCode(String codeString) throws FHIRException { 081 if (codeString == null || "".equals(codeString)) 082 return null; 083 if ("grouped-by".equals(codeString)) 084 return GROUPEDBY; 085 if ("is-a".equals(codeString)) 086 return ISA; 087 if ("part-of".equals(codeString)) 088 return PARTOF; 089 if ("classified-with".equals(codeString)) 090 return CLASSIFIEDWITH; 091 if (Configuration.isAcceptInvalidEnums()) 092 return null; 093 else 094 throw new FHIRException("Unknown CodeSystemHierarchyMeaning code '"+codeString+"'"); 095 } 096 public String toCode() { 097 switch (this) { 098 case GROUPEDBY: return "grouped-by"; 099 case ISA: return "is-a"; 100 case PARTOF: return "part-of"; 101 case CLASSIFIEDWITH: return "classified-with"; 102 case NULL: return null; 103 default: return "?"; 104 } 105 } 106 public String getSystem() { 107 switch (this) { 108 case GROUPEDBY: return "http://hl7.org/fhir/codesystem-hierarchy-meaning"; 109 case ISA: return "http://hl7.org/fhir/codesystem-hierarchy-meaning"; 110 case PARTOF: return "http://hl7.org/fhir/codesystem-hierarchy-meaning"; 111 case CLASSIFIEDWITH: return "http://hl7.org/fhir/codesystem-hierarchy-meaning"; 112 case NULL: return null; 113 default: return "?"; 114 } 115 } 116 public String getDefinition() { 117 switch (this) { 118 case GROUPEDBY: return "No particular relationship between the concepts can be assumed, except what can be determined by inspection of the definitions of the elements (possible reasons to use this: importing from a source where this is not defined, or where various parts of the hierarchy have different meanings)"; 119 case ISA: return "A hierarchy where the child concepts have an IS-A relationship with the parents - that is, all the properties of the parent are also true for its child concepts"; 120 case PARTOF: return "Child elements list the individual parts of a composite whole (e.g. body site)"; 121 case CLASSIFIEDWITH: return "Child concepts in the hierarchy may have only one parent, and there is a presumption that the code system is a \"closed world\" meaning all things must be in the hierarchy. This results in concepts such as \"not otherwise classified.\""; 122 case NULL: return null; 123 default: return "?"; 124 } 125 } 126 public String getDisplay() { 127 switch (this) { 128 case GROUPEDBY: return "Grouped By"; 129 case ISA: return "Is-A"; 130 case PARTOF: return "Part Of"; 131 case CLASSIFIEDWITH: return "Classified With"; 132 case NULL: return null; 133 default: return "?"; 134 } 135 } 136 } 137 138 public static class CodeSystemHierarchyMeaningEnumFactory implements EnumFactory<CodeSystemHierarchyMeaning> { 139 public CodeSystemHierarchyMeaning fromCode(String codeString) throws IllegalArgumentException { 140 if (codeString == null || "".equals(codeString)) 141 if (codeString == null || "".equals(codeString)) 142 return null; 143 if ("grouped-by".equals(codeString)) 144 return CodeSystemHierarchyMeaning.GROUPEDBY; 145 if ("is-a".equals(codeString)) 146 return CodeSystemHierarchyMeaning.ISA; 147 if ("part-of".equals(codeString)) 148 return CodeSystemHierarchyMeaning.PARTOF; 149 if ("classified-with".equals(codeString)) 150 return CodeSystemHierarchyMeaning.CLASSIFIEDWITH; 151 throw new IllegalArgumentException("Unknown CodeSystemHierarchyMeaning code '"+codeString+"'"); 152 } 153 public Enumeration<CodeSystemHierarchyMeaning> fromType(PrimitiveType<?> code) throws FHIRException { 154 if (code == null) 155 return null; 156 if (code.isEmpty()) 157 return new Enumeration<CodeSystemHierarchyMeaning>(this); 158 String codeString = code.asStringValue(); 159 if (codeString == null || "".equals(codeString)) 160 return null; 161 if ("grouped-by".equals(codeString)) 162 return new Enumeration<CodeSystemHierarchyMeaning>(this, CodeSystemHierarchyMeaning.GROUPEDBY); 163 if ("is-a".equals(codeString)) 164 return new Enumeration<CodeSystemHierarchyMeaning>(this, CodeSystemHierarchyMeaning.ISA); 165 if ("part-of".equals(codeString)) 166 return new Enumeration<CodeSystemHierarchyMeaning>(this, CodeSystemHierarchyMeaning.PARTOF); 167 if ("classified-with".equals(codeString)) 168 return new Enumeration<CodeSystemHierarchyMeaning>(this, CodeSystemHierarchyMeaning.CLASSIFIEDWITH); 169 throw new FHIRException("Unknown CodeSystemHierarchyMeaning code '"+codeString+"'"); 170 } 171 public String toCode(CodeSystemHierarchyMeaning code) { 172 if (code == CodeSystemHierarchyMeaning.GROUPEDBY) 173 return "grouped-by"; 174 if (code == CodeSystemHierarchyMeaning.ISA) 175 return "is-a"; 176 if (code == CodeSystemHierarchyMeaning.PARTOF) 177 return "part-of"; 178 if (code == CodeSystemHierarchyMeaning.CLASSIFIEDWITH) 179 return "classified-with"; 180 return "?"; 181 } 182 public String toSystem(CodeSystemHierarchyMeaning code) { 183 return code.getSystem(); 184 } 185 } 186 187 public enum CodeSystemContentMode { 188 /** 189 * None of the concepts defined by the code system are included in the code system resource 190 */ 191 NOTPRESENT, 192 /** 193 * A few representative concepts are included in the code system resource 194 */ 195 EXAMPLE, 196 /** 197 * A subset of the code system concepts are included in the code system resource 198 */ 199 FRAGMENT, 200 /** 201 * All the concepts defined by the code system are included in the code system resource 202 */ 203 COMPLETE, 204 /** 205 * added to help the parsers with the generic types 206 */ 207 NULL; 208 public static CodeSystemContentMode fromCode(String codeString) throws FHIRException { 209 if (codeString == null || "".equals(codeString)) 210 return null; 211 if ("not-present".equals(codeString)) 212 return NOTPRESENT; 213 if ("example".equals(codeString)) 214 return EXAMPLE; 215 if ("fragment".equals(codeString)) 216 return FRAGMENT; 217 if ("complete".equals(codeString)) 218 return COMPLETE; 219 if (Configuration.isAcceptInvalidEnums()) 220 return null; 221 else 222 throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'"); 223 } 224 public String toCode() { 225 switch (this) { 226 case NOTPRESENT: return "not-present"; 227 case EXAMPLE: return "example"; 228 case FRAGMENT: return "fragment"; 229 case COMPLETE: return "complete"; 230 case NULL: return null; 231 default: return "?"; 232 } 233 } 234 public String getSystem() { 235 switch (this) { 236 case NOTPRESENT: return "http://hl7.org/fhir/codesystem-content-mode"; 237 case EXAMPLE: return "http://hl7.org/fhir/codesystem-content-mode"; 238 case FRAGMENT: return "http://hl7.org/fhir/codesystem-content-mode"; 239 case COMPLETE: return "http://hl7.org/fhir/codesystem-content-mode"; 240 case NULL: return null; 241 default: return "?"; 242 } 243 } 244 public String getDefinition() { 245 switch (this) { 246 case NOTPRESENT: return "None of the concepts defined by the code system are included in the code system resource"; 247 case EXAMPLE: return "A few representative concepts are included in the code system resource"; 248 case FRAGMENT: return "A subset of the code system concepts are included in the code system resource"; 249 case COMPLETE: return "All the concepts defined by the code system are included in the code system resource"; 250 case NULL: return null; 251 default: return "?"; 252 } 253 } 254 public String getDisplay() { 255 switch (this) { 256 case NOTPRESENT: return "Not Present"; 257 case EXAMPLE: return "Example"; 258 case FRAGMENT: return "Fragment"; 259 case COMPLETE: return "Complete"; 260 case NULL: return null; 261 default: return "?"; 262 } 263 } 264 } 265 266 public static class CodeSystemContentModeEnumFactory implements EnumFactory<CodeSystemContentMode> { 267 public CodeSystemContentMode fromCode(String codeString) throws IllegalArgumentException { 268 if (codeString == null || "".equals(codeString)) 269 if (codeString == null || "".equals(codeString)) 270 return null; 271 if ("not-present".equals(codeString)) 272 return CodeSystemContentMode.NOTPRESENT; 273 if ("example".equals(codeString)) 274 return CodeSystemContentMode.EXAMPLE; 275 if ("fragment".equals(codeString)) 276 return CodeSystemContentMode.FRAGMENT; 277 if ("complete".equals(codeString)) 278 return CodeSystemContentMode.COMPLETE; 279 throw new IllegalArgumentException("Unknown CodeSystemContentMode code '"+codeString+"'"); 280 } 281 public Enumeration<CodeSystemContentMode> fromType(PrimitiveType<?> code) throws FHIRException { 282 if (code == null) 283 return null; 284 if (code.isEmpty()) 285 return new Enumeration<CodeSystemContentMode>(this); 286 String codeString = code.asStringValue(); 287 if (codeString == null || "".equals(codeString)) 288 return null; 289 if ("not-present".equals(codeString)) 290 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NOTPRESENT); 291 if ("example".equals(codeString)) 292 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.EXAMPLE); 293 if ("fragment".equals(codeString)) 294 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.FRAGMENT); 295 if ("complete".equals(codeString)) 296 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.COMPLETE); 297 throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'"); 298 } 299 public String toCode(CodeSystemContentMode code) { 300 if (code == CodeSystemContentMode.NOTPRESENT) 301 return "not-present"; 302 if (code == CodeSystemContentMode.EXAMPLE) 303 return "example"; 304 if (code == CodeSystemContentMode.FRAGMENT) 305 return "fragment"; 306 if (code == CodeSystemContentMode.COMPLETE) 307 return "complete"; 308 return "?"; 309 } 310 public String toSystem(CodeSystemContentMode code) { 311 return code.getSystem(); 312 } 313 } 314 315 public enum FilterOperator { 316 /** 317 * The specified property of the code equals the provided value. 318 */ 319 EQUAL, 320 /** 321 * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (i.e. include child codes) 322 */ 323 ISA, 324 /** 325 * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself (i.e. include child codes) 326 */ 327 DESCENDENTOF, 328 /** 329 * The specified property of the code does not have an is-a relationship with the provided value. 330 */ 331 ISNOTA, 332 /** 333 * The specified property of the code matches the regex specified in the provided value. 334 */ 335 REGEX, 336 /** 337 * The specified property of the code is in the set of codes or concepts specified in the provided value (comma separated list). 338 */ 339 IN, 340 /** 341 * The specified property of the code is not in the set of codes or concepts specified in the provided value (comma separated list). 342 */ 343 NOTIN, 344 /** 345 * Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (e.g. include parent codes) 346 */ 347 GENERALIZES, 348 /** 349 * The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values) 350 */ 351 EXISTS, 352 /** 353 * added to help the parsers with the generic types 354 */ 355 NULL; 356 public static FilterOperator fromCode(String codeString) throws FHIRException { 357 if (codeString == null || "".equals(codeString)) 358 return null; 359 if ("=".equals(codeString)) 360 return EQUAL; 361 if ("is-a".equals(codeString)) 362 return ISA; 363 if ("descendent-of".equals(codeString)) 364 return DESCENDENTOF; 365 if ("is-not-a".equals(codeString)) 366 return ISNOTA; 367 if ("regex".equals(codeString)) 368 return REGEX; 369 if ("in".equals(codeString)) 370 return IN; 371 if ("not-in".equals(codeString)) 372 return NOTIN; 373 if ("generalizes".equals(codeString)) 374 return GENERALIZES; 375 if ("exists".equals(codeString)) 376 return EXISTS; 377 if (Configuration.isAcceptInvalidEnums()) 378 return null; 379 else 380 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 381 } 382 public String toCode() { 383 switch (this) { 384 case EQUAL: return "="; 385 case ISA: return "is-a"; 386 case DESCENDENTOF: return "descendent-of"; 387 case ISNOTA: return "is-not-a"; 388 case REGEX: return "regex"; 389 case IN: return "in"; 390 case NOTIN: return "not-in"; 391 case GENERALIZES: return "generalizes"; 392 case EXISTS: return "exists"; 393 case NULL: return null; 394 default: return "?"; 395 } 396 } 397 public String getSystem() { 398 switch (this) { 399 case EQUAL: return "http://hl7.org/fhir/filter-operator"; 400 case ISA: return "http://hl7.org/fhir/filter-operator"; 401 case DESCENDENTOF: return "http://hl7.org/fhir/filter-operator"; 402 case ISNOTA: return "http://hl7.org/fhir/filter-operator"; 403 case REGEX: return "http://hl7.org/fhir/filter-operator"; 404 case IN: return "http://hl7.org/fhir/filter-operator"; 405 case NOTIN: return "http://hl7.org/fhir/filter-operator"; 406 case GENERALIZES: return "http://hl7.org/fhir/filter-operator"; 407 case EXISTS: return "http://hl7.org/fhir/filter-operator"; 408 case NULL: return null; 409 default: return "?"; 410 } 411 } 412 public String getDefinition() { 413 switch (this) { 414 case EQUAL: return "The specified property of the code equals the provided value."; 415 case ISA: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (i.e. include child codes)"; 416 case DESCENDENTOF: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself (i.e. include child codes)"; 417 case ISNOTA: return "The specified property of the code does not have an is-a relationship with the provided value."; 418 case REGEX: return "The specified property of the code matches the regex specified in the provided value."; 419 case IN: return "The specified property of the code is in the set of codes or concepts specified in the provided value (comma separated list)."; 420 case NOTIN: return "The specified property of the code is not in the set of codes or concepts specified in the provided value (comma separated list)."; 421 case GENERALIZES: return "Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (e.g. include parent codes)"; 422 case EXISTS: return "The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values)"; 423 case NULL: return null; 424 default: return "?"; 425 } 426 } 427 public String getDisplay() { 428 switch (this) { 429 case EQUAL: return "Equals"; 430 case ISA: return "Is A (by subsumption)"; 431 case DESCENDENTOF: return "Descendent Of (by subsumption)"; 432 case ISNOTA: return "Not (Is A) (by subsumption)"; 433 case REGEX: return "Regular Expression"; 434 case IN: return "In Set"; 435 case NOTIN: return "Not in Set"; 436 case GENERALIZES: return "Generalizes (by Subsumption)"; 437 case EXISTS: return "Exists"; 438 case NULL: return null; 439 default: return "?"; 440 } 441 } 442 } 443 444 public static class FilterOperatorEnumFactory implements EnumFactory<FilterOperator> { 445 public FilterOperator fromCode(String codeString) throws IllegalArgumentException { 446 if (codeString == null || "".equals(codeString)) 447 if (codeString == null || "".equals(codeString)) 448 return null; 449 if ("=".equals(codeString)) 450 return FilterOperator.EQUAL; 451 if ("is-a".equals(codeString)) 452 return FilterOperator.ISA; 453 if ("descendent-of".equals(codeString)) 454 return FilterOperator.DESCENDENTOF; 455 if ("is-not-a".equals(codeString)) 456 return FilterOperator.ISNOTA; 457 if ("regex".equals(codeString)) 458 return FilterOperator.REGEX; 459 if ("in".equals(codeString)) 460 return FilterOperator.IN; 461 if ("not-in".equals(codeString)) 462 return FilterOperator.NOTIN; 463 if ("generalizes".equals(codeString)) 464 return FilterOperator.GENERALIZES; 465 if ("exists".equals(codeString)) 466 return FilterOperator.EXISTS; 467 throw new IllegalArgumentException("Unknown FilterOperator code '"+codeString+"'"); 468 } 469 public Enumeration<FilterOperator> fromType(PrimitiveType<?> code) throws FHIRException { 470 if (code == null) 471 return null; 472 if (code.isEmpty()) 473 return new Enumeration<FilterOperator>(this); 474 String codeString = code.asStringValue(); 475 if (codeString == null || "".equals(codeString)) 476 return null; 477 if ("=".equals(codeString)) 478 return new Enumeration<FilterOperator>(this, FilterOperator.EQUAL); 479 if ("is-a".equals(codeString)) 480 return new Enumeration<FilterOperator>(this, FilterOperator.ISA); 481 if ("descendent-of".equals(codeString)) 482 return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTOF); 483 if ("is-not-a".equals(codeString)) 484 return new Enumeration<FilterOperator>(this, FilterOperator.ISNOTA); 485 if ("regex".equals(codeString)) 486 return new Enumeration<FilterOperator>(this, FilterOperator.REGEX); 487 if ("in".equals(codeString)) 488 return new Enumeration<FilterOperator>(this, FilterOperator.IN); 489 if ("not-in".equals(codeString)) 490 return new Enumeration<FilterOperator>(this, FilterOperator.NOTIN); 491 if ("generalizes".equals(codeString)) 492 return new Enumeration<FilterOperator>(this, FilterOperator.GENERALIZES); 493 if ("exists".equals(codeString)) 494 return new Enumeration<FilterOperator>(this, FilterOperator.EXISTS); 495 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 496 } 497 public String toCode(FilterOperator code) { 498 if (code == FilterOperator.EQUAL) 499 return "="; 500 if (code == FilterOperator.ISA) 501 return "is-a"; 502 if (code == FilterOperator.DESCENDENTOF) 503 return "descendent-of"; 504 if (code == FilterOperator.ISNOTA) 505 return "is-not-a"; 506 if (code == FilterOperator.REGEX) 507 return "regex"; 508 if (code == FilterOperator.IN) 509 return "in"; 510 if (code == FilterOperator.NOTIN) 511 return "not-in"; 512 if (code == FilterOperator.GENERALIZES) 513 return "generalizes"; 514 if (code == FilterOperator.EXISTS) 515 return "exists"; 516 return "?"; 517 } 518 public String toSystem(FilterOperator code) { 519 return code.getSystem(); 520 } 521 } 522 523 public enum PropertyType { 524 /** 525 * The property value is a code that identifies a concept defined in the code system 526 */ 527 CODE, 528 /** 529 * The property value is a code defined in an external code system. This may be used for translations, but is not the intent 530 */ 531 CODING, 532 /** 533 * The property value is a string 534 */ 535 STRING, 536 /** 537 * The property value is a string (often used to assign ranking values to concepts for supporting score assessments) 538 */ 539 INTEGER, 540 /** 541 * The property value is a boolean true | false 542 */ 543 BOOLEAN, 544 /** 545 * The property is a date or a date + time 546 */ 547 DATETIME, 548 /** 549 * added to help the parsers with the generic types 550 */ 551 NULL; 552 public static PropertyType fromCode(String codeString) throws FHIRException { 553 if (codeString == null || "".equals(codeString)) 554 return null; 555 if ("code".equals(codeString)) 556 return CODE; 557 if ("Coding".equals(codeString)) 558 return CODING; 559 if ("string".equals(codeString)) 560 return STRING; 561 if ("integer".equals(codeString)) 562 return INTEGER; 563 if ("boolean".equals(codeString)) 564 return BOOLEAN; 565 if ("dateTime".equals(codeString)) 566 return DATETIME; 567 if (Configuration.isAcceptInvalidEnums()) 568 return null; 569 else 570 throw new FHIRException("Unknown PropertyType code '"+codeString+"'"); 571 } 572 public String toCode() { 573 switch (this) { 574 case CODE: return "code"; 575 case CODING: return "Coding"; 576 case STRING: return "string"; 577 case INTEGER: return "integer"; 578 case BOOLEAN: return "boolean"; 579 case DATETIME: return "dateTime"; 580 case NULL: return null; 581 default: return "?"; 582 } 583 } 584 public String getSystem() { 585 switch (this) { 586 case CODE: return "http://hl7.org/fhir/concept-property-type"; 587 case CODING: return "http://hl7.org/fhir/concept-property-type"; 588 case STRING: return "http://hl7.org/fhir/concept-property-type"; 589 case INTEGER: return "http://hl7.org/fhir/concept-property-type"; 590 case BOOLEAN: return "http://hl7.org/fhir/concept-property-type"; 591 case DATETIME: return "http://hl7.org/fhir/concept-property-type"; 592 case NULL: return null; 593 default: return "?"; 594 } 595 } 596 public String getDefinition() { 597 switch (this) { 598 case CODE: return "The property value is a code that identifies a concept defined in the code system"; 599 case CODING: return "The property value is a code defined in an external code system. This may be used for translations, but is not the intent"; 600 case STRING: return "The property value is a string"; 601 case INTEGER: return "The property value is a string (often used to assign ranking values to concepts for supporting score assessments)"; 602 case BOOLEAN: return "The property value is a boolean true | false"; 603 case DATETIME: return "The property is a date or a date + time"; 604 case NULL: return null; 605 default: return "?"; 606 } 607 } 608 public String getDisplay() { 609 switch (this) { 610 case CODE: return "code (internal reference)"; 611 case CODING: return "Coding (external reference)"; 612 case STRING: return "string"; 613 case INTEGER: return "integer"; 614 case BOOLEAN: return "boolean"; 615 case DATETIME: return "dateTime"; 616 case NULL: return null; 617 default: return "?"; 618 } 619 } 620 } 621 622 public static class PropertyTypeEnumFactory implements EnumFactory<PropertyType> { 623 public PropertyType fromCode(String codeString) throws IllegalArgumentException { 624 if (codeString == null || "".equals(codeString)) 625 if (codeString == null || "".equals(codeString)) 626 return null; 627 if ("code".equals(codeString)) 628 return PropertyType.CODE; 629 if ("Coding".equals(codeString)) 630 return PropertyType.CODING; 631 if ("string".equals(codeString)) 632 return PropertyType.STRING; 633 if ("integer".equals(codeString)) 634 return PropertyType.INTEGER; 635 if ("boolean".equals(codeString)) 636 return PropertyType.BOOLEAN; 637 if ("dateTime".equals(codeString)) 638 return PropertyType.DATETIME; 639 throw new IllegalArgumentException("Unknown PropertyType code '"+codeString+"'"); 640 } 641 public Enumeration<PropertyType> fromType(PrimitiveType<?> code) throws FHIRException { 642 if (code == null) 643 return null; 644 if (code.isEmpty()) 645 return new Enumeration<PropertyType>(this); 646 String codeString = code.asStringValue(); 647 if (codeString == null || "".equals(codeString)) 648 return null; 649 if ("code".equals(codeString)) 650 return new Enumeration<PropertyType>(this, PropertyType.CODE); 651 if ("Coding".equals(codeString)) 652 return new Enumeration<PropertyType>(this, PropertyType.CODING); 653 if ("string".equals(codeString)) 654 return new Enumeration<PropertyType>(this, PropertyType.STRING); 655 if ("integer".equals(codeString)) 656 return new Enumeration<PropertyType>(this, PropertyType.INTEGER); 657 if ("boolean".equals(codeString)) 658 return new Enumeration<PropertyType>(this, PropertyType.BOOLEAN); 659 if ("dateTime".equals(codeString)) 660 return new Enumeration<PropertyType>(this, PropertyType.DATETIME); 661 throw new FHIRException("Unknown PropertyType code '"+codeString+"'"); 662 } 663 public String toCode(PropertyType code) { 664 if (code == PropertyType.CODE) 665 return "code"; 666 if (code == PropertyType.CODING) 667 return "Coding"; 668 if (code == PropertyType.STRING) 669 return "string"; 670 if (code == PropertyType.INTEGER) 671 return "integer"; 672 if (code == PropertyType.BOOLEAN) 673 return "boolean"; 674 if (code == PropertyType.DATETIME) 675 return "dateTime"; 676 return "?"; 677 } 678 public String toSystem(PropertyType code) { 679 return code.getSystem(); 680 } 681 } 682 683 @Block() 684 public static class CodeSystemFilterComponent extends BackboneElement implements IBaseBackboneElement { 685 /** 686 * The code that identifies this filter when it is used in the instance. 687 */ 688 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 689 @Description(shortDefinition="Code that identifies the filter", formalDefinition="The code that identifies this filter when it is used in the instance." ) 690 protected CodeType code; 691 692 /** 693 * A description of how or why the filter is used. 694 */ 695 @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 696 @Description(shortDefinition="How or why the filter is used", formalDefinition="A description of how or why the filter is used." ) 697 protected StringType description; 698 699 /** 700 * A list of operators that can be used with the filter. 701 */ 702 @Child(name = "operator", type = {CodeType.class}, order=3, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 703 @Description(shortDefinition="Operators that can be used with filter", formalDefinition="A list of operators that can be used with the filter." ) 704 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/filter-operator") 705 protected List<Enumeration<FilterOperator>> operator; 706 707 /** 708 * A description of what the value for the filter should be. 709 */ 710 @Child(name = "value", type = {StringType.class}, order=4, min=1, max=1, modifier=false, summary=true) 711 @Description(shortDefinition="What to use for the value", formalDefinition="A description of what the value for the filter should be." ) 712 protected StringType value; 713 714 private static final long serialVersionUID = -1087409836L; 715 716 /** 717 * Constructor 718 */ 719 public CodeSystemFilterComponent() { 720 super(); 721 } 722 723 /** 724 * Constructor 725 */ 726 public CodeSystemFilterComponent(CodeType code, StringType value) { 727 super(); 728 this.code = code; 729 this.value = value; 730 } 731 732 /** 733 * @return {@link #code} (The code that identifies this filter when it is used in the instance.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 734 */ 735 public CodeType getCodeElement() { 736 if (this.code == null) 737 if (Configuration.errorOnAutoCreate()) 738 throw new Error("Attempt to auto-create CodeSystemFilterComponent.code"); 739 else if (Configuration.doAutoCreate()) 740 this.code = new CodeType(); // bb 741 return this.code; 742 } 743 744 public boolean hasCodeElement() { 745 return this.code != null && !this.code.isEmpty(); 746 } 747 748 public boolean hasCode() { 749 return this.code != null && !this.code.isEmpty(); 750 } 751 752 /** 753 * @param value {@link #code} (The code that identifies this filter when it is used in the instance.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 754 */ 755 public CodeSystemFilterComponent setCodeElement(CodeType value) { 756 this.code = value; 757 return this; 758 } 759 760 /** 761 * @return The code that identifies this filter when it is used in the instance. 762 */ 763 public String getCode() { 764 return this.code == null ? null : this.code.getValue(); 765 } 766 767 /** 768 * @param value The code that identifies this filter when it is used in the instance. 769 */ 770 public CodeSystemFilterComponent setCode(String value) { 771 if (this.code == null) 772 this.code = new CodeType(); 773 this.code.setValue(value); 774 return this; 775 } 776 777 /** 778 * @return {@link #description} (A description of how or why the filter is used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 779 */ 780 public StringType getDescriptionElement() { 781 if (this.description == null) 782 if (Configuration.errorOnAutoCreate()) 783 throw new Error("Attempt to auto-create CodeSystemFilterComponent.description"); 784 else if (Configuration.doAutoCreate()) 785 this.description = new StringType(); // bb 786 return this.description; 787 } 788 789 public boolean hasDescriptionElement() { 790 return this.description != null && !this.description.isEmpty(); 791 } 792 793 public boolean hasDescription() { 794 return this.description != null && !this.description.isEmpty(); 795 } 796 797 /** 798 * @param value {@link #description} (A description of how or why the filter is used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 799 */ 800 public CodeSystemFilterComponent setDescriptionElement(StringType value) { 801 this.description = value; 802 return this; 803 } 804 805 /** 806 * @return A description of how or why the filter is used. 807 */ 808 public String getDescription() { 809 return this.description == null ? null : this.description.getValue(); 810 } 811 812 /** 813 * @param value A description of how or why the filter is used. 814 */ 815 public CodeSystemFilterComponent setDescription(String value) { 816 if (Utilities.noString(value)) 817 this.description = null; 818 else { 819 if (this.description == null) 820 this.description = new StringType(); 821 this.description.setValue(value); 822 } 823 return this; 824 } 825 826 /** 827 * @return {@link #operator} (A list of operators that can be used with the filter.) 828 */ 829 public List<Enumeration<FilterOperator>> getOperator() { 830 if (this.operator == null) 831 this.operator = new ArrayList<Enumeration<FilterOperator>>(); 832 return this.operator; 833 } 834 835 /** 836 * @return Returns a reference to <code>this</code> for easy method chaining 837 */ 838 public CodeSystemFilterComponent setOperator(List<Enumeration<FilterOperator>> theOperator) { 839 this.operator = theOperator; 840 return this; 841 } 842 843 public boolean hasOperator() { 844 if (this.operator == null) 845 return false; 846 for (Enumeration<FilterOperator> item : this.operator) 847 if (!item.isEmpty()) 848 return true; 849 return false; 850 } 851 852 /** 853 * @return {@link #operator} (A list of operators that can be used with the filter.) 854 */ 855 public Enumeration<FilterOperator> addOperatorElement() {//2 856 Enumeration<FilterOperator> t = new Enumeration<FilterOperator>(new FilterOperatorEnumFactory()); 857 if (this.operator == null) 858 this.operator = new ArrayList<Enumeration<FilterOperator>>(); 859 this.operator.add(t); 860 return t; 861 } 862 863 /** 864 * @param value {@link #operator} (A list of operators that can be used with the filter.) 865 */ 866 public CodeSystemFilterComponent addOperator(FilterOperator value) { //1 867 Enumeration<FilterOperator> t = new Enumeration<FilterOperator>(new FilterOperatorEnumFactory()); 868 t.setValue(value); 869 if (this.operator == null) 870 this.operator = new ArrayList<Enumeration<FilterOperator>>(); 871 this.operator.add(t); 872 return this; 873 } 874 875 /** 876 * @param value {@link #operator} (A list of operators that can be used with the filter.) 877 */ 878 public boolean hasOperator(FilterOperator value) { 879 if (this.operator == null) 880 return false; 881 for (Enumeration<FilterOperator> v : this.operator) 882 if (v.getValue().equals(value)) // code 883 return true; 884 return false; 885 } 886 887 /** 888 * @return {@link #value} (A description of what the value for the filter should be.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value 889 */ 890 public StringType getValueElement() { 891 if (this.value == null) 892 if (Configuration.errorOnAutoCreate()) 893 throw new Error("Attempt to auto-create CodeSystemFilterComponent.value"); 894 else if (Configuration.doAutoCreate()) 895 this.value = new StringType(); // bb 896 return this.value; 897 } 898 899 public boolean hasValueElement() { 900 return this.value != null && !this.value.isEmpty(); 901 } 902 903 public boolean hasValue() { 904 return this.value != null && !this.value.isEmpty(); 905 } 906 907 /** 908 * @param value {@link #value} (A description of what the value for the filter should be.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value 909 */ 910 public CodeSystemFilterComponent setValueElement(StringType value) { 911 this.value = value; 912 return this; 913 } 914 915 /** 916 * @return A description of what the value for the filter should be. 917 */ 918 public String getValue() { 919 return this.value == null ? null : this.value.getValue(); 920 } 921 922 /** 923 * @param value A description of what the value for the filter should be. 924 */ 925 public CodeSystemFilterComponent setValue(String value) { 926 if (this.value == null) 927 this.value = new StringType(); 928 this.value.setValue(value); 929 return this; 930 } 931 932 protected void listChildren(List<Property> children) { 933 super.listChildren(children); 934 children.add(new Property("code", "code", "The code that identifies this filter when it is used in the instance.", 0, 1, code)); 935 children.add(new Property("description", "string", "A description of how or why the filter is used.", 0, 1, description)); 936 children.add(new Property("operator", "code", "A list of operators that can be used with the filter.", 0, java.lang.Integer.MAX_VALUE, operator)); 937 children.add(new Property("value", "string", "A description of what the value for the filter should be.", 0, 1, value)); 938 } 939 940 @Override 941 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 942 switch (_hash) { 943 case 3059181: /*code*/ return new Property("code", "code", "The code that identifies this filter when it is used in the instance.", 0, 1, code); 944 case -1724546052: /*description*/ return new Property("description", "string", "A description of how or why the filter is used.", 0, 1, description); 945 case -500553564: /*operator*/ return new Property("operator", "code", "A list of operators that can be used with the filter.", 0, java.lang.Integer.MAX_VALUE, operator); 946 case 111972721: /*value*/ return new Property("value", "string", "A description of what the value for the filter should be.", 0, 1, value); 947 default: return super.getNamedProperty(_hash, _name, _checkValid); 948 } 949 950 } 951 952 @Override 953 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 954 switch (hash) { 955 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType 956 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 957 case -500553564: /*operator*/ return this.operator == null ? new Base[0] : this.operator.toArray(new Base[this.operator.size()]); // Enumeration<FilterOperator> 958 case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // StringType 959 default: return super.getProperty(hash, name, checkValid); 960 } 961 962 } 963 964 @Override 965 public Base setProperty(int hash, String name, Base value) throws FHIRException { 966 switch (hash) { 967 case 3059181: // code 968 this.code = castToCode(value); // CodeType 969 return value; 970 case -1724546052: // description 971 this.description = castToString(value); // StringType 972 return value; 973 case -500553564: // operator 974 value = new FilterOperatorEnumFactory().fromType(castToCode(value)); 975 this.getOperator().add((Enumeration) value); // Enumeration<FilterOperator> 976 return value; 977 case 111972721: // value 978 this.value = castToString(value); // StringType 979 return value; 980 default: return super.setProperty(hash, name, value); 981 } 982 983 } 984 985 @Override 986 public Base setProperty(String name, Base value) throws FHIRException { 987 if (name.equals("code")) { 988 this.code = castToCode(value); // CodeType 989 } else if (name.equals("description")) { 990 this.description = castToString(value); // StringType 991 } else if (name.equals("operator")) { 992 value = new FilterOperatorEnumFactory().fromType(castToCode(value)); 993 this.getOperator().add((Enumeration) value); 994 } else if (name.equals("value")) { 995 this.value = castToString(value); // StringType 996 } else 997 return super.setProperty(name, value); 998 return value; 999 } 1000 1001 @Override 1002 public Base makeProperty(int hash, String name) throws FHIRException { 1003 switch (hash) { 1004 case 3059181: return getCodeElement(); 1005 case -1724546052: return getDescriptionElement(); 1006 case -500553564: return addOperatorElement(); 1007 case 111972721: return getValueElement(); 1008 default: return super.makeProperty(hash, name); 1009 } 1010 1011 } 1012 1013 @Override 1014 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1015 switch (hash) { 1016 case 3059181: /*code*/ return new String[] {"code"}; 1017 case -1724546052: /*description*/ return new String[] {"string"}; 1018 case -500553564: /*operator*/ return new String[] {"code"}; 1019 case 111972721: /*value*/ return new String[] {"string"}; 1020 default: return super.getTypesForProperty(hash, name); 1021 } 1022 1023 } 1024 1025 @Override 1026 public Base addChild(String name) throws FHIRException { 1027 if (name.equals("code")) { 1028 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.code"); 1029 } 1030 else if (name.equals("description")) { 1031 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.description"); 1032 } 1033 else if (name.equals("operator")) { 1034 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.operator"); 1035 } 1036 else if (name.equals("value")) { 1037 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.value"); 1038 } 1039 else 1040 return super.addChild(name); 1041 } 1042 1043 public CodeSystemFilterComponent copy() { 1044 CodeSystemFilterComponent dst = new CodeSystemFilterComponent(); 1045 copyValues(dst); 1046 dst.code = code == null ? null : code.copy(); 1047 dst.description = description == null ? null : description.copy(); 1048 if (operator != null) { 1049 dst.operator = new ArrayList<Enumeration<FilterOperator>>(); 1050 for (Enumeration<FilterOperator> i : operator) 1051 dst.operator.add(i.copy()); 1052 }; 1053 dst.value = value == null ? null : value.copy(); 1054 return dst; 1055 } 1056 1057 @Override 1058 public boolean equalsDeep(Base other_) { 1059 if (!super.equalsDeep(other_)) 1060 return false; 1061 if (!(other_ instanceof CodeSystemFilterComponent)) 1062 return false; 1063 CodeSystemFilterComponent o = (CodeSystemFilterComponent) other_; 1064 return compareDeep(code, o.code, true) && compareDeep(description, o.description, true) && compareDeep(operator, o.operator, true) 1065 && compareDeep(value, o.value, true); 1066 } 1067 1068 @Override 1069 public boolean equalsShallow(Base other_) { 1070 if (!super.equalsShallow(other_)) 1071 return false; 1072 if (!(other_ instanceof CodeSystemFilterComponent)) 1073 return false; 1074 CodeSystemFilterComponent o = (CodeSystemFilterComponent) other_; 1075 return compareValues(code, o.code, true) && compareValues(description, o.description, true) && compareValues(operator, o.operator, true) 1076 && compareValues(value, o.value, true); 1077 } 1078 1079 public boolean isEmpty() { 1080 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, description, operator 1081 , value); 1082 } 1083 1084 public String fhirType() { 1085 return "CodeSystem.filter"; 1086 1087 } 1088 1089 } 1090 1091 @Block() 1092 public static class PropertyComponent extends BackboneElement implements IBaseBackboneElement { 1093 /** 1094 * A code that is used to identify the property. The code is used internally (in CodeSystem.concept.property.code) and also externally, such as in property filters. 1095 */ 1096 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1097 @Description(shortDefinition="Identifies the property on the concepts, and when referred to in operations", formalDefinition="A code that is used to identify the property. The code is used internally (in CodeSystem.concept.property.code) and also externally, such as in property filters." ) 1098 protected CodeType code; 1099 1100 /** 1101 * Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system. 1102 */ 1103 @Child(name = "uri", type = {UriType.class}, order=2, min=0, max=1, modifier=false, summary=true) 1104 @Description(shortDefinition="Formal identifier for the property", formalDefinition="Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system." ) 1105 protected UriType uri; 1106 1107 /** 1108 * A description of the property- why it is defined, and how its value might be used. 1109 */ 1110 @Child(name = "description", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true) 1111 @Description(shortDefinition="Why the property is defined, and/or what it conveys", formalDefinition="A description of the property- why it is defined, and how its value might be used." ) 1112 protected StringType description; 1113 1114 /** 1115 * The type of the property value. Properties of type "code" contain a code defined by the code system (e.g. a reference to anotherr defined concept). 1116 */ 1117 @Child(name = "type", type = {CodeType.class}, order=4, min=1, max=1, modifier=false, summary=true) 1118 @Description(shortDefinition="code | Coding | string | integer | boolean | dateTime", formalDefinition="The type of the property value. Properties of type \"code\" contain a code defined by the code system (e.g. a reference to anotherr defined concept)." ) 1119 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/concept-property-type") 1120 protected Enumeration<PropertyType> type; 1121 1122 private static final long serialVersionUID = -1810713373L; 1123 1124 /** 1125 * Constructor 1126 */ 1127 public PropertyComponent() { 1128 super(); 1129 } 1130 1131 /** 1132 * Constructor 1133 */ 1134 public PropertyComponent(CodeType code, Enumeration<PropertyType> type) { 1135 super(); 1136 this.code = code; 1137 this.type = type; 1138 } 1139 1140 /** 1141 * @return {@link #code} (A code that is used to identify the property. The code is used internally (in CodeSystem.concept.property.code) and also externally, such as in property filters.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 1142 */ 1143 public CodeType getCodeElement() { 1144 if (this.code == null) 1145 if (Configuration.errorOnAutoCreate()) 1146 throw new Error("Attempt to auto-create PropertyComponent.code"); 1147 else if (Configuration.doAutoCreate()) 1148 this.code = new CodeType(); // bb 1149 return this.code; 1150 } 1151 1152 public boolean hasCodeElement() { 1153 return this.code != null && !this.code.isEmpty(); 1154 } 1155 1156 public boolean hasCode() { 1157 return this.code != null && !this.code.isEmpty(); 1158 } 1159 1160 /** 1161 * @param value {@link #code} (A code that is used to identify the property. The code is used internally (in CodeSystem.concept.property.code) and also externally, such as in property filters.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 1162 */ 1163 public PropertyComponent setCodeElement(CodeType value) { 1164 this.code = value; 1165 return this; 1166 } 1167 1168 /** 1169 * @return A code that is used to identify the property. The code is used internally (in CodeSystem.concept.property.code) and also externally, such as in property filters. 1170 */ 1171 public String getCode() { 1172 return this.code == null ? null : this.code.getValue(); 1173 } 1174 1175 /** 1176 * @param value A code that is used to identify the property. The code is used internally (in CodeSystem.concept.property.code) and also externally, such as in property filters. 1177 */ 1178 public PropertyComponent setCode(String value) { 1179 if (this.code == null) 1180 this.code = new CodeType(); 1181 this.code.setValue(value); 1182 return this; 1183 } 1184 1185 /** 1186 * @return {@link #uri} (Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system.). This is the underlying object with id, value and extensions. The accessor "getUri" gives direct access to the value 1187 */ 1188 public UriType getUriElement() { 1189 if (this.uri == null) 1190 if (Configuration.errorOnAutoCreate()) 1191 throw new Error("Attempt to auto-create PropertyComponent.uri"); 1192 else if (Configuration.doAutoCreate()) 1193 this.uri = new UriType(); // bb 1194 return this.uri; 1195 } 1196 1197 public boolean hasUriElement() { 1198 return this.uri != null && !this.uri.isEmpty(); 1199 } 1200 1201 public boolean hasUri() { 1202 return this.uri != null && !this.uri.isEmpty(); 1203 } 1204 1205 /** 1206 * @param value {@link #uri} (Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system.). This is the underlying object with id, value and extensions. The accessor "getUri" gives direct access to the value 1207 */ 1208 public PropertyComponent setUriElement(UriType value) { 1209 this.uri = value; 1210 return this; 1211 } 1212 1213 /** 1214 * @return Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system. 1215 */ 1216 public String getUri() { 1217 return this.uri == null ? null : this.uri.getValue(); 1218 } 1219 1220 /** 1221 * @param value Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system. 1222 */ 1223 public PropertyComponent setUri(String value) { 1224 if (Utilities.noString(value)) 1225 this.uri = null; 1226 else { 1227 if (this.uri == null) 1228 this.uri = new UriType(); 1229 this.uri.setValue(value); 1230 } 1231 return this; 1232 } 1233 1234 /** 1235 * @return {@link #description} (A description of the property- why it is defined, and how its value might be used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1236 */ 1237 public StringType getDescriptionElement() { 1238 if (this.description == null) 1239 if (Configuration.errorOnAutoCreate()) 1240 throw new Error("Attempt to auto-create PropertyComponent.description"); 1241 else if (Configuration.doAutoCreate()) 1242 this.description = new StringType(); // bb 1243 return this.description; 1244 } 1245 1246 public boolean hasDescriptionElement() { 1247 return this.description != null && !this.description.isEmpty(); 1248 } 1249 1250 public boolean hasDescription() { 1251 return this.description != null && !this.description.isEmpty(); 1252 } 1253 1254 /** 1255 * @param value {@link #description} (A description of the property- why it is defined, and how its value might be used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1256 */ 1257 public PropertyComponent setDescriptionElement(StringType value) { 1258 this.description = value; 1259 return this; 1260 } 1261 1262 /** 1263 * @return A description of the property- why it is defined, and how its value might be used. 1264 */ 1265 public String getDescription() { 1266 return this.description == null ? null : this.description.getValue(); 1267 } 1268 1269 /** 1270 * @param value A description of the property- why it is defined, and how its value might be used. 1271 */ 1272 public PropertyComponent setDescription(String value) { 1273 if (Utilities.noString(value)) 1274 this.description = null; 1275 else { 1276 if (this.description == null) 1277 this.description = new StringType(); 1278 this.description.setValue(value); 1279 } 1280 return this; 1281 } 1282 1283 /** 1284 * @return {@link #type} (The type of the property value. Properties of type "code" contain a code defined by the code system (e.g. a reference to anotherr defined concept).). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1285 */ 1286 public Enumeration<PropertyType> getTypeElement() { 1287 if (this.type == null) 1288 if (Configuration.errorOnAutoCreate()) 1289 throw new Error("Attempt to auto-create PropertyComponent.type"); 1290 else if (Configuration.doAutoCreate()) 1291 this.type = new Enumeration<PropertyType>(new PropertyTypeEnumFactory()); // bb 1292 return this.type; 1293 } 1294 1295 public boolean hasTypeElement() { 1296 return this.type != null && !this.type.isEmpty(); 1297 } 1298 1299 public boolean hasType() { 1300 return this.type != null && !this.type.isEmpty(); 1301 } 1302 1303 /** 1304 * @param value {@link #type} (The type of the property value. Properties of type "code" contain a code defined by the code system (e.g. a reference to anotherr defined concept).). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1305 */ 1306 public PropertyComponent setTypeElement(Enumeration<PropertyType> value) { 1307 this.type = value; 1308 return this; 1309 } 1310 1311 /** 1312 * @return The type of the property value. Properties of type "code" contain a code defined by the code system (e.g. a reference to anotherr defined concept). 1313 */ 1314 public PropertyType getType() { 1315 return this.type == null ? null : this.type.getValue(); 1316 } 1317 1318 /** 1319 * @param value The type of the property value. Properties of type "code" contain a code defined by the code system (e.g. a reference to anotherr defined concept). 1320 */ 1321 public PropertyComponent setType(PropertyType value) { 1322 if (this.type == null) 1323 this.type = new Enumeration<PropertyType>(new PropertyTypeEnumFactory()); 1324 this.type.setValue(value); 1325 return this; 1326 } 1327 1328 protected void listChildren(List<Property> children) { 1329 super.listChildren(children); 1330 children.add(new Property("code", "code", "A code that is used to identify the property. The code is used internally (in CodeSystem.concept.property.code) and also externally, such as in property filters.", 0, 1, code)); 1331 children.add(new Property("uri", "uri", "Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system.", 0, 1, uri)); 1332 children.add(new Property("description", "string", "A description of the property- why it is defined, and how its value might be used.", 0, 1, description)); 1333 children.add(new Property("type", "code", "The type of the property value. Properties of type \"code\" contain a code defined by the code system (e.g. a reference to anotherr defined concept).", 0, 1, type)); 1334 } 1335 1336 @Override 1337 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1338 switch (_hash) { 1339 case 3059181: /*code*/ return new Property("code", "code", "A code that is used to identify the property. The code is used internally (in CodeSystem.concept.property.code) and also externally, such as in property filters.", 0, 1, code); 1340 case 116076: /*uri*/ return new Property("uri", "uri", "Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system.", 0, 1, uri); 1341 case -1724546052: /*description*/ return new Property("description", "string", "A description of the property- why it is defined, and how its value might be used.", 0, 1, description); 1342 case 3575610: /*type*/ return new Property("type", "code", "The type of the property value. Properties of type \"code\" contain a code defined by the code system (e.g. a reference to anotherr defined concept).", 0, 1, type); 1343 default: return super.getNamedProperty(_hash, _name, _checkValid); 1344 } 1345 1346 } 1347 1348 @Override 1349 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1350 switch (hash) { 1351 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType 1352 case 116076: /*uri*/ return this.uri == null ? new Base[0] : new Base[] {this.uri}; // UriType 1353 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 1354 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<PropertyType> 1355 default: return super.getProperty(hash, name, checkValid); 1356 } 1357 1358 } 1359 1360 @Override 1361 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1362 switch (hash) { 1363 case 3059181: // code 1364 this.code = castToCode(value); // CodeType 1365 return value; 1366 case 116076: // uri 1367 this.uri = castToUri(value); // UriType 1368 return value; 1369 case -1724546052: // description 1370 this.description = castToString(value); // StringType 1371 return value; 1372 case 3575610: // type 1373 value = new PropertyTypeEnumFactory().fromType(castToCode(value)); 1374 this.type = (Enumeration) value; // Enumeration<PropertyType> 1375 return value; 1376 default: return super.setProperty(hash, name, value); 1377 } 1378 1379 } 1380 1381 @Override 1382 public Base setProperty(String name, Base value) throws FHIRException { 1383 if (name.equals("code")) { 1384 this.code = castToCode(value); // CodeType 1385 } else if (name.equals("uri")) { 1386 this.uri = castToUri(value); // UriType 1387 } else if (name.equals("description")) { 1388 this.description = castToString(value); // StringType 1389 } else if (name.equals("type")) { 1390 value = new PropertyTypeEnumFactory().fromType(castToCode(value)); 1391 this.type = (Enumeration) value; // Enumeration<PropertyType> 1392 } else 1393 return super.setProperty(name, value); 1394 return value; 1395 } 1396 1397 @Override 1398 public Base makeProperty(int hash, String name) throws FHIRException { 1399 switch (hash) { 1400 case 3059181: return getCodeElement(); 1401 case 116076: return getUriElement(); 1402 case -1724546052: return getDescriptionElement(); 1403 case 3575610: return getTypeElement(); 1404 default: return super.makeProperty(hash, name); 1405 } 1406 1407 } 1408 1409 @Override 1410 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1411 switch (hash) { 1412 case 3059181: /*code*/ return new String[] {"code"}; 1413 case 116076: /*uri*/ return new String[] {"uri"}; 1414 case -1724546052: /*description*/ return new String[] {"string"}; 1415 case 3575610: /*type*/ return new String[] {"code"}; 1416 default: return super.getTypesForProperty(hash, name); 1417 } 1418 1419 } 1420 1421 @Override 1422 public Base addChild(String name) throws FHIRException { 1423 if (name.equals("code")) { 1424 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.code"); 1425 } 1426 else if (name.equals("uri")) { 1427 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.uri"); 1428 } 1429 else if (name.equals("description")) { 1430 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.description"); 1431 } 1432 else if (name.equals("type")) { 1433 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.type"); 1434 } 1435 else 1436 return super.addChild(name); 1437 } 1438 1439 public PropertyComponent copy() { 1440 PropertyComponent dst = new PropertyComponent(); 1441 copyValues(dst); 1442 dst.code = code == null ? null : code.copy(); 1443 dst.uri = uri == null ? null : uri.copy(); 1444 dst.description = description == null ? null : description.copy(); 1445 dst.type = type == null ? null : type.copy(); 1446 return dst; 1447 } 1448 1449 @Override 1450 public boolean equalsDeep(Base other_) { 1451 if (!super.equalsDeep(other_)) 1452 return false; 1453 if (!(other_ instanceof PropertyComponent)) 1454 return false; 1455 PropertyComponent o = (PropertyComponent) other_; 1456 return compareDeep(code, o.code, true) && compareDeep(uri, o.uri, true) && compareDeep(description, o.description, true) 1457 && compareDeep(type, o.type, true); 1458 } 1459 1460 @Override 1461 public boolean equalsShallow(Base other_) { 1462 if (!super.equalsShallow(other_)) 1463 return false; 1464 if (!(other_ instanceof PropertyComponent)) 1465 return false; 1466 PropertyComponent o = (PropertyComponent) other_; 1467 return compareValues(code, o.code, true) && compareValues(uri, o.uri, true) && compareValues(description, o.description, true) 1468 && compareValues(type, o.type, true); 1469 } 1470 1471 public boolean isEmpty() { 1472 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, uri, description, type 1473 ); 1474 } 1475 1476 public String fhirType() { 1477 return "CodeSystem.property"; 1478 1479 } 1480 1481 } 1482 1483 @Block() 1484 public static class ConceptDefinitionComponent extends BackboneElement implements IBaseBackboneElement { 1485 /** 1486 * A code - a text symbol - that uniquely identifies the concept within the code system. 1487 */ 1488 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 1489 @Description(shortDefinition="Code that identifies concept", formalDefinition="A code - a text symbol - that uniquely identifies the concept within the code system." ) 1490 protected CodeType code; 1491 1492 /** 1493 * A human readable string that is the recommended default way to present this concept to a user. 1494 */ 1495 @Child(name = "display", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false) 1496 @Description(shortDefinition="Text to display to the user", formalDefinition="A human readable string that is the recommended default way to present this concept to a user." ) 1497 protected StringType display; 1498 1499 /** 1500 * The formal definition of the concept. The code system resource does not make formal definitions required, because of the prevalence of legacy systems. However, they are highly recommended, as without them there is no formal meaning associated with the concept. 1501 */ 1502 @Child(name = "definition", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false) 1503 @Description(shortDefinition="Formal definition", formalDefinition="The formal definition of the concept. The code system resource does not make formal definitions required, because of the prevalence of legacy systems. However, they are highly recommended, as without them there is no formal meaning associated with the concept." ) 1504 protected StringType definition; 1505 1506 /** 1507 * Additional representations for the concept - other languages, aliases, specialized purposes, used for particular purposes, etc. 1508 */ 1509 @Child(name = "designation", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1510 @Description(shortDefinition="Additional representations for the concept", formalDefinition="Additional representations for the concept - other languages, aliases, specialized purposes, used for particular purposes, etc." ) 1511 protected List<ConceptDefinitionDesignationComponent> designation; 1512 1513 /** 1514 * A property value for this concept. 1515 */ 1516 @Child(name = "property", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1517 @Description(shortDefinition="Property value for the concept", formalDefinition="A property value for this concept." ) 1518 protected List<ConceptPropertyComponent> property; 1519 1520 /** 1521 * Defines children of a concept to produce a hierarchy of concepts. The nature of the relationships is variable (is-a/contains/categorizes) - see hierarchyMeaning. 1522 */ 1523 @Child(name = "concept", type = {ConceptDefinitionComponent.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1524 @Description(shortDefinition="Child Concepts (is-a/contains/categorizes)", formalDefinition="Defines children of a concept to produce a hierarchy of concepts. The nature of the relationships is variable (is-a/contains/categorizes) - see hierarchyMeaning." ) 1525 protected List<ConceptDefinitionComponent> concept; 1526 1527 private static final long serialVersionUID = 878320988L; 1528 1529 /** 1530 * Constructor 1531 */ 1532 public ConceptDefinitionComponent() { 1533 super(); 1534 } 1535 1536 /** 1537 * Constructor 1538 */ 1539 public ConceptDefinitionComponent(CodeType code) { 1540 super(); 1541 this.code = code; 1542 } 1543 1544 /** 1545 * @return {@link #code} (A code - a text symbol - that uniquely identifies the concept within the code system.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 1546 */ 1547 public CodeType getCodeElement() { 1548 if (this.code == null) 1549 if (Configuration.errorOnAutoCreate()) 1550 throw new Error("Attempt to auto-create ConceptDefinitionComponent.code"); 1551 else if (Configuration.doAutoCreate()) 1552 this.code = new CodeType(); // bb 1553 return this.code; 1554 } 1555 1556 public boolean hasCodeElement() { 1557 return this.code != null && !this.code.isEmpty(); 1558 } 1559 1560 public boolean hasCode() { 1561 return this.code != null && !this.code.isEmpty(); 1562 } 1563 1564 /** 1565 * @param value {@link #code} (A code - a text symbol - that uniquely identifies the concept within the code system.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 1566 */ 1567 public ConceptDefinitionComponent setCodeElement(CodeType value) { 1568 this.code = value; 1569 return this; 1570 } 1571 1572 /** 1573 * @return A code - a text symbol - that uniquely identifies the concept within the code system. 1574 */ 1575 public String getCode() { 1576 return this.code == null ? null : this.code.getValue(); 1577 } 1578 1579 /** 1580 * @param value A code - a text symbol - that uniquely identifies the concept within the code system. 1581 */ 1582 public ConceptDefinitionComponent setCode(String value) { 1583 if (this.code == null) 1584 this.code = new CodeType(); 1585 this.code.setValue(value); 1586 return this; 1587 } 1588 1589 /** 1590 * @return {@link #display} (A human readable string that is the recommended default way to present this concept to a user.). This is the underlying object with id, value and extensions. The accessor "getDisplay" gives direct access to the value 1591 */ 1592 public StringType getDisplayElement() { 1593 if (this.display == null) 1594 if (Configuration.errorOnAutoCreate()) 1595 throw new Error("Attempt to auto-create ConceptDefinitionComponent.display"); 1596 else if (Configuration.doAutoCreate()) 1597 this.display = new StringType(); // bb 1598 return this.display; 1599 } 1600 1601 public boolean hasDisplayElement() { 1602 return this.display != null && !this.display.isEmpty(); 1603 } 1604 1605 public boolean hasDisplay() { 1606 return this.display != null && !this.display.isEmpty(); 1607 } 1608 1609 /** 1610 * @param value {@link #display} (A human readable string that is the recommended default way to present this concept to a user.). This is the underlying object with id, value and extensions. The accessor "getDisplay" gives direct access to the value 1611 */ 1612 public ConceptDefinitionComponent setDisplayElement(StringType value) { 1613 this.display = value; 1614 return this; 1615 } 1616 1617 /** 1618 * @return A human readable string that is the recommended default way to present this concept to a user. 1619 */ 1620 public String getDisplay() { 1621 return this.display == null ? null : this.display.getValue(); 1622 } 1623 1624 /** 1625 * @param value A human readable string that is the recommended default way to present this concept to a user. 1626 */ 1627 public ConceptDefinitionComponent setDisplay(String value) { 1628 if (Utilities.noString(value)) 1629 this.display = null; 1630 else { 1631 if (this.display == null) 1632 this.display = new StringType(); 1633 this.display.setValue(value); 1634 } 1635 return this; 1636 } 1637 1638 /** 1639 * @return {@link #definition} (The formal definition of the concept. The code system resource does not make formal definitions required, because of the prevalence of legacy systems. However, they are highly recommended, as without them there is no formal meaning associated with the concept.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 1640 */ 1641 public StringType getDefinitionElement() { 1642 if (this.definition == null) 1643 if (Configuration.errorOnAutoCreate()) 1644 throw new Error("Attempt to auto-create ConceptDefinitionComponent.definition"); 1645 else if (Configuration.doAutoCreate()) 1646 this.definition = new StringType(); // bb 1647 return this.definition; 1648 } 1649 1650 public boolean hasDefinitionElement() { 1651 return this.definition != null && !this.definition.isEmpty(); 1652 } 1653 1654 public boolean hasDefinition() { 1655 return this.definition != null && !this.definition.isEmpty(); 1656 } 1657 1658 /** 1659 * @param value {@link #definition} (The formal definition of the concept. The code system resource does not make formal definitions required, because of the prevalence of legacy systems. However, they are highly recommended, as without them there is no formal meaning associated with the concept.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 1660 */ 1661 public ConceptDefinitionComponent setDefinitionElement(StringType value) { 1662 this.definition = value; 1663 return this; 1664 } 1665 1666 /** 1667 * @return The formal definition of the concept. The code system resource does not make formal definitions required, because of the prevalence of legacy systems. However, they are highly recommended, as without them there is no formal meaning associated with the concept. 1668 */ 1669 public String getDefinition() { 1670 return this.definition == null ? null : this.definition.getValue(); 1671 } 1672 1673 /** 1674 * @param value The formal definition of the concept. The code system resource does not make formal definitions required, because of the prevalence of legacy systems. However, they are highly recommended, as without them there is no formal meaning associated with the concept. 1675 */ 1676 public ConceptDefinitionComponent setDefinition(String value) { 1677 if (Utilities.noString(value)) 1678 this.definition = null; 1679 else { 1680 if (this.definition == null) 1681 this.definition = new StringType(); 1682 this.definition.setValue(value); 1683 } 1684 return this; 1685 } 1686 1687 /** 1688 * @return {@link #designation} (Additional representations for the concept - other languages, aliases, specialized purposes, used for particular purposes, etc.) 1689 */ 1690 public List<ConceptDefinitionDesignationComponent> getDesignation() { 1691 if (this.designation == null) 1692 this.designation = new ArrayList<ConceptDefinitionDesignationComponent>(); 1693 return this.designation; 1694 } 1695 1696 /** 1697 * @return Returns a reference to <code>this</code> for easy method chaining 1698 */ 1699 public ConceptDefinitionComponent setDesignation(List<ConceptDefinitionDesignationComponent> theDesignation) { 1700 this.designation = theDesignation; 1701 return this; 1702 } 1703 1704 public boolean hasDesignation() { 1705 if (this.designation == null) 1706 return false; 1707 for (ConceptDefinitionDesignationComponent item : this.designation) 1708 if (!item.isEmpty()) 1709 return true; 1710 return false; 1711 } 1712 1713 public ConceptDefinitionDesignationComponent addDesignation() { //3 1714 ConceptDefinitionDesignationComponent t = new ConceptDefinitionDesignationComponent(); 1715 if (this.designation == null) 1716 this.designation = new ArrayList<ConceptDefinitionDesignationComponent>(); 1717 this.designation.add(t); 1718 return t; 1719 } 1720 1721 public ConceptDefinitionComponent addDesignation(ConceptDefinitionDesignationComponent t) { //3 1722 if (t == null) 1723 return this; 1724 if (this.designation == null) 1725 this.designation = new ArrayList<ConceptDefinitionDesignationComponent>(); 1726 this.designation.add(t); 1727 return this; 1728 } 1729 1730 /** 1731 * @return The first repetition of repeating field {@link #designation}, creating it if it does not already exist 1732 */ 1733 public ConceptDefinitionDesignationComponent getDesignationFirstRep() { 1734 if (getDesignation().isEmpty()) { 1735 addDesignation(); 1736 } 1737 return getDesignation().get(0); 1738 } 1739 1740 /** 1741 * @return {@link #property} (A property value for this concept.) 1742 */ 1743 public List<ConceptPropertyComponent> getProperty() { 1744 if (this.property == null) 1745 this.property = new ArrayList<ConceptPropertyComponent>(); 1746 return this.property; 1747 } 1748 1749 /** 1750 * @return Returns a reference to <code>this</code> for easy method chaining 1751 */ 1752 public ConceptDefinitionComponent setProperty(List<ConceptPropertyComponent> theProperty) { 1753 this.property = theProperty; 1754 return this; 1755 } 1756 1757 public boolean hasProperty() { 1758 if (this.property == null) 1759 return false; 1760 for (ConceptPropertyComponent item : this.property) 1761 if (!item.isEmpty()) 1762 return true; 1763 return false; 1764 } 1765 1766 public ConceptPropertyComponent addProperty() { //3 1767 ConceptPropertyComponent t = new ConceptPropertyComponent(); 1768 if (this.property == null) 1769 this.property = new ArrayList<ConceptPropertyComponent>(); 1770 this.property.add(t); 1771 return t; 1772 } 1773 1774 public ConceptDefinitionComponent addProperty(ConceptPropertyComponent t) { //3 1775 if (t == null) 1776 return this; 1777 if (this.property == null) 1778 this.property = new ArrayList<ConceptPropertyComponent>(); 1779 this.property.add(t); 1780 return this; 1781 } 1782 1783 /** 1784 * @return The first repetition of repeating field {@link #property}, creating it if it does not already exist 1785 */ 1786 public ConceptPropertyComponent getPropertyFirstRep() { 1787 if (getProperty().isEmpty()) { 1788 addProperty(); 1789 } 1790 return getProperty().get(0); 1791 } 1792 1793 /** 1794 * @return {@link #concept} (Defines children of a concept to produce a hierarchy of concepts. The nature of the relationships is variable (is-a/contains/categorizes) - see hierarchyMeaning.) 1795 */ 1796 public List<ConceptDefinitionComponent> getConcept() { 1797 if (this.concept == null) 1798 this.concept = new ArrayList<ConceptDefinitionComponent>(); 1799 return this.concept; 1800 } 1801 1802 /** 1803 * @return Returns a reference to <code>this</code> for easy method chaining 1804 */ 1805 public ConceptDefinitionComponent setConcept(List<ConceptDefinitionComponent> theConcept) { 1806 this.concept = theConcept; 1807 return this; 1808 } 1809 1810 public boolean hasConcept() { 1811 if (this.concept == null) 1812 return false; 1813 for (ConceptDefinitionComponent item : this.concept) 1814 if (!item.isEmpty()) 1815 return true; 1816 return false; 1817 } 1818 1819 public ConceptDefinitionComponent addConcept() { //3 1820 ConceptDefinitionComponent t = new ConceptDefinitionComponent(); 1821 if (this.concept == null) 1822 this.concept = new ArrayList<ConceptDefinitionComponent>(); 1823 this.concept.add(t); 1824 return t; 1825 } 1826 1827 public ConceptDefinitionComponent addConcept(ConceptDefinitionComponent t) { //3 1828 if (t == null) 1829 return this; 1830 if (this.concept == null) 1831 this.concept = new ArrayList<ConceptDefinitionComponent>(); 1832 this.concept.add(t); 1833 return this; 1834 } 1835 1836 /** 1837 * @return The first repetition of repeating field {@link #concept}, creating it if it does not already exist 1838 */ 1839 public ConceptDefinitionComponent getConceptFirstRep() { 1840 if (getConcept().isEmpty()) { 1841 addConcept(); 1842 } 1843 return getConcept().get(0); 1844 } 1845 1846 protected void listChildren(List<Property> children) { 1847 super.listChildren(children); 1848 children.add(new Property("code", "code", "A code - a text symbol - that uniquely identifies the concept within the code system.", 0, 1, code)); 1849 children.add(new Property("display", "string", "A human readable string that is the recommended default way to present this concept to a user.", 0, 1, display)); 1850 children.add(new Property("definition", "string", "The formal definition of the concept. The code system resource does not make formal definitions required, because of the prevalence of legacy systems. However, they are highly recommended, as without them there is no formal meaning associated with the concept.", 0, 1, definition)); 1851 children.add(new Property("designation", "", "Additional representations for the concept - other languages, aliases, specialized purposes, used for particular purposes, etc.", 0, java.lang.Integer.MAX_VALUE, designation)); 1852 children.add(new Property("property", "", "A property value for this concept.", 0, java.lang.Integer.MAX_VALUE, property)); 1853 children.add(new Property("concept", "@CodeSystem.concept", "Defines children of a concept to produce a hierarchy of concepts. The nature of the relationships is variable (is-a/contains/categorizes) - see hierarchyMeaning.", 0, java.lang.Integer.MAX_VALUE, concept)); 1854 } 1855 1856 @Override 1857 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1858 switch (_hash) { 1859 case 3059181: /*code*/ return new Property("code", "code", "A code - a text symbol - that uniquely identifies the concept within the code system.", 0, 1, code); 1860 case 1671764162: /*display*/ return new Property("display", "string", "A human readable string that is the recommended default way to present this concept to a user.", 0, 1, display); 1861 case -1014418093: /*definition*/ return new Property("definition", "string", "The formal definition of the concept. The code system resource does not make formal definitions required, because of the prevalence of legacy systems. However, they are highly recommended, as without them there is no formal meaning associated with the concept.", 0, 1, definition); 1862 case -900931593: /*designation*/ return new Property("designation", "", "Additional representations for the concept - other languages, aliases, specialized purposes, used for particular purposes, etc.", 0, java.lang.Integer.MAX_VALUE, designation); 1863 case -993141291: /*property*/ return new Property("property", "", "A property value for this concept.", 0, java.lang.Integer.MAX_VALUE, property); 1864 case 951024232: /*concept*/ return new Property("concept", "@CodeSystem.concept", "Defines children of a concept to produce a hierarchy of concepts. The nature of the relationships is variable (is-a/contains/categorizes) - see hierarchyMeaning.", 0, java.lang.Integer.MAX_VALUE, concept); 1865 default: return super.getNamedProperty(_hash, _name, _checkValid); 1866 } 1867 1868 } 1869 1870 @Override 1871 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1872 switch (hash) { 1873 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType 1874 case 1671764162: /*display*/ return this.display == null ? new Base[0] : new Base[] {this.display}; // StringType 1875 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // StringType 1876 case -900931593: /*designation*/ return this.designation == null ? new Base[0] : this.designation.toArray(new Base[this.designation.size()]); // ConceptDefinitionDesignationComponent 1877 case -993141291: /*property*/ return this.property == null ? new Base[0] : this.property.toArray(new Base[this.property.size()]); // ConceptPropertyComponent 1878 case 951024232: /*concept*/ return this.concept == null ? new Base[0] : this.concept.toArray(new Base[this.concept.size()]); // ConceptDefinitionComponent 1879 default: return super.getProperty(hash, name, checkValid); 1880 } 1881 1882 } 1883 1884 @Override 1885 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1886 switch (hash) { 1887 case 3059181: // code 1888 this.code = castToCode(value); // CodeType 1889 return value; 1890 case 1671764162: // display 1891 this.display = castToString(value); // StringType 1892 return value; 1893 case -1014418093: // definition 1894 this.definition = castToString(value); // StringType 1895 return value; 1896 case -900931593: // designation 1897 this.getDesignation().add((ConceptDefinitionDesignationComponent) value); // ConceptDefinitionDesignationComponent 1898 return value; 1899 case -993141291: // property 1900 this.getProperty().add((ConceptPropertyComponent) value); // ConceptPropertyComponent 1901 return value; 1902 case 951024232: // concept 1903 this.getConcept().add((ConceptDefinitionComponent) value); // ConceptDefinitionComponent 1904 return value; 1905 default: return super.setProperty(hash, name, value); 1906 } 1907 1908 } 1909 1910 @Override 1911 public Base setProperty(String name, Base value) throws FHIRException { 1912 if (name.equals("code")) { 1913 this.code = castToCode(value); // CodeType 1914 } else if (name.equals("display")) { 1915 this.display = castToString(value); // StringType 1916 } else if (name.equals("definition")) { 1917 this.definition = castToString(value); // StringType 1918 } else if (name.equals("designation")) { 1919 this.getDesignation().add((ConceptDefinitionDesignationComponent) value); 1920 } else if (name.equals("property")) { 1921 this.getProperty().add((ConceptPropertyComponent) value); 1922 } else if (name.equals("concept")) { 1923 this.getConcept().add((ConceptDefinitionComponent) value); 1924 } else 1925 return super.setProperty(name, value); 1926 return value; 1927 } 1928 1929 @Override 1930 public Base makeProperty(int hash, String name) throws FHIRException { 1931 switch (hash) { 1932 case 3059181: return getCodeElement(); 1933 case 1671764162: return getDisplayElement(); 1934 case -1014418093: return getDefinitionElement(); 1935 case -900931593: return addDesignation(); 1936 case -993141291: return addProperty(); 1937 case 951024232: return addConcept(); 1938 default: return super.makeProperty(hash, name); 1939 } 1940 1941 } 1942 1943 @Override 1944 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1945 switch (hash) { 1946 case 3059181: /*code*/ return new String[] {"code"}; 1947 case 1671764162: /*display*/ return new String[] {"string"}; 1948 case -1014418093: /*definition*/ return new String[] {"string"}; 1949 case -900931593: /*designation*/ return new String[] {}; 1950 case -993141291: /*property*/ return new String[] {}; 1951 case 951024232: /*concept*/ return new String[] {"@CodeSystem.concept"}; 1952 default: return super.getTypesForProperty(hash, name); 1953 } 1954 1955 } 1956 1957 @Override 1958 public Base addChild(String name) throws FHIRException { 1959 if (name.equals("code")) { 1960 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.code"); 1961 } 1962 else if (name.equals("display")) { 1963 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.display"); 1964 } 1965 else if (name.equals("definition")) { 1966 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.definition"); 1967 } 1968 else if (name.equals("designation")) { 1969 return addDesignation(); 1970 } 1971 else if (name.equals("property")) { 1972 return addProperty(); 1973 } 1974 else if (name.equals("concept")) { 1975 return addConcept(); 1976 } 1977 else 1978 return super.addChild(name); 1979 } 1980 1981 public ConceptDefinitionComponent copy() { 1982 ConceptDefinitionComponent dst = new ConceptDefinitionComponent(); 1983 copyValues(dst); 1984 dst.code = code == null ? null : code.copy(); 1985 dst.display = display == null ? null : display.copy(); 1986 dst.definition = definition == null ? null : definition.copy(); 1987 if (designation != null) { 1988 dst.designation = new ArrayList<ConceptDefinitionDesignationComponent>(); 1989 for (ConceptDefinitionDesignationComponent i : designation) 1990 dst.designation.add(i.copy()); 1991 }; 1992 if (property != null) { 1993 dst.property = new ArrayList<ConceptPropertyComponent>(); 1994 for (ConceptPropertyComponent i : property) 1995 dst.property.add(i.copy()); 1996 }; 1997 if (concept != null) { 1998 dst.concept = new ArrayList<ConceptDefinitionComponent>(); 1999 for (ConceptDefinitionComponent i : concept) 2000 dst.concept.add(i.copy()); 2001 }; 2002 return dst; 2003 } 2004 2005 @Override 2006 public boolean equalsDeep(Base other_) { 2007 if (!super.equalsDeep(other_)) 2008 return false; 2009 if (!(other_ instanceof ConceptDefinitionComponent)) 2010 return false; 2011 ConceptDefinitionComponent o = (ConceptDefinitionComponent) other_; 2012 return compareDeep(code, o.code, true) && compareDeep(display, o.display, true) && compareDeep(definition, o.definition, true) 2013 && compareDeep(designation, o.designation, true) && compareDeep(property, o.property, true) && compareDeep(concept, o.concept, true) 2014 ; 2015 } 2016 2017 @Override 2018 public boolean equalsShallow(Base other_) { 2019 if (!super.equalsShallow(other_)) 2020 return false; 2021 if (!(other_ instanceof ConceptDefinitionComponent)) 2022 return false; 2023 ConceptDefinitionComponent o = (ConceptDefinitionComponent) other_; 2024 return compareValues(code, o.code, true) && compareValues(display, o.display, true) && compareValues(definition, o.definition, true) 2025 ; 2026 } 2027 2028 public boolean isEmpty() { 2029 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, display, definition 2030 , designation, property, concept); 2031 } 2032 2033 public String fhirType() { 2034 return "CodeSystem.concept"; 2035 2036 } 2037 2038 } 2039 2040 @Block() 2041 public static class ConceptDefinitionDesignationComponent extends BackboneElement implements IBaseBackboneElement { 2042 /** 2043 * The language this designation is defined for. 2044 */ 2045 @Child(name = "language", type = {CodeType.class}, order=1, min=0, max=1, modifier=false, summary=false) 2046 @Description(shortDefinition="Human language of the designation", formalDefinition="The language this designation is defined for." ) 2047 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/languages") 2048 protected CodeType language; 2049 2050 /** 2051 * A code that details how this designation would be used. 2052 */ 2053 @Child(name = "use", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false) 2054 @Description(shortDefinition="Details how this designation would be used", formalDefinition="A code that details how this designation would be used." ) 2055 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/designation-use") 2056 protected Coding use; 2057 2058 /** 2059 * The text value for this designation. 2060 */ 2061 @Child(name = "value", type = {StringType.class}, order=3, min=1, max=1, modifier=false, summary=false) 2062 @Description(shortDefinition="The text value for this designation", formalDefinition="The text value for this designation." ) 2063 protected StringType value; 2064 2065 private static final long serialVersionUID = 1515662414L; 2066 2067 /** 2068 * Constructor 2069 */ 2070 public ConceptDefinitionDesignationComponent() { 2071 super(); 2072 } 2073 2074 /** 2075 * Constructor 2076 */ 2077 public ConceptDefinitionDesignationComponent(StringType value) { 2078 super(); 2079 this.value = value; 2080 } 2081 2082 /** 2083 * @return {@link #language} (The language this designation is defined for.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value 2084 */ 2085 public CodeType getLanguageElement() { 2086 if (this.language == null) 2087 if (Configuration.errorOnAutoCreate()) 2088 throw new Error("Attempt to auto-create ConceptDefinitionDesignationComponent.language"); 2089 else if (Configuration.doAutoCreate()) 2090 this.language = new CodeType(); // bb 2091 return this.language; 2092 } 2093 2094 public boolean hasLanguageElement() { 2095 return this.language != null && !this.language.isEmpty(); 2096 } 2097 2098 public boolean hasLanguage() { 2099 return this.language != null && !this.language.isEmpty(); 2100 } 2101 2102 /** 2103 * @param value {@link #language} (The language this designation is defined for.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value 2104 */ 2105 public ConceptDefinitionDesignationComponent setLanguageElement(CodeType value) { 2106 this.language = value; 2107 return this; 2108 } 2109 2110 /** 2111 * @return The language this designation is defined for. 2112 */ 2113 public String getLanguage() { 2114 return this.language == null ? null : this.language.getValue(); 2115 } 2116 2117 /** 2118 * @param value The language this designation is defined for. 2119 */ 2120 public ConceptDefinitionDesignationComponent setLanguage(String value) { 2121 if (Utilities.noString(value)) 2122 this.language = null; 2123 else { 2124 if (this.language == null) 2125 this.language = new CodeType(); 2126 this.language.setValue(value); 2127 } 2128 return this; 2129 } 2130 2131 /** 2132 * @return {@link #use} (A code that details how this designation would be used.) 2133 */ 2134 public Coding getUse() { 2135 if (this.use == null) 2136 if (Configuration.errorOnAutoCreate()) 2137 throw new Error("Attempt to auto-create ConceptDefinitionDesignationComponent.use"); 2138 else if (Configuration.doAutoCreate()) 2139 this.use = new Coding(); // cc 2140 return this.use; 2141 } 2142 2143 public boolean hasUse() { 2144 return this.use != null && !this.use.isEmpty(); 2145 } 2146 2147 /** 2148 * @param value {@link #use} (A code that details how this designation would be used.) 2149 */ 2150 public ConceptDefinitionDesignationComponent setUse(Coding value) { 2151 this.use = value; 2152 return this; 2153 } 2154 2155 /** 2156 * @return {@link #value} (The text value for this designation.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value 2157 */ 2158 public StringType getValueElement() { 2159 if (this.value == null) 2160 if (Configuration.errorOnAutoCreate()) 2161 throw new Error("Attempt to auto-create ConceptDefinitionDesignationComponent.value"); 2162 else if (Configuration.doAutoCreate()) 2163 this.value = new StringType(); // bb 2164 return this.value; 2165 } 2166 2167 public boolean hasValueElement() { 2168 return this.value != null && !this.value.isEmpty(); 2169 } 2170 2171 public boolean hasValue() { 2172 return this.value != null && !this.value.isEmpty(); 2173 } 2174 2175 /** 2176 * @param value {@link #value} (The text value for this designation.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value 2177 */ 2178 public ConceptDefinitionDesignationComponent setValueElement(StringType value) { 2179 this.value = value; 2180 return this; 2181 } 2182 2183 /** 2184 * @return The text value for this designation. 2185 */ 2186 public String getValue() { 2187 return this.value == null ? null : this.value.getValue(); 2188 } 2189 2190 /** 2191 * @param value The text value for this designation. 2192 */ 2193 public ConceptDefinitionDesignationComponent setValue(String value) { 2194 if (this.value == null) 2195 this.value = new StringType(); 2196 this.value.setValue(value); 2197 return this; 2198 } 2199 2200 protected void listChildren(List<Property> children) { 2201 super.listChildren(children); 2202 children.add(new Property("language", "code", "The language this designation is defined for.", 0, 1, language)); 2203 children.add(new Property("use", "Coding", "A code that details how this designation would be used.", 0, 1, use)); 2204 children.add(new Property("value", "string", "The text value for this designation.", 0, 1, value)); 2205 } 2206 2207 @Override 2208 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2209 switch (_hash) { 2210 case -1613589672: /*language*/ return new Property("language", "code", "The language this designation is defined for.", 0, 1, language); 2211 case 116103: /*use*/ return new Property("use", "Coding", "A code that details how this designation would be used.", 0, 1, use); 2212 case 111972721: /*value*/ return new Property("value", "string", "The text value for this designation.", 0, 1, value); 2213 default: return super.getNamedProperty(_hash, _name, _checkValid); 2214 } 2215 2216 } 2217 2218 @Override 2219 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2220 switch (hash) { 2221 case -1613589672: /*language*/ return this.language == null ? new Base[0] : new Base[] {this.language}; // CodeType 2222 case 116103: /*use*/ return this.use == null ? new Base[0] : new Base[] {this.use}; // Coding 2223 case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // StringType 2224 default: return super.getProperty(hash, name, checkValid); 2225 } 2226 2227 } 2228 2229 @Override 2230 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2231 switch (hash) { 2232 case -1613589672: // language 2233 this.language = castToCode(value); // CodeType 2234 return value; 2235 case 116103: // use 2236 this.use = castToCoding(value); // Coding 2237 return value; 2238 case 111972721: // value 2239 this.value = castToString(value); // StringType 2240 return value; 2241 default: return super.setProperty(hash, name, value); 2242 } 2243 2244 } 2245 2246 @Override 2247 public Base setProperty(String name, Base value) throws FHIRException { 2248 if (name.equals("language")) { 2249 this.language = castToCode(value); // CodeType 2250 } else if (name.equals("use")) { 2251 this.use = castToCoding(value); // Coding 2252 } else if (name.equals("value")) { 2253 this.value = castToString(value); // StringType 2254 } else 2255 return super.setProperty(name, value); 2256 return value; 2257 } 2258 2259 @Override 2260 public Base makeProperty(int hash, String name) throws FHIRException { 2261 switch (hash) { 2262 case -1613589672: return getLanguageElement(); 2263 case 116103: return getUse(); 2264 case 111972721: return getValueElement(); 2265 default: return super.makeProperty(hash, name); 2266 } 2267 2268 } 2269 2270 @Override 2271 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2272 switch (hash) { 2273 case -1613589672: /*language*/ return new String[] {"code"}; 2274 case 116103: /*use*/ return new String[] {"Coding"}; 2275 case 111972721: /*value*/ return new String[] {"string"}; 2276 default: return super.getTypesForProperty(hash, name); 2277 } 2278 2279 } 2280 2281 @Override 2282 public Base addChild(String name) throws FHIRException { 2283 if (name.equals("language")) { 2284 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.language"); 2285 } 2286 else if (name.equals("use")) { 2287 this.use = new Coding(); 2288 return this.use; 2289 } 2290 else if (name.equals("value")) { 2291 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.value"); 2292 } 2293 else 2294 return super.addChild(name); 2295 } 2296 2297 public ConceptDefinitionDesignationComponent copy() { 2298 ConceptDefinitionDesignationComponent dst = new ConceptDefinitionDesignationComponent(); 2299 copyValues(dst); 2300 dst.language = language == null ? null : language.copy(); 2301 dst.use = use == null ? null : use.copy(); 2302 dst.value = value == null ? null : value.copy(); 2303 return dst; 2304 } 2305 2306 @Override 2307 public boolean equalsDeep(Base other_) { 2308 if (!super.equalsDeep(other_)) 2309 return false; 2310 if (!(other_ instanceof ConceptDefinitionDesignationComponent)) 2311 return false; 2312 ConceptDefinitionDesignationComponent o = (ConceptDefinitionDesignationComponent) other_; 2313 return compareDeep(language, o.language, true) && compareDeep(use, o.use, true) && compareDeep(value, o.value, true) 2314 ; 2315 } 2316 2317 @Override 2318 public boolean equalsShallow(Base other_) { 2319 if (!super.equalsShallow(other_)) 2320 return false; 2321 if (!(other_ instanceof ConceptDefinitionDesignationComponent)) 2322 return false; 2323 ConceptDefinitionDesignationComponent o = (ConceptDefinitionDesignationComponent) other_; 2324 return compareValues(language, o.language, true) && compareValues(value, o.value, true); 2325 } 2326 2327 public boolean isEmpty() { 2328 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(language, use, value); 2329 } 2330 2331 public String fhirType() { 2332 return "CodeSystem.concept.designation"; 2333 2334 } 2335 2336 } 2337 2338 @Block() 2339 public static class ConceptPropertyComponent extends BackboneElement implements IBaseBackboneElement { 2340 /** 2341 * A code that is a reference to CodeSystem.property.code. 2342 */ 2343 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 2344 @Description(shortDefinition="Reference to CodeSystem.property.code", formalDefinition="A code that is a reference to CodeSystem.property.code." ) 2345 protected CodeType code; 2346 2347 /** 2348 * The value of this property. 2349 */ 2350 @Child(name = "value", type = {CodeType.class, Coding.class, StringType.class, IntegerType.class, BooleanType.class, DateTimeType.class}, order=2, min=1, max=1, modifier=false, summary=false) 2351 @Description(shortDefinition="Value of the property for this concept", formalDefinition="The value of this property." ) 2352 protected Type value; 2353 2354 private static final long serialVersionUID = 1742812311L; 2355 2356 /** 2357 * Constructor 2358 */ 2359 public ConceptPropertyComponent() { 2360 super(); 2361 } 2362 2363 /** 2364 * Constructor 2365 */ 2366 public ConceptPropertyComponent(CodeType code, Type value) { 2367 super(); 2368 this.code = code; 2369 this.value = value; 2370 } 2371 2372 /** 2373 * @return {@link #code} (A code that is a reference to CodeSystem.property.code.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 2374 */ 2375 public CodeType getCodeElement() { 2376 if (this.code == null) 2377 if (Configuration.errorOnAutoCreate()) 2378 throw new Error("Attempt to auto-create ConceptPropertyComponent.code"); 2379 else if (Configuration.doAutoCreate()) 2380 this.code = new CodeType(); // bb 2381 return this.code; 2382 } 2383 2384 public boolean hasCodeElement() { 2385 return this.code != null && !this.code.isEmpty(); 2386 } 2387 2388 public boolean hasCode() { 2389 return this.code != null && !this.code.isEmpty(); 2390 } 2391 2392 /** 2393 * @param value {@link #code} (A code that is a reference to CodeSystem.property.code.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 2394 */ 2395 public ConceptPropertyComponent setCodeElement(CodeType value) { 2396 this.code = value; 2397 return this; 2398 } 2399 2400 /** 2401 * @return A code that is a reference to CodeSystem.property.code. 2402 */ 2403 public String getCode() { 2404 return this.code == null ? null : this.code.getValue(); 2405 } 2406 2407 /** 2408 * @param value A code that is a reference to CodeSystem.property.code. 2409 */ 2410 public ConceptPropertyComponent setCode(String value) { 2411 if (this.code == null) 2412 this.code = new CodeType(); 2413 this.code.setValue(value); 2414 return this; 2415 } 2416 2417 /** 2418 * @return {@link #value} (The value of this property.) 2419 */ 2420 public Type getValue() { 2421 return this.value; 2422 } 2423 2424 /** 2425 * @return {@link #value} (The value of this property.) 2426 */ 2427 public CodeType getValueCodeType() throws FHIRException { 2428 if (this.value == null) 2429 return null; 2430 if (!(this.value instanceof CodeType)) 2431 throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.value.getClass().getName()+" was encountered"); 2432 return (CodeType) this.value; 2433 } 2434 2435 public boolean hasValueCodeType() { 2436 return this != null && this.value instanceof CodeType; 2437 } 2438 2439 /** 2440 * @return {@link #value} (The value of this property.) 2441 */ 2442 public Coding getValueCoding() throws FHIRException { 2443 if (this.value == null) 2444 return null; 2445 if (!(this.value instanceof Coding)) 2446 throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.value.getClass().getName()+" was encountered"); 2447 return (Coding) this.value; 2448 } 2449 2450 public boolean hasValueCoding() { 2451 return this != null && this.value instanceof Coding; 2452 } 2453 2454 /** 2455 * @return {@link #value} (The value of this property.) 2456 */ 2457 public StringType getValueStringType() throws FHIRException { 2458 if (this.value == null) 2459 return null; 2460 if (!(this.value instanceof StringType)) 2461 throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.value.getClass().getName()+" was encountered"); 2462 return (StringType) this.value; 2463 } 2464 2465 public boolean hasValueStringType() { 2466 return this != null && this.value instanceof StringType; 2467 } 2468 2469 /** 2470 * @return {@link #value} (The value of this property.) 2471 */ 2472 public IntegerType getValueIntegerType() throws FHIRException { 2473 if (this.value == null) 2474 return null; 2475 if (!(this.value instanceof IntegerType)) 2476 throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.value.getClass().getName()+" was encountered"); 2477 return (IntegerType) this.value; 2478 } 2479 2480 public boolean hasValueIntegerType() { 2481 return this != null && this.value instanceof IntegerType; 2482 } 2483 2484 /** 2485 * @return {@link #value} (The value of this property.) 2486 */ 2487 public BooleanType getValueBooleanType() throws FHIRException { 2488 if (this.value == null) 2489 return null; 2490 if (!(this.value instanceof BooleanType)) 2491 throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.value.getClass().getName()+" was encountered"); 2492 return (BooleanType) this.value; 2493 } 2494 2495 public boolean hasValueBooleanType() { 2496 return this != null && this.value instanceof BooleanType; 2497 } 2498 2499 /** 2500 * @return {@link #value} (The value of this property.) 2501 */ 2502 public DateTimeType getValueDateTimeType() throws FHIRException { 2503 if (this.value == null) 2504 return null; 2505 if (!(this.value instanceof DateTimeType)) 2506 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.value.getClass().getName()+" was encountered"); 2507 return (DateTimeType) this.value; 2508 } 2509 2510 public boolean hasValueDateTimeType() { 2511 return this != null && this.value instanceof DateTimeType; 2512 } 2513 2514 public boolean hasValue() { 2515 return this.value != null && !this.value.isEmpty(); 2516 } 2517 2518 /** 2519 * @param value {@link #value} (The value of this property.) 2520 */ 2521 public ConceptPropertyComponent setValue(Type value) throws FHIRFormatError { 2522 if (value != null && !(value instanceof CodeType || value instanceof Coding || value instanceof StringType || value instanceof IntegerType || value instanceof BooleanType || value instanceof DateTimeType)) 2523 throw new FHIRFormatError("Not the right type for CodeSystem.concept.property.value[x]: "+value.fhirType()); 2524 this.value = value; 2525 return this; 2526 } 2527 2528 protected void listChildren(List<Property> children) { 2529 super.listChildren(children); 2530 children.add(new Property("code", "code", "A code that is a reference to CodeSystem.property.code.", 0, 1, code)); 2531 children.add(new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value)); 2532 } 2533 2534 @Override 2535 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2536 switch (_hash) { 2537 case 3059181: /*code*/ return new Property("code", "code", "A code that is a reference to CodeSystem.property.code.", 0, 1, code); 2538 case -1410166417: /*value[x]*/ return new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value); 2539 case 111972721: /*value*/ return new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value); 2540 case -766209282: /*valueCode*/ return new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value); 2541 case -1887705029: /*valueCoding*/ return new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value); 2542 case -1424603934: /*valueString*/ return new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value); 2543 case -1668204915: /*valueInteger*/ return new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value); 2544 case 733421943: /*valueBoolean*/ return new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value); 2545 case 1047929900: /*valueDateTime*/ return new Property("value[x]", "code|Coding|string|integer|boolean|dateTime", "The value of this property.", 0, 1, value); 2546 default: return super.getNamedProperty(_hash, _name, _checkValid); 2547 } 2548 2549 } 2550 2551 @Override 2552 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2553 switch (hash) { 2554 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType 2555 case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // Type 2556 default: return super.getProperty(hash, name, checkValid); 2557 } 2558 2559 } 2560 2561 @Override 2562 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2563 switch (hash) { 2564 case 3059181: // code 2565 this.code = castToCode(value); // CodeType 2566 return value; 2567 case 111972721: // value 2568 this.value = castToType(value); // Type 2569 return value; 2570 default: return super.setProperty(hash, name, value); 2571 } 2572 2573 } 2574 2575 @Override 2576 public Base setProperty(String name, Base value) throws FHIRException { 2577 if (name.equals("code")) { 2578 this.code = castToCode(value); // CodeType 2579 } else if (name.equals("value[x]")) { 2580 this.value = castToType(value); // Type 2581 } else 2582 return super.setProperty(name, value); 2583 return value; 2584 } 2585 2586 @Override 2587 public Base makeProperty(int hash, String name) throws FHIRException { 2588 switch (hash) { 2589 case 3059181: return getCodeElement(); 2590 case -1410166417: return getValue(); 2591 case 111972721: return getValue(); 2592 default: return super.makeProperty(hash, name); 2593 } 2594 2595 } 2596 2597 @Override 2598 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2599 switch (hash) { 2600 case 3059181: /*code*/ return new String[] {"code"}; 2601 case 111972721: /*value*/ return new String[] {"code", "Coding", "string", "integer", "boolean", "dateTime"}; 2602 default: return super.getTypesForProperty(hash, name); 2603 } 2604 2605 } 2606 2607 @Override 2608 public Base addChild(String name) throws FHIRException { 2609 if (name.equals("code")) { 2610 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.code"); 2611 } 2612 else if (name.equals("valueCode")) { 2613 this.value = new CodeType(); 2614 return this.value; 2615 } 2616 else if (name.equals("valueCoding")) { 2617 this.value = new Coding(); 2618 return this.value; 2619 } 2620 else if (name.equals("valueString")) { 2621 this.value = new StringType(); 2622 return this.value; 2623 } 2624 else if (name.equals("valueInteger")) { 2625 this.value = new IntegerType(); 2626 return this.value; 2627 } 2628 else if (name.equals("valueBoolean")) { 2629 this.value = new BooleanType(); 2630 return this.value; 2631 } 2632 else if (name.equals("valueDateTime")) { 2633 this.value = new DateTimeType(); 2634 return this.value; 2635 } 2636 else 2637 return super.addChild(name); 2638 } 2639 2640 public ConceptPropertyComponent copy() { 2641 ConceptPropertyComponent dst = new ConceptPropertyComponent(); 2642 copyValues(dst); 2643 dst.code = code == null ? null : code.copy(); 2644 dst.value = value == null ? null : value.copy(); 2645 return dst; 2646 } 2647 2648 @Override 2649 public boolean equalsDeep(Base other_) { 2650 if (!super.equalsDeep(other_)) 2651 return false; 2652 if (!(other_ instanceof ConceptPropertyComponent)) 2653 return false; 2654 ConceptPropertyComponent o = (ConceptPropertyComponent) other_; 2655 return compareDeep(code, o.code, true) && compareDeep(value, o.value, true); 2656 } 2657 2658 @Override 2659 public boolean equalsShallow(Base other_) { 2660 if (!super.equalsShallow(other_)) 2661 return false; 2662 if (!(other_ instanceof ConceptPropertyComponent)) 2663 return false; 2664 ConceptPropertyComponent o = (ConceptPropertyComponent) other_; 2665 return compareValues(code, o.code, true); 2666 } 2667 2668 public boolean isEmpty() { 2669 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, value); 2670 } 2671 2672 public String fhirType() { 2673 return "CodeSystem.concept.property"; 2674 2675 } 2676 2677 } 2678 2679 /** 2680 * A formal identifier that is used to identify this code system when it is represented in other formats, or referenced in a specification, model, design or an instance. 2681 */ 2682 @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=1, modifier=false, summary=true) 2683 @Description(shortDefinition="Additional identifier for the code system", formalDefinition="A formal identifier that is used to identify this code system when it is represented in other formats, or referenced in a specification, model, design or an instance." ) 2684 protected Identifier identifier; 2685 2686 /** 2687 * Explaination of why this code system is needed and why it has been designed as it has. 2688 */ 2689 @Child(name = "purpose", type = {MarkdownType.class}, order=1, min=0, max=1, modifier=false, summary=false) 2690 @Description(shortDefinition="Why this code system is defined", formalDefinition="Explaination of why this code system is needed and why it has been designed as it has." ) 2691 protected MarkdownType purpose; 2692 2693 /** 2694 * A copyright statement relating to the code system and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the code system. 2695 */ 2696 @Child(name = "copyright", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 2697 @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the code system and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the code system." ) 2698 protected MarkdownType copyright; 2699 2700 /** 2701 * If code comparison is case sensitive when codes within this system are compared to each other. 2702 */ 2703 @Child(name = "caseSensitive", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=true) 2704 @Description(shortDefinition="If code comparison is case sensitive", formalDefinition="If code comparison is case sensitive when codes within this system are compared to each other." ) 2705 protected BooleanType caseSensitive; 2706 2707 /** 2708 * Canonical URL of value set that contains the entire code system. 2709 */ 2710 @Child(name = "valueSet", type = {UriType.class}, order=4, min=0, max=1, modifier=false, summary=true) 2711 @Description(shortDefinition="Canonical URL for value set with entire code system", formalDefinition="Canonical URL of value set that contains the entire code system." ) 2712 protected UriType valueSet; 2713 2714 /** 2715 * The meaning of the hierarchy of concepts. 2716 */ 2717 @Child(name = "hierarchyMeaning", type = {CodeType.class}, order=5, min=0, max=1, modifier=false, summary=true) 2718 @Description(shortDefinition="grouped-by | is-a | part-of | classified-with", formalDefinition="The meaning of the hierarchy of concepts." ) 2719 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/codesystem-hierarchy-meaning") 2720 protected Enumeration<CodeSystemHierarchyMeaning> hierarchyMeaning; 2721 2722 /** 2723 * True If code system defines a post-composition grammar. 2724 */ 2725 @Child(name = "compositional", type = {BooleanType.class}, order=6, min=0, max=1, modifier=false, summary=true) 2726 @Description(shortDefinition="If code system defines a post-composition grammar", formalDefinition="True If code system defines a post-composition grammar." ) 2727 protected BooleanType compositional; 2728 2729 /** 2730 * This flag is used to signify that the code system has not (or does not) maintain the definitions, and a version must be specified when referencing this code system. 2731 */ 2732 @Child(name = "versionNeeded", type = {BooleanType.class}, order=7, min=0, max=1, modifier=false, summary=true) 2733 @Description(shortDefinition="If definitions are not stable", formalDefinition="This flag is used to signify that the code system has not (or does not) maintain the definitions, and a version must be specified when referencing this code system." ) 2734 protected BooleanType versionNeeded; 2735 2736 /** 2737 * How much of the content of the code system - the concepts and codes it defines - are represented in this resource. 2738 */ 2739 @Child(name = "content", type = {CodeType.class}, order=8, min=1, max=1, modifier=false, summary=true) 2740 @Description(shortDefinition="not-present | example | fragment | complete", formalDefinition="How much of the content of the code system - the concepts and codes it defines - are represented in this resource." ) 2741 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/codesystem-content-mode") 2742 protected Enumeration<CodeSystemContentMode> content; 2743 2744 /** 2745 * The total number of concepts defined by the code system. Where the code system has a compositional grammar, the count refers to the number of base (primitive) concepts. 2746 */ 2747 @Child(name = "count", type = {UnsignedIntType.class}, order=9, min=0, max=1, modifier=false, summary=true) 2748 @Description(shortDefinition="Total concepts in the code system", formalDefinition="The total number of concepts defined by the code system. Where the code system has a compositional grammar, the count refers to the number of base (primitive) concepts." ) 2749 protected UnsignedIntType count; 2750 2751 /** 2752 * A filter that can be used in a value set compose statement when selecting concepts using a filter. 2753 */ 2754 @Child(name = "filter", type = {}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2755 @Description(shortDefinition="Filter that can be used in a value set", formalDefinition="A filter that can be used in a value set compose statement when selecting concepts using a filter." ) 2756 protected List<CodeSystemFilterComponent> filter; 2757 2758 /** 2759 * A property defines an additional slot through which additional information can be provided about a concept. 2760 */ 2761 @Child(name = "property", type = {}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2762 @Description(shortDefinition="Additional information supplied about each concept", formalDefinition="A property defines an additional slot through which additional information can be provided about a concept." ) 2763 protected List<PropertyComponent> property; 2764 2765 /** 2766 * Concepts that are in the code system. The concept definitions are inherently hierarchical, but the definitions must be consulted to determine what the meaning of the hierarchical relationships are. 2767 */ 2768 @Child(name = "concept", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2769 @Description(shortDefinition="Concepts in the code system", formalDefinition="Concepts that are in the code system. The concept definitions are inherently hierarchical, but the definitions must be consulted to determine what the meaning of the hierarchical relationships are." ) 2770 protected List<ConceptDefinitionComponent> concept; 2771 2772 private static final long serialVersionUID = -1344546572L; 2773 2774 /** 2775 * Constructor 2776 */ 2777 public CodeSystem() { 2778 super(); 2779 } 2780 2781 /** 2782 * Constructor 2783 */ 2784 public CodeSystem(Enumeration<PublicationStatus> status, Enumeration<CodeSystemContentMode> content) { 2785 super(); 2786 this.status = status; 2787 this.content = content; 2788 } 2789 2790 /** 2791 * @return {@link #url} (An absolute URI that is used to identify this code system when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this code system is (or will be) published. The URL SHOULD include the major version of the code system. For more information see [Technical and Business Versions](resource.html#versions). This is used in [Coding]{datatypes.html#Coding}.system.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 2792 */ 2793 public UriType getUrlElement() { 2794 if (this.url == null) 2795 if (Configuration.errorOnAutoCreate()) 2796 throw new Error("Attempt to auto-create CodeSystem.url"); 2797 else if (Configuration.doAutoCreate()) 2798 this.url = new UriType(); // bb 2799 return this.url; 2800 } 2801 2802 public boolean hasUrlElement() { 2803 return this.url != null && !this.url.isEmpty(); 2804 } 2805 2806 public boolean hasUrl() { 2807 return this.url != null && !this.url.isEmpty(); 2808 } 2809 2810 /** 2811 * @param value {@link #url} (An absolute URI that is used to identify this code system when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this code system is (or will be) published. The URL SHOULD include the major version of the code system. For more information see [Technical and Business Versions](resource.html#versions). This is used in [Coding]{datatypes.html#Coding}.system.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 2812 */ 2813 public CodeSystem setUrlElement(UriType value) { 2814 this.url = value; 2815 return this; 2816 } 2817 2818 /** 2819 * @return An absolute URI that is used to identify this code system when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this code system is (or will be) published. The URL SHOULD include the major version of the code system. For more information see [Technical and Business Versions](resource.html#versions). This is used in [Coding]{datatypes.html#Coding}.system. 2820 */ 2821 public String getUrl() { 2822 return this.url == null ? null : this.url.getValue(); 2823 } 2824 2825 /** 2826 * @param value An absolute URI that is used to identify this code system when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this code system is (or will be) published. The URL SHOULD include the major version of the code system. For more information see [Technical and Business Versions](resource.html#versions). This is used in [Coding]{datatypes.html#Coding}.system. 2827 */ 2828 public CodeSystem setUrl(String value) { 2829 if (Utilities.noString(value)) 2830 this.url = null; 2831 else { 2832 if (this.url == null) 2833 this.url = new UriType(); 2834 this.url.setValue(value); 2835 } 2836 return this; 2837 } 2838 2839 /** 2840 * @return {@link #identifier} (A formal identifier that is used to identify this code system when it is represented in other formats, or referenced in a specification, model, design or an instance.) 2841 */ 2842 public Identifier getIdentifier() { 2843 if (this.identifier == null) 2844 if (Configuration.errorOnAutoCreate()) 2845 throw new Error("Attempt to auto-create CodeSystem.identifier"); 2846 else if (Configuration.doAutoCreate()) 2847 this.identifier = new Identifier(); // cc 2848 return this.identifier; 2849 } 2850 2851 public boolean hasIdentifier() { 2852 return this.identifier != null && !this.identifier.isEmpty(); 2853 } 2854 2855 /** 2856 * @param value {@link #identifier} (A formal identifier that is used to identify this code system when it is represented in other formats, or referenced in a specification, model, design or an instance.) 2857 */ 2858 public CodeSystem setIdentifier(Identifier value) { 2859 this.identifier = value; 2860 return this; 2861 } 2862 2863 /** 2864 * @return {@link #version} (The identifier that is used to identify this version of the code system when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the code system author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. This is used in [Coding]{datatypes.html#Coding}.version.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 2865 */ 2866 public StringType getVersionElement() { 2867 if (this.version == null) 2868 if (Configuration.errorOnAutoCreate()) 2869 throw new Error("Attempt to auto-create CodeSystem.version"); 2870 else if (Configuration.doAutoCreate()) 2871 this.version = new StringType(); // bb 2872 return this.version; 2873 } 2874 2875 public boolean hasVersionElement() { 2876 return this.version != null && !this.version.isEmpty(); 2877 } 2878 2879 public boolean hasVersion() { 2880 return this.version != null && !this.version.isEmpty(); 2881 } 2882 2883 /** 2884 * @param value {@link #version} (The identifier that is used to identify this version of the code system when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the code system author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. This is used in [Coding]{datatypes.html#Coding}.version.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 2885 */ 2886 public CodeSystem setVersionElement(StringType value) { 2887 this.version = value; 2888 return this; 2889 } 2890 2891 /** 2892 * @return The identifier that is used to identify this version of the code system when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the code system author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. This is used in [Coding]{datatypes.html#Coding}.version. 2893 */ 2894 public String getVersion() { 2895 return this.version == null ? null : this.version.getValue(); 2896 } 2897 2898 /** 2899 * @param value The identifier that is used to identify this version of the code system when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the code system author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. This is used in [Coding]{datatypes.html#Coding}.version. 2900 */ 2901 public CodeSystem setVersion(String value) { 2902 if (Utilities.noString(value)) 2903 this.version = null; 2904 else { 2905 if (this.version == null) 2906 this.version = new StringType(); 2907 this.version.setValue(value); 2908 } 2909 return this; 2910 } 2911 2912 /** 2913 * @return {@link #name} (A natural language name identifying the code system. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 2914 */ 2915 public StringType getNameElement() { 2916 if (this.name == null) 2917 if (Configuration.errorOnAutoCreate()) 2918 throw new Error("Attempt to auto-create CodeSystem.name"); 2919 else if (Configuration.doAutoCreate()) 2920 this.name = new StringType(); // bb 2921 return this.name; 2922 } 2923 2924 public boolean hasNameElement() { 2925 return this.name != null && !this.name.isEmpty(); 2926 } 2927 2928 public boolean hasName() { 2929 return this.name != null && !this.name.isEmpty(); 2930 } 2931 2932 /** 2933 * @param value {@link #name} (A natural language name identifying the code system. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 2934 */ 2935 public CodeSystem setNameElement(StringType value) { 2936 this.name = value; 2937 return this; 2938 } 2939 2940 /** 2941 * @return A natural language name identifying the code system. This name should be usable as an identifier for the module by machine processing applications such as code generation. 2942 */ 2943 public String getName() { 2944 return this.name == null ? null : this.name.getValue(); 2945 } 2946 2947 /** 2948 * @param value A natural language name identifying the code system. This name should be usable as an identifier for the module by machine processing applications such as code generation. 2949 */ 2950 public CodeSystem setName(String value) { 2951 if (Utilities.noString(value)) 2952 this.name = null; 2953 else { 2954 if (this.name == null) 2955 this.name = new StringType(); 2956 this.name.setValue(value); 2957 } 2958 return this; 2959 } 2960 2961 /** 2962 * @return {@link #title} (A short, descriptive, user-friendly title for the code system.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 2963 */ 2964 public StringType getTitleElement() { 2965 if (this.title == null) 2966 if (Configuration.errorOnAutoCreate()) 2967 throw new Error("Attempt to auto-create CodeSystem.title"); 2968 else if (Configuration.doAutoCreate()) 2969 this.title = new StringType(); // bb 2970 return this.title; 2971 } 2972 2973 public boolean hasTitleElement() { 2974 return this.title != null && !this.title.isEmpty(); 2975 } 2976 2977 public boolean hasTitle() { 2978 return this.title != null && !this.title.isEmpty(); 2979 } 2980 2981 /** 2982 * @param value {@link #title} (A short, descriptive, user-friendly title for the code system.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 2983 */ 2984 public CodeSystem setTitleElement(StringType value) { 2985 this.title = value; 2986 return this; 2987 } 2988 2989 /** 2990 * @return A short, descriptive, user-friendly title for the code system. 2991 */ 2992 public String getTitle() { 2993 return this.title == null ? null : this.title.getValue(); 2994 } 2995 2996 /** 2997 * @param value A short, descriptive, user-friendly title for the code system. 2998 */ 2999 public CodeSystem setTitle(String value) { 3000 if (Utilities.noString(value)) 3001 this.title = null; 3002 else { 3003 if (this.title == null) 3004 this.title = new StringType(); 3005 this.title.setValue(value); 3006 } 3007 return this; 3008 } 3009 3010 /** 3011 * @return {@link #status} (The status of this code system. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 3012 */ 3013 public Enumeration<PublicationStatus> getStatusElement() { 3014 if (this.status == null) 3015 if (Configuration.errorOnAutoCreate()) 3016 throw new Error("Attempt to auto-create CodeSystem.status"); 3017 else if (Configuration.doAutoCreate()) 3018 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 3019 return this.status; 3020 } 3021 3022 public boolean hasStatusElement() { 3023 return this.status != null && !this.status.isEmpty(); 3024 } 3025 3026 public boolean hasStatus() { 3027 return this.status != null && !this.status.isEmpty(); 3028 } 3029 3030 /** 3031 * @param value {@link #status} (The status of this code system. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 3032 */ 3033 public CodeSystem setStatusElement(Enumeration<PublicationStatus> value) { 3034 this.status = value; 3035 return this; 3036 } 3037 3038 /** 3039 * @return The status of this code system. Enables tracking the life-cycle of the content. 3040 */ 3041 public PublicationStatus getStatus() { 3042 return this.status == null ? null : this.status.getValue(); 3043 } 3044 3045 /** 3046 * @param value The status of this code system. Enables tracking the life-cycle of the content. 3047 */ 3048 public CodeSystem setStatus(PublicationStatus value) { 3049 if (this.status == null) 3050 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 3051 this.status.setValue(value); 3052 return this; 3053 } 3054 3055 /** 3056 * @return {@link #experimental} (A boolean value to indicate that this code system is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value 3057 */ 3058 public BooleanType getExperimentalElement() { 3059 if (this.experimental == null) 3060 if (Configuration.errorOnAutoCreate()) 3061 throw new Error("Attempt to auto-create CodeSystem.experimental"); 3062 else if (Configuration.doAutoCreate()) 3063 this.experimental = new BooleanType(); // bb 3064 return this.experimental; 3065 } 3066 3067 public boolean hasExperimentalElement() { 3068 return this.experimental != null && !this.experimental.isEmpty(); 3069 } 3070 3071 public boolean hasExperimental() { 3072 return this.experimental != null && !this.experimental.isEmpty(); 3073 } 3074 3075 /** 3076 * @param value {@link #experimental} (A boolean value to indicate that this code system is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value 3077 */ 3078 public CodeSystem setExperimentalElement(BooleanType value) { 3079 this.experimental = value; 3080 return this; 3081 } 3082 3083 /** 3084 * @return A boolean value to indicate that this code system is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage. 3085 */ 3086 public boolean getExperimental() { 3087 return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue(); 3088 } 3089 3090 /** 3091 * @param value A boolean value to indicate that this code system is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage. 3092 */ 3093 public CodeSystem setExperimental(boolean value) { 3094 if (this.experimental == null) 3095 this.experimental = new BooleanType(); 3096 this.experimental.setValue(value); 3097 return this; 3098 } 3099 3100 /** 3101 * @return {@link #date} (The date (and optionally time) when the code system was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the code system changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 3102 */ 3103 public DateTimeType getDateElement() { 3104 if (this.date == null) 3105 if (Configuration.errorOnAutoCreate()) 3106 throw new Error("Attempt to auto-create CodeSystem.date"); 3107 else if (Configuration.doAutoCreate()) 3108 this.date = new DateTimeType(); // bb 3109 return this.date; 3110 } 3111 3112 public boolean hasDateElement() { 3113 return this.date != null && !this.date.isEmpty(); 3114 } 3115 3116 public boolean hasDate() { 3117 return this.date != null && !this.date.isEmpty(); 3118 } 3119 3120 /** 3121 * @param value {@link #date} (The date (and optionally time) when the code system was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the code system changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 3122 */ 3123 public CodeSystem setDateElement(DateTimeType value) { 3124 this.date = value; 3125 return this; 3126 } 3127 3128 /** 3129 * @return The date (and optionally time) when the code system was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the code system changes. 3130 */ 3131 public Date getDate() { 3132 return this.date == null ? null : this.date.getValue(); 3133 } 3134 3135 /** 3136 * @param value The date (and optionally time) when the code system was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the code system changes. 3137 */ 3138 public CodeSystem setDate(Date value) { 3139 if (value == null) 3140 this.date = null; 3141 else { 3142 if (this.date == null) 3143 this.date = new DateTimeType(); 3144 this.date.setValue(value); 3145 } 3146 return this; 3147 } 3148 3149 /** 3150 * @return {@link #publisher} (The name of the individual or organization that published the code system.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 3151 */ 3152 public StringType getPublisherElement() { 3153 if (this.publisher == null) 3154 if (Configuration.errorOnAutoCreate()) 3155 throw new Error("Attempt to auto-create CodeSystem.publisher"); 3156 else if (Configuration.doAutoCreate()) 3157 this.publisher = new StringType(); // bb 3158 return this.publisher; 3159 } 3160 3161 public boolean hasPublisherElement() { 3162 return this.publisher != null && !this.publisher.isEmpty(); 3163 } 3164 3165 public boolean hasPublisher() { 3166 return this.publisher != null && !this.publisher.isEmpty(); 3167 } 3168 3169 /** 3170 * @param value {@link #publisher} (The name of the individual or organization that published the code system.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 3171 */ 3172 public CodeSystem setPublisherElement(StringType value) { 3173 this.publisher = value; 3174 return this; 3175 } 3176 3177 /** 3178 * @return The name of the individual or organization that published the code system. 3179 */ 3180 public String getPublisher() { 3181 return this.publisher == null ? null : this.publisher.getValue(); 3182 } 3183 3184 /** 3185 * @param value The name of the individual or organization that published the code system. 3186 */ 3187 public CodeSystem setPublisher(String value) { 3188 if (Utilities.noString(value)) 3189 this.publisher = null; 3190 else { 3191 if (this.publisher == null) 3192 this.publisher = new StringType(); 3193 this.publisher.setValue(value); 3194 } 3195 return this; 3196 } 3197 3198 /** 3199 * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.) 3200 */ 3201 public List<ContactDetail> getContact() { 3202 if (this.contact == null) 3203 this.contact = new ArrayList<ContactDetail>(); 3204 return this.contact; 3205 } 3206 3207 /** 3208 * @return Returns a reference to <code>this</code> for easy method chaining 3209 */ 3210 public CodeSystem setContact(List<ContactDetail> theContact) { 3211 this.contact = theContact; 3212 return this; 3213 } 3214 3215 public boolean hasContact() { 3216 if (this.contact == null) 3217 return false; 3218 for (ContactDetail item : this.contact) 3219 if (!item.isEmpty()) 3220 return true; 3221 return false; 3222 } 3223 3224 public ContactDetail addContact() { //3 3225 ContactDetail t = new ContactDetail(); 3226 if (this.contact == null) 3227 this.contact = new ArrayList<ContactDetail>(); 3228 this.contact.add(t); 3229 return t; 3230 } 3231 3232 public CodeSystem addContact(ContactDetail t) { //3 3233 if (t == null) 3234 return this; 3235 if (this.contact == null) 3236 this.contact = new ArrayList<ContactDetail>(); 3237 this.contact.add(t); 3238 return this; 3239 } 3240 3241 /** 3242 * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist 3243 */ 3244 public ContactDetail getContactFirstRep() { 3245 if (getContact().isEmpty()) { 3246 addContact(); 3247 } 3248 return getContact().get(0); 3249 } 3250 3251 /** 3252 * @return {@link #description} (A free text natural language description of the code system from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 3253 */ 3254 public MarkdownType getDescriptionElement() { 3255 if (this.description == null) 3256 if (Configuration.errorOnAutoCreate()) 3257 throw new Error("Attempt to auto-create CodeSystem.description"); 3258 else if (Configuration.doAutoCreate()) 3259 this.description = new MarkdownType(); // bb 3260 return this.description; 3261 } 3262 3263 public boolean hasDescriptionElement() { 3264 return this.description != null && !this.description.isEmpty(); 3265 } 3266 3267 public boolean hasDescription() { 3268 return this.description != null && !this.description.isEmpty(); 3269 } 3270 3271 /** 3272 * @param value {@link #description} (A free text natural language description of the code system from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 3273 */ 3274 public CodeSystem setDescriptionElement(MarkdownType value) { 3275 this.description = value; 3276 return this; 3277 } 3278 3279 /** 3280 * @return A free text natural language description of the code system from a consumer's perspective. 3281 */ 3282 public String getDescription() { 3283 return this.description == null ? null : this.description.getValue(); 3284 } 3285 3286 /** 3287 * @param value A free text natural language description of the code system from a consumer's perspective. 3288 */ 3289 public CodeSystem setDescription(String value) { 3290 if (value == null) 3291 this.description = null; 3292 else { 3293 if (this.description == null) 3294 this.description = new MarkdownType(); 3295 this.description.setValue(value); 3296 } 3297 return this; 3298 } 3299 3300 /** 3301 * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate code system instances.) 3302 */ 3303 public List<UsageContext> getUseContext() { 3304 if (this.useContext == null) 3305 this.useContext = new ArrayList<UsageContext>(); 3306 return this.useContext; 3307 } 3308 3309 /** 3310 * @return Returns a reference to <code>this</code> for easy method chaining 3311 */ 3312 public CodeSystem setUseContext(List<UsageContext> theUseContext) { 3313 this.useContext = theUseContext; 3314 return this; 3315 } 3316 3317 public boolean hasUseContext() { 3318 if (this.useContext == null) 3319 return false; 3320 for (UsageContext item : this.useContext) 3321 if (!item.isEmpty()) 3322 return true; 3323 return false; 3324 } 3325 3326 public UsageContext addUseContext() { //3 3327 UsageContext t = new UsageContext(); 3328 if (this.useContext == null) 3329 this.useContext = new ArrayList<UsageContext>(); 3330 this.useContext.add(t); 3331 return t; 3332 } 3333 3334 public CodeSystem addUseContext(UsageContext t) { //3 3335 if (t == null) 3336 return this; 3337 if (this.useContext == null) 3338 this.useContext = new ArrayList<UsageContext>(); 3339 this.useContext.add(t); 3340 return this; 3341 } 3342 3343 /** 3344 * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist 3345 */ 3346 public UsageContext getUseContextFirstRep() { 3347 if (getUseContext().isEmpty()) { 3348 addUseContext(); 3349 } 3350 return getUseContext().get(0); 3351 } 3352 3353 /** 3354 * @return {@link #jurisdiction} (A legal or geographic region in which the code system is intended to be used.) 3355 */ 3356 public List<CodeableConcept> getJurisdiction() { 3357 if (this.jurisdiction == null) 3358 this.jurisdiction = new ArrayList<CodeableConcept>(); 3359 return this.jurisdiction; 3360 } 3361 3362 /** 3363 * @return Returns a reference to <code>this</code> for easy method chaining 3364 */ 3365 public CodeSystem setJurisdiction(List<CodeableConcept> theJurisdiction) { 3366 this.jurisdiction = theJurisdiction; 3367 return this; 3368 } 3369 3370 public boolean hasJurisdiction() { 3371 if (this.jurisdiction == null) 3372 return false; 3373 for (CodeableConcept item : this.jurisdiction) 3374 if (!item.isEmpty()) 3375 return true; 3376 return false; 3377 } 3378 3379 public CodeableConcept addJurisdiction() { //3 3380 CodeableConcept t = new CodeableConcept(); 3381 if (this.jurisdiction == null) 3382 this.jurisdiction = new ArrayList<CodeableConcept>(); 3383 this.jurisdiction.add(t); 3384 return t; 3385 } 3386 3387 public CodeSystem addJurisdiction(CodeableConcept t) { //3 3388 if (t == null) 3389 return this; 3390 if (this.jurisdiction == null) 3391 this.jurisdiction = new ArrayList<CodeableConcept>(); 3392 this.jurisdiction.add(t); 3393 return this; 3394 } 3395 3396 /** 3397 * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist 3398 */ 3399 public CodeableConcept getJurisdictionFirstRep() { 3400 if (getJurisdiction().isEmpty()) { 3401 addJurisdiction(); 3402 } 3403 return getJurisdiction().get(0); 3404 } 3405 3406 /** 3407 * @return {@link #purpose} (Explaination of why this code system is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 3408 */ 3409 public MarkdownType getPurposeElement() { 3410 if (this.purpose == null) 3411 if (Configuration.errorOnAutoCreate()) 3412 throw new Error("Attempt to auto-create CodeSystem.purpose"); 3413 else if (Configuration.doAutoCreate()) 3414 this.purpose = new MarkdownType(); // bb 3415 return this.purpose; 3416 } 3417 3418 public boolean hasPurposeElement() { 3419 return this.purpose != null && !this.purpose.isEmpty(); 3420 } 3421 3422 public boolean hasPurpose() { 3423 return this.purpose != null && !this.purpose.isEmpty(); 3424 } 3425 3426 /** 3427 * @param value {@link #purpose} (Explaination of why this code system is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 3428 */ 3429 public CodeSystem setPurposeElement(MarkdownType value) { 3430 this.purpose = value; 3431 return this; 3432 } 3433 3434 /** 3435 * @return Explaination of why this code system is needed and why it has been designed as it has. 3436 */ 3437 public String getPurpose() { 3438 return this.purpose == null ? null : this.purpose.getValue(); 3439 } 3440 3441 /** 3442 * @param value Explaination of why this code system is needed and why it has been designed as it has. 3443 */ 3444 public CodeSystem setPurpose(String value) { 3445 if (value == null) 3446 this.purpose = null; 3447 else { 3448 if (this.purpose == null) 3449 this.purpose = new MarkdownType(); 3450 this.purpose.setValue(value); 3451 } 3452 return this; 3453 } 3454 3455 /** 3456 * @return {@link #copyright} (A copyright statement relating to the code system and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the code system.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value 3457 */ 3458 public MarkdownType getCopyrightElement() { 3459 if (this.copyright == null) 3460 if (Configuration.errorOnAutoCreate()) 3461 throw new Error("Attempt to auto-create CodeSystem.copyright"); 3462 else if (Configuration.doAutoCreate()) 3463 this.copyright = new MarkdownType(); // bb 3464 return this.copyright; 3465 } 3466 3467 public boolean hasCopyrightElement() { 3468 return this.copyright != null && !this.copyright.isEmpty(); 3469 } 3470 3471 public boolean hasCopyright() { 3472 return this.copyright != null && !this.copyright.isEmpty(); 3473 } 3474 3475 /** 3476 * @param value {@link #copyright} (A copyright statement relating to the code system and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the code system.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value 3477 */ 3478 public CodeSystem setCopyrightElement(MarkdownType value) { 3479 this.copyright = value; 3480 return this; 3481 } 3482 3483 /** 3484 * @return A copyright statement relating to the code system and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the code system. 3485 */ 3486 public String getCopyright() { 3487 return this.copyright == null ? null : this.copyright.getValue(); 3488 } 3489 3490 /** 3491 * @param value A copyright statement relating to the code system and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the code system. 3492 */ 3493 public CodeSystem setCopyright(String value) { 3494 if (value == null) 3495 this.copyright = null; 3496 else { 3497 if (this.copyright == null) 3498 this.copyright = new MarkdownType(); 3499 this.copyright.setValue(value); 3500 } 3501 return this; 3502 } 3503 3504 /** 3505 * @return {@link #caseSensitive} (If code comparison is case sensitive when codes within this system are compared to each other.). This is the underlying object with id, value and extensions. The accessor "getCaseSensitive" gives direct access to the value 3506 */ 3507 public BooleanType getCaseSensitiveElement() { 3508 if (this.caseSensitive == null) 3509 if (Configuration.errorOnAutoCreate()) 3510 throw new Error("Attempt to auto-create CodeSystem.caseSensitive"); 3511 else if (Configuration.doAutoCreate()) 3512 this.caseSensitive = new BooleanType(); // bb 3513 return this.caseSensitive; 3514 } 3515 3516 public boolean hasCaseSensitiveElement() { 3517 return this.caseSensitive != null && !this.caseSensitive.isEmpty(); 3518 } 3519 3520 public boolean hasCaseSensitive() { 3521 return this.caseSensitive != null && !this.caseSensitive.isEmpty(); 3522 } 3523 3524 /** 3525 * @param value {@link #caseSensitive} (If code comparison is case sensitive when codes within this system are compared to each other.). This is the underlying object with id, value and extensions. The accessor "getCaseSensitive" gives direct access to the value 3526 */ 3527 public CodeSystem setCaseSensitiveElement(BooleanType value) { 3528 this.caseSensitive = value; 3529 return this; 3530 } 3531 3532 /** 3533 * @return If code comparison is case sensitive when codes within this system are compared to each other. 3534 */ 3535 public boolean getCaseSensitive() { 3536 return this.caseSensitive == null || this.caseSensitive.isEmpty() ? false : this.caseSensitive.getValue(); 3537 } 3538 3539 /** 3540 * @param value If code comparison is case sensitive when codes within this system are compared to each other. 3541 */ 3542 public CodeSystem setCaseSensitive(boolean value) { 3543 if (this.caseSensitive == null) 3544 this.caseSensitive = new BooleanType(); 3545 this.caseSensitive.setValue(value); 3546 return this; 3547 } 3548 3549 /** 3550 * @return {@link #valueSet} (Canonical URL of value set that contains the entire code system.). This is the underlying object with id, value and extensions. The accessor "getValueSet" gives direct access to the value 3551 */ 3552 public UriType getValueSetElement() { 3553 if (this.valueSet == null) 3554 if (Configuration.errorOnAutoCreate()) 3555 throw new Error("Attempt to auto-create CodeSystem.valueSet"); 3556 else if (Configuration.doAutoCreate()) 3557 this.valueSet = new UriType(); // bb 3558 return this.valueSet; 3559 } 3560 3561 public boolean hasValueSetElement() { 3562 return this.valueSet != null && !this.valueSet.isEmpty(); 3563 } 3564 3565 public boolean hasValueSet() { 3566 return this.valueSet != null && !this.valueSet.isEmpty(); 3567 } 3568 3569 /** 3570 * @param value {@link #valueSet} (Canonical URL of value set that contains the entire code system.). This is the underlying object with id, value and extensions. The accessor "getValueSet" gives direct access to the value 3571 */ 3572 public CodeSystem setValueSetElement(UriType value) { 3573 this.valueSet = value; 3574 return this; 3575 } 3576 3577 /** 3578 * @return Canonical URL of value set that contains the entire code system. 3579 */ 3580 public String getValueSet() { 3581 return this.valueSet == null ? null : this.valueSet.getValue(); 3582 } 3583 3584 /** 3585 * @param value Canonical URL of value set that contains the entire code system. 3586 */ 3587 public CodeSystem setValueSet(String value) { 3588 if (Utilities.noString(value)) 3589 this.valueSet = null; 3590 else { 3591 if (this.valueSet == null) 3592 this.valueSet = new UriType(); 3593 this.valueSet.setValue(value); 3594 } 3595 return this; 3596 } 3597 3598 /** 3599 * @return {@link #hierarchyMeaning} (The meaning of the hierarchy of concepts.). This is the underlying object with id, value and extensions. The accessor "getHierarchyMeaning" gives direct access to the value 3600 */ 3601 public Enumeration<CodeSystemHierarchyMeaning> getHierarchyMeaningElement() { 3602 if (this.hierarchyMeaning == null) 3603 if (Configuration.errorOnAutoCreate()) 3604 throw new Error("Attempt to auto-create CodeSystem.hierarchyMeaning"); 3605 else if (Configuration.doAutoCreate()) 3606 this.hierarchyMeaning = new Enumeration<CodeSystemHierarchyMeaning>(new CodeSystemHierarchyMeaningEnumFactory()); // bb 3607 return this.hierarchyMeaning; 3608 } 3609 3610 public boolean hasHierarchyMeaningElement() { 3611 return this.hierarchyMeaning != null && !this.hierarchyMeaning.isEmpty(); 3612 } 3613 3614 public boolean hasHierarchyMeaning() { 3615 return this.hierarchyMeaning != null && !this.hierarchyMeaning.isEmpty(); 3616 } 3617 3618 /** 3619 * @param value {@link #hierarchyMeaning} (The meaning of the hierarchy of concepts.). This is the underlying object with id, value and extensions. The accessor "getHierarchyMeaning" gives direct access to the value 3620 */ 3621 public CodeSystem setHierarchyMeaningElement(Enumeration<CodeSystemHierarchyMeaning> value) { 3622 this.hierarchyMeaning = value; 3623 return this; 3624 } 3625 3626 /** 3627 * @return The meaning of the hierarchy of concepts. 3628 */ 3629 public CodeSystemHierarchyMeaning getHierarchyMeaning() { 3630 return this.hierarchyMeaning == null ? null : this.hierarchyMeaning.getValue(); 3631 } 3632 3633 /** 3634 * @param value The meaning of the hierarchy of concepts. 3635 */ 3636 public CodeSystem setHierarchyMeaning(CodeSystemHierarchyMeaning value) { 3637 if (value == null) 3638 this.hierarchyMeaning = null; 3639 else { 3640 if (this.hierarchyMeaning == null) 3641 this.hierarchyMeaning = new Enumeration<CodeSystemHierarchyMeaning>(new CodeSystemHierarchyMeaningEnumFactory()); 3642 this.hierarchyMeaning.setValue(value); 3643 } 3644 return this; 3645 } 3646 3647 /** 3648 * @return {@link #compositional} (True If code system defines a post-composition grammar.). This is the underlying object with id, value and extensions. The accessor "getCompositional" gives direct access to the value 3649 */ 3650 public BooleanType getCompositionalElement() { 3651 if (this.compositional == null) 3652 if (Configuration.errorOnAutoCreate()) 3653 throw new Error("Attempt to auto-create CodeSystem.compositional"); 3654 else if (Configuration.doAutoCreate()) 3655 this.compositional = new BooleanType(); // bb 3656 return this.compositional; 3657 } 3658 3659 public boolean hasCompositionalElement() { 3660 return this.compositional != null && !this.compositional.isEmpty(); 3661 } 3662 3663 public boolean hasCompositional() { 3664 return this.compositional != null && !this.compositional.isEmpty(); 3665 } 3666 3667 /** 3668 * @param value {@link #compositional} (True If code system defines a post-composition grammar.). This is the underlying object with id, value and extensions. The accessor "getCompositional" gives direct access to the value 3669 */ 3670 public CodeSystem setCompositionalElement(BooleanType value) { 3671 this.compositional = value; 3672 return this; 3673 } 3674 3675 /** 3676 * @return True If code system defines a post-composition grammar. 3677 */ 3678 public boolean getCompositional() { 3679 return this.compositional == null || this.compositional.isEmpty() ? false : this.compositional.getValue(); 3680 } 3681 3682 /** 3683 * @param value True If code system defines a post-composition grammar. 3684 */ 3685 public CodeSystem setCompositional(boolean value) { 3686 if (this.compositional == null) 3687 this.compositional = new BooleanType(); 3688 this.compositional.setValue(value); 3689 return this; 3690 } 3691 3692 /** 3693 * @return {@link #versionNeeded} (This flag is used to signify that the code system has not (or does not) maintain the definitions, and a version must be specified when referencing this code system.). This is the underlying object with id, value and extensions. The accessor "getVersionNeeded" gives direct access to the value 3694 */ 3695 public BooleanType getVersionNeededElement() { 3696 if (this.versionNeeded == null) 3697 if (Configuration.errorOnAutoCreate()) 3698 throw new Error("Attempt to auto-create CodeSystem.versionNeeded"); 3699 else if (Configuration.doAutoCreate()) 3700 this.versionNeeded = new BooleanType(); // bb 3701 return this.versionNeeded; 3702 } 3703 3704 public boolean hasVersionNeededElement() { 3705 return this.versionNeeded != null && !this.versionNeeded.isEmpty(); 3706 } 3707 3708 public boolean hasVersionNeeded() { 3709 return this.versionNeeded != null && !this.versionNeeded.isEmpty(); 3710 } 3711 3712 /** 3713 * @param value {@link #versionNeeded} (This flag is used to signify that the code system has not (or does not) maintain the definitions, and a version must be specified when referencing this code system.). This is the underlying object with id, value and extensions. The accessor "getVersionNeeded" gives direct access to the value 3714 */ 3715 public CodeSystem setVersionNeededElement(BooleanType value) { 3716 this.versionNeeded = value; 3717 return this; 3718 } 3719 3720 /** 3721 * @return This flag is used to signify that the code system has not (or does not) maintain the definitions, and a version must be specified when referencing this code system. 3722 */ 3723 public boolean getVersionNeeded() { 3724 return this.versionNeeded == null || this.versionNeeded.isEmpty() ? false : this.versionNeeded.getValue(); 3725 } 3726 3727 /** 3728 * @param value This flag is used to signify that the code system has not (or does not) maintain the definitions, and a version must be specified when referencing this code system. 3729 */ 3730 public CodeSystem setVersionNeeded(boolean value) { 3731 if (this.versionNeeded == null) 3732 this.versionNeeded = new BooleanType(); 3733 this.versionNeeded.setValue(value); 3734 return this; 3735 } 3736 3737 /** 3738 * @return {@link #content} (How much of the content of the code system - the concepts and codes it defines - are represented in this resource.). This is the underlying object with id, value and extensions. The accessor "getContent" gives direct access to the value 3739 */ 3740 public Enumeration<CodeSystemContentMode> getContentElement() { 3741 if (this.content == null) 3742 if (Configuration.errorOnAutoCreate()) 3743 throw new Error("Attempt to auto-create CodeSystem.content"); 3744 else if (Configuration.doAutoCreate()) 3745 this.content = new Enumeration<CodeSystemContentMode>(new CodeSystemContentModeEnumFactory()); // bb 3746 return this.content; 3747 } 3748 3749 public boolean hasContentElement() { 3750 return this.content != null && !this.content.isEmpty(); 3751 } 3752 3753 public boolean hasContent() { 3754 return this.content != null && !this.content.isEmpty(); 3755 } 3756 3757 /** 3758 * @param value {@link #content} (How much of the content of the code system - the concepts and codes it defines - are represented in this resource.). This is the underlying object with id, value and extensions. The accessor "getContent" gives direct access to the value 3759 */ 3760 public CodeSystem setContentElement(Enumeration<CodeSystemContentMode> value) { 3761 this.content = value; 3762 return this; 3763 } 3764 3765 /** 3766 * @return How much of the content of the code system - the concepts and codes it defines - are represented in this resource. 3767 */ 3768 public CodeSystemContentMode getContent() { 3769 return this.content == null ? null : this.content.getValue(); 3770 } 3771 3772 /** 3773 * @param value How much of the content of the code system - the concepts and codes it defines - are represented in this resource. 3774 */ 3775 public CodeSystem setContent(CodeSystemContentMode value) { 3776 if (this.content == null) 3777 this.content = new Enumeration<CodeSystemContentMode>(new CodeSystemContentModeEnumFactory()); 3778 this.content.setValue(value); 3779 return this; 3780 } 3781 3782 /** 3783 * @return {@link #count} (The total number of concepts defined by the code system. Where the code system has a compositional grammar, the count refers to the number of base (primitive) concepts.). This is the underlying object with id, value and extensions. The accessor "getCount" gives direct access to the value 3784 */ 3785 public UnsignedIntType getCountElement() { 3786 if (this.count == null) 3787 if (Configuration.errorOnAutoCreate()) 3788 throw new Error("Attempt to auto-create CodeSystem.count"); 3789 else if (Configuration.doAutoCreate()) 3790 this.count = new UnsignedIntType(); // bb 3791 return this.count; 3792 } 3793 3794 public boolean hasCountElement() { 3795 return this.count != null && !this.count.isEmpty(); 3796 } 3797 3798 public boolean hasCount() { 3799 return this.count != null && !this.count.isEmpty(); 3800 } 3801 3802 /** 3803 * @param value {@link #count} (The total number of concepts defined by the code system. Where the code system has a compositional grammar, the count refers to the number of base (primitive) concepts.). This is the underlying object with id, value and extensions. The accessor "getCount" gives direct access to the value 3804 */ 3805 public CodeSystem setCountElement(UnsignedIntType value) { 3806 this.count = value; 3807 return this; 3808 } 3809 3810 /** 3811 * @return The total number of concepts defined by the code system. Where the code system has a compositional grammar, the count refers to the number of base (primitive) concepts. 3812 */ 3813 public int getCount() { 3814 return this.count == null || this.count.isEmpty() ? 0 : this.count.getValue(); 3815 } 3816 3817 /** 3818 * @param value The total number of concepts defined by the code system. Where the code system has a compositional grammar, the count refers to the number of base (primitive) concepts. 3819 */ 3820 public CodeSystem setCount(int value) { 3821 if (this.count == null) 3822 this.count = new UnsignedIntType(); 3823 this.count.setValue(value); 3824 return this; 3825 } 3826 3827 /** 3828 * @return {@link #filter} (A filter that can be used in a value set compose statement when selecting concepts using a filter.) 3829 */ 3830 public List<CodeSystemFilterComponent> getFilter() { 3831 if (this.filter == null) 3832 this.filter = new ArrayList<CodeSystemFilterComponent>(); 3833 return this.filter; 3834 } 3835 3836 /** 3837 * @return Returns a reference to <code>this</code> for easy method chaining 3838 */ 3839 public CodeSystem setFilter(List<CodeSystemFilterComponent> theFilter) { 3840 this.filter = theFilter; 3841 return this; 3842 } 3843 3844 public boolean hasFilter() { 3845 if (this.filter == null) 3846 return false; 3847 for (CodeSystemFilterComponent item : this.filter) 3848 if (!item.isEmpty()) 3849 return true; 3850 return false; 3851 } 3852 3853 public CodeSystemFilterComponent addFilter() { //3 3854 CodeSystemFilterComponent t = new CodeSystemFilterComponent(); 3855 if (this.filter == null) 3856 this.filter = new ArrayList<CodeSystemFilterComponent>(); 3857 this.filter.add(t); 3858 return t; 3859 } 3860 3861 public CodeSystem addFilter(CodeSystemFilterComponent t) { //3 3862 if (t == null) 3863 return this; 3864 if (this.filter == null) 3865 this.filter = new ArrayList<CodeSystemFilterComponent>(); 3866 this.filter.add(t); 3867 return this; 3868 } 3869 3870 /** 3871 * @return The first repetition of repeating field {@link #filter}, creating it if it does not already exist 3872 */ 3873 public CodeSystemFilterComponent getFilterFirstRep() { 3874 if (getFilter().isEmpty()) { 3875 addFilter(); 3876 } 3877 return getFilter().get(0); 3878 } 3879 3880 /** 3881 * @return {@link #property} (A property defines an additional slot through which additional information can be provided about a concept.) 3882 */ 3883 public List<PropertyComponent> getProperty() { 3884 if (this.property == null) 3885 this.property = new ArrayList<PropertyComponent>(); 3886 return this.property; 3887 } 3888 3889 /** 3890 * @return Returns a reference to <code>this</code> for easy method chaining 3891 */ 3892 public CodeSystem setProperty(List<PropertyComponent> theProperty) { 3893 this.property = theProperty; 3894 return this; 3895 } 3896 3897 public boolean hasProperty() { 3898 if (this.property == null) 3899 return false; 3900 for (PropertyComponent item : this.property) 3901 if (!item.isEmpty()) 3902 return true; 3903 return false; 3904 } 3905 3906 public PropertyComponent addProperty() { //3 3907 PropertyComponent t = new PropertyComponent(); 3908 if (this.property == null) 3909 this.property = new ArrayList<PropertyComponent>(); 3910 this.property.add(t); 3911 return t; 3912 } 3913 3914 public CodeSystem addProperty(PropertyComponent t) { //3 3915 if (t == null) 3916 return this; 3917 if (this.property == null) 3918 this.property = new ArrayList<PropertyComponent>(); 3919 this.property.add(t); 3920 return this; 3921 } 3922 3923 /** 3924 * @return The first repetition of repeating field {@link #property}, creating it if it does not already exist 3925 */ 3926 public PropertyComponent getPropertyFirstRep() { 3927 if (getProperty().isEmpty()) { 3928 addProperty(); 3929 } 3930 return getProperty().get(0); 3931 } 3932 3933 /** 3934 * @return {@link #concept} (Concepts that are in the code system. The concept definitions are inherently hierarchical, but the definitions must be consulted to determine what the meaning of the hierarchical relationships are.) 3935 */ 3936 public List<ConceptDefinitionComponent> getConcept() { 3937 if (this.concept == null) 3938 this.concept = new ArrayList<ConceptDefinitionComponent>(); 3939 return this.concept; 3940 } 3941 3942 /** 3943 * @return Returns a reference to <code>this</code> for easy method chaining 3944 */ 3945 public CodeSystem setConcept(List<ConceptDefinitionComponent> theConcept) { 3946 this.concept = theConcept; 3947 return this; 3948 } 3949 3950 public boolean hasConcept() { 3951 if (this.concept == null) 3952 return false; 3953 for (ConceptDefinitionComponent item : this.concept) 3954 if (!item.isEmpty()) 3955 return true; 3956 return false; 3957 } 3958 3959 public ConceptDefinitionComponent addConcept() { //3 3960 ConceptDefinitionComponent t = new ConceptDefinitionComponent(); 3961 if (this.concept == null) 3962 this.concept = new ArrayList<ConceptDefinitionComponent>(); 3963 this.concept.add(t); 3964 return t; 3965 } 3966 3967 public CodeSystem addConcept(ConceptDefinitionComponent t) { //3 3968 if (t == null) 3969 return this; 3970 if (this.concept == null) 3971 this.concept = new ArrayList<ConceptDefinitionComponent>(); 3972 this.concept.add(t); 3973 return this; 3974 } 3975 3976 /** 3977 * @return The first repetition of repeating field {@link #concept}, creating it if it does not already exist 3978 */ 3979 public ConceptDefinitionComponent getConceptFirstRep() { 3980 if (getConcept().isEmpty()) { 3981 addConcept(); 3982 } 3983 return getConcept().get(0); 3984 } 3985 3986 protected void listChildren(List<Property> children) { 3987 super.listChildren(children); 3988 children.add(new Property("url", "uri", "An absolute URI that is used to identify this code system when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this code system is (or will be) published. The URL SHOULD include the major version of the code system. For more information see [Technical and Business Versions](resource.html#versions). This is used in [Coding]{datatypes.html#Coding}.system.", 0, 1, url)); 3989 children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this code system when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, 1, identifier)); 3990 children.add(new Property("version", "string", "The identifier that is used to identify this version of the code system when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the code system author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. This is used in [Coding]{datatypes.html#Coding}.version.", 0, 1, version)); 3991 children.add(new Property("name", "string", "A natural language name identifying the code system. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name)); 3992 children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the code system.", 0, 1, title)); 3993 children.add(new Property("status", "code", "The status of this code system. Enables tracking the life-cycle of the content.", 0, 1, status)); 3994 children.add(new Property("experimental", "boolean", "A boolean value to indicate that this code system is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental)); 3995 children.add(new Property("date", "dateTime", "The date (and optionally time) when the code system was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the code system changes.", 0, 1, date)); 3996 children.add(new Property("publisher", "string", "The name of the individual or organization that published the code system.", 0, 1, publisher)); 3997 children.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact)); 3998 children.add(new Property("description", "markdown", "A free text natural language description of the code system from a consumer's perspective.", 0, 1, description)); 3999 children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate code system instances.", 0, java.lang.Integer.MAX_VALUE, useContext)); 4000 children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the code system is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction)); 4001 children.add(new Property("purpose", "markdown", "Explaination of why this code system is needed and why it has been designed as it has.", 0, 1, purpose)); 4002 children.add(new Property("copyright", "markdown", "A copyright statement relating to the code system and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the code system.", 0, 1, copyright)); 4003 children.add(new Property("caseSensitive", "boolean", "If code comparison is case sensitive when codes within this system are compared to each other.", 0, 1, caseSensitive)); 4004 children.add(new Property("valueSet", "uri", "Canonical URL of value set that contains the entire code system.", 0, 1, valueSet)); 4005 children.add(new Property("hierarchyMeaning", "code", "The meaning of the hierarchy of concepts.", 0, 1, hierarchyMeaning)); 4006 children.add(new Property("compositional", "boolean", "True If code system defines a post-composition grammar.", 0, 1, compositional)); 4007 children.add(new Property("versionNeeded", "boolean", "This flag is used to signify that the code system has not (or does not) maintain the definitions, and a version must be specified when referencing this code system.", 0, 1, versionNeeded)); 4008 children.add(new Property("content", "code", "How much of the content of the code system - the concepts and codes it defines - are represented in this resource.", 0, 1, content)); 4009 children.add(new Property("count", "unsignedInt", "The total number of concepts defined by the code system. Where the code system has a compositional grammar, the count refers to the number of base (primitive) concepts.", 0, 1, count)); 4010 children.add(new Property("filter", "", "A filter that can be used in a value set compose statement when selecting concepts using a filter.", 0, java.lang.Integer.MAX_VALUE, filter)); 4011 children.add(new Property("property", "", "A property defines an additional slot through which additional information can be provided about a concept.", 0, java.lang.Integer.MAX_VALUE, property)); 4012 children.add(new Property("concept", "", "Concepts that are in the code system. The concept definitions are inherently hierarchical, but the definitions must be consulted to determine what the meaning of the hierarchical relationships are.", 0, java.lang.Integer.MAX_VALUE, concept)); 4013 } 4014 4015 @Override 4016 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4017 switch (_hash) { 4018 case 116079: /*url*/ return new Property("url", "uri", "An absolute URI that is used to identify this code system when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this code system is (or will be) published. The URL SHOULD include the major version of the code system. For more information see [Technical and Business Versions](resource.html#versions). This is used in [Coding]{datatypes.html#Coding}.system.", 0, 1, url); 4019 case -1618432855: /*identifier*/ return new Property("identifier", "Identifier", "A formal identifier that is used to identify this code system when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, 1, identifier); 4020 case 351608024: /*version*/ return new Property("version", "string", "The identifier that is used to identify this version of the code system when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the code system author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. This is used in [Coding]{datatypes.html#Coding}.version.", 0, 1, version); 4021 case 3373707: /*name*/ return new Property("name", "string", "A natural language name identifying the code system. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name); 4022 case 110371416: /*title*/ return new Property("title", "string", "A short, descriptive, user-friendly title for the code system.", 0, 1, title); 4023 case -892481550: /*status*/ return new Property("status", "code", "The status of this code system. Enables tracking the life-cycle of the content.", 0, 1, status); 4024 case -404562712: /*experimental*/ return new Property("experimental", "boolean", "A boolean value to indicate that this code system is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental); 4025 case 3076014: /*date*/ return new Property("date", "dateTime", "The date (and optionally time) when the code system was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the code system changes.", 0, 1, date); 4026 case 1447404028: /*publisher*/ return new Property("publisher", "string", "The name of the individual or organization that published the code system.", 0, 1, publisher); 4027 case 951526432: /*contact*/ return new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact); 4028 case -1724546052: /*description*/ return new Property("description", "markdown", "A free text natural language description of the code system from a consumer's perspective.", 0, 1, description); 4029 case -669707736: /*useContext*/ return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate code system instances.", 0, java.lang.Integer.MAX_VALUE, useContext); 4030 case -507075711: /*jurisdiction*/ return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the code system is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction); 4031 case -220463842: /*purpose*/ return new Property("purpose", "markdown", "Explaination of why this code system is needed and why it has been designed as it has.", 0, 1, purpose); 4032 case 1522889671: /*copyright*/ return new Property("copyright", "markdown", "A copyright statement relating to the code system and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the code system.", 0, 1, copyright); 4033 case -35616442: /*caseSensitive*/ return new Property("caseSensitive", "boolean", "If code comparison is case sensitive when codes within this system are compared to each other.", 0, 1, caseSensitive); 4034 case -1410174671: /*valueSet*/ return new Property("valueSet", "uri", "Canonical URL of value set that contains the entire code system.", 0, 1, valueSet); 4035 case 1913078280: /*hierarchyMeaning*/ return new Property("hierarchyMeaning", "code", "The meaning of the hierarchy of concepts.", 0, 1, hierarchyMeaning); 4036 case 1248023381: /*compositional*/ return new Property("compositional", "boolean", "True If code system defines a post-composition grammar.", 0, 1, compositional); 4037 case 617270957: /*versionNeeded*/ return new Property("versionNeeded", "boolean", "This flag is used to signify that the code system has not (or does not) maintain the definitions, and a version must be specified when referencing this code system.", 0, 1, versionNeeded); 4038 case 951530617: /*content*/ return new Property("content", "code", "How much of the content of the code system - the concepts and codes it defines - are represented in this resource.", 0, 1, content); 4039 case 94851343: /*count*/ return new Property("count", "unsignedInt", "The total number of concepts defined by the code system. Where the code system has a compositional grammar, the count refers to the number of base (primitive) concepts.", 0, 1, count); 4040 case -1274492040: /*filter*/ return new Property("filter", "", "A filter that can be used in a value set compose statement when selecting concepts using a filter.", 0, java.lang.Integer.MAX_VALUE, filter); 4041 case -993141291: /*property*/ return new Property("property", "", "A property defines an additional slot through which additional information can be provided about a concept.", 0, java.lang.Integer.MAX_VALUE, property); 4042 case 951024232: /*concept*/ return new Property("concept", "", "Concepts that are in the code system. The concept definitions are inherently hierarchical, but the definitions must be consulted to determine what the meaning of the hierarchical relationships are.", 0, java.lang.Integer.MAX_VALUE, concept); 4043 default: return super.getNamedProperty(_hash, _name, _checkValid); 4044 } 4045 4046 } 4047 4048 @Override 4049 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4050 switch (hash) { 4051 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType 4052 case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : new Base[] {this.identifier}; // Identifier 4053 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 4054 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 4055 case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType 4056 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus> 4057 case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType 4058 case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType 4059 case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType 4060 case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 4061 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 4062 case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 4063 case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 4064 case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType 4065 case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType 4066 case -35616442: /*caseSensitive*/ return this.caseSensitive == null ? new Base[0] : new Base[] {this.caseSensitive}; // BooleanType 4067 case -1410174671: /*valueSet*/ return this.valueSet == null ? new Base[0] : new Base[] {this.valueSet}; // UriType 4068 case 1913078280: /*hierarchyMeaning*/ return this.hierarchyMeaning == null ? new Base[0] : new Base[] {this.hierarchyMeaning}; // Enumeration<CodeSystemHierarchyMeaning> 4069 case 1248023381: /*compositional*/ return this.compositional == null ? new Base[0] : new Base[] {this.compositional}; // BooleanType 4070 case 617270957: /*versionNeeded*/ return this.versionNeeded == null ? new Base[0] : new Base[] {this.versionNeeded}; // BooleanType 4071 case 951530617: /*content*/ return this.content == null ? new Base[0] : new Base[] {this.content}; // Enumeration<CodeSystemContentMode> 4072 case 94851343: /*count*/ return this.count == null ? new Base[0] : new Base[] {this.count}; // UnsignedIntType 4073 case -1274492040: /*filter*/ return this.filter == null ? new Base[0] : this.filter.toArray(new Base[this.filter.size()]); // CodeSystemFilterComponent 4074 case -993141291: /*property*/ return this.property == null ? new Base[0] : this.property.toArray(new Base[this.property.size()]); // PropertyComponent 4075 case 951024232: /*concept*/ return this.concept == null ? new Base[0] : this.concept.toArray(new Base[this.concept.size()]); // ConceptDefinitionComponent 4076 default: return super.getProperty(hash, name, checkValid); 4077 } 4078 4079 } 4080 4081 @Override 4082 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4083 switch (hash) { 4084 case 116079: // url 4085 this.url = castToUri(value); // UriType 4086 return value; 4087 case -1618432855: // identifier 4088 this.identifier = castToIdentifier(value); // Identifier 4089 return value; 4090 case 351608024: // version 4091 this.version = castToString(value); // StringType 4092 return value; 4093 case 3373707: // name 4094 this.name = castToString(value); // StringType 4095 return value; 4096 case 110371416: // title 4097 this.title = castToString(value); // StringType 4098 return value; 4099 case -892481550: // status 4100 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 4101 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 4102 return value; 4103 case -404562712: // experimental 4104 this.experimental = castToBoolean(value); // BooleanType 4105 return value; 4106 case 3076014: // date 4107 this.date = castToDateTime(value); // DateTimeType 4108 return value; 4109 case 1447404028: // publisher 4110 this.publisher = castToString(value); // StringType 4111 return value; 4112 case 951526432: // contact 4113 this.getContact().add(castToContactDetail(value)); // ContactDetail 4114 return value; 4115 case -1724546052: // description 4116 this.description = castToMarkdown(value); // MarkdownType 4117 return value; 4118 case -669707736: // useContext 4119 this.getUseContext().add(castToUsageContext(value)); // UsageContext 4120 return value; 4121 case -507075711: // jurisdiction 4122 this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept 4123 return value; 4124 case -220463842: // purpose 4125 this.purpose = castToMarkdown(value); // MarkdownType 4126 return value; 4127 case 1522889671: // copyright 4128 this.copyright = castToMarkdown(value); // MarkdownType 4129 return value; 4130 case -35616442: // caseSensitive 4131 this.caseSensitive = castToBoolean(value); // BooleanType 4132 return value; 4133 case -1410174671: // valueSet 4134 this.valueSet = castToUri(value); // UriType 4135 return value; 4136 case 1913078280: // hierarchyMeaning 4137 value = new CodeSystemHierarchyMeaningEnumFactory().fromType(castToCode(value)); 4138 this.hierarchyMeaning = (Enumeration) value; // Enumeration<CodeSystemHierarchyMeaning> 4139 return value; 4140 case 1248023381: // compositional 4141 this.compositional = castToBoolean(value); // BooleanType 4142 return value; 4143 case 617270957: // versionNeeded 4144 this.versionNeeded = castToBoolean(value); // BooleanType 4145 return value; 4146 case 951530617: // content 4147 value = new CodeSystemContentModeEnumFactory().fromType(castToCode(value)); 4148 this.content = (Enumeration) value; // Enumeration<CodeSystemContentMode> 4149 return value; 4150 case 94851343: // count 4151 this.count = castToUnsignedInt(value); // UnsignedIntType 4152 return value; 4153 case -1274492040: // filter 4154 this.getFilter().add((CodeSystemFilterComponent) value); // CodeSystemFilterComponent 4155 return value; 4156 case -993141291: // property 4157 this.getProperty().add((PropertyComponent) value); // PropertyComponent 4158 return value; 4159 case 951024232: // concept 4160 this.getConcept().add((ConceptDefinitionComponent) value); // ConceptDefinitionComponent 4161 return value; 4162 default: return super.setProperty(hash, name, value); 4163 } 4164 4165 } 4166 4167 @Override 4168 public Base setProperty(String name, Base value) throws FHIRException { 4169 if (name.equals("url")) { 4170 this.url = castToUri(value); // UriType 4171 } else if (name.equals("identifier")) { 4172 this.identifier = castToIdentifier(value); // Identifier 4173 } else if (name.equals("version")) { 4174 this.version = castToString(value); // StringType 4175 } else if (name.equals("name")) { 4176 this.name = castToString(value); // StringType 4177 } else if (name.equals("title")) { 4178 this.title = castToString(value); // StringType 4179 } else if (name.equals("status")) { 4180 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 4181 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 4182 } else if (name.equals("experimental")) { 4183 this.experimental = castToBoolean(value); // BooleanType 4184 } else if (name.equals("date")) { 4185 this.date = castToDateTime(value); // DateTimeType 4186 } else if (name.equals("publisher")) { 4187 this.publisher = castToString(value); // StringType 4188 } else if (name.equals("contact")) { 4189 this.getContact().add(castToContactDetail(value)); 4190 } else if (name.equals("description")) { 4191 this.description = castToMarkdown(value); // MarkdownType 4192 } else if (name.equals("useContext")) { 4193 this.getUseContext().add(castToUsageContext(value)); 4194 } else if (name.equals("jurisdiction")) { 4195 this.getJurisdiction().add(castToCodeableConcept(value)); 4196 } else if (name.equals("purpose")) { 4197 this.purpose = castToMarkdown(value); // MarkdownType 4198 } else if (name.equals("copyright")) { 4199 this.copyright = castToMarkdown(value); // MarkdownType 4200 } else if (name.equals("caseSensitive")) { 4201 this.caseSensitive = castToBoolean(value); // BooleanType 4202 } else if (name.equals("valueSet")) { 4203 this.valueSet = castToUri(value); // UriType 4204 } else if (name.equals("hierarchyMeaning")) { 4205 value = new CodeSystemHierarchyMeaningEnumFactory().fromType(castToCode(value)); 4206 this.hierarchyMeaning = (Enumeration) value; // Enumeration<CodeSystemHierarchyMeaning> 4207 } else if (name.equals("compositional")) { 4208 this.compositional = castToBoolean(value); // BooleanType 4209 } else if (name.equals("versionNeeded")) { 4210 this.versionNeeded = castToBoolean(value); // BooleanType 4211 } else if (name.equals("content")) { 4212 value = new CodeSystemContentModeEnumFactory().fromType(castToCode(value)); 4213 this.content = (Enumeration) value; // Enumeration<CodeSystemContentMode> 4214 } else if (name.equals("count")) { 4215 this.count = castToUnsignedInt(value); // UnsignedIntType 4216 } else if (name.equals("filter")) { 4217 this.getFilter().add((CodeSystemFilterComponent) value); 4218 } else if (name.equals("property")) { 4219 this.getProperty().add((PropertyComponent) value); 4220 } else if (name.equals("concept")) { 4221 this.getConcept().add((ConceptDefinitionComponent) value); 4222 } else 4223 return super.setProperty(name, value); 4224 return value; 4225 } 4226 4227 @Override 4228 public Base makeProperty(int hash, String name) throws FHIRException { 4229 switch (hash) { 4230 case 116079: return getUrlElement(); 4231 case -1618432855: return getIdentifier(); 4232 case 351608024: return getVersionElement(); 4233 case 3373707: return getNameElement(); 4234 case 110371416: return getTitleElement(); 4235 case -892481550: return getStatusElement(); 4236 case -404562712: return getExperimentalElement(); 4237 case 3076014: return getDateElement(); 4238 case 1447404028: return getPublisherElement(); 4239 case 951526432: return addContact(); 4240 case -1724546052: return getDescriptionElement(); 4241 case -669707736: return addUseContext(); 4242 case -507075711: return addJurisdiction(); 4243 case -220463842: return getPurposeElement(); 4244 case 1522889671: return getCopyrightElement(); 4245 case -35616442: return getCaseSensitiveElement(); 4246 case -1410174671: return getValueSetElement(); 4247 case 1913078280: return getHierarchyMeaningElement(); 4248 case 1248023381: return getCompositionalElement(); 4249 case 617270957: return getVersionNeededElement(); 4250 case 951530617: return getContentElement(); 4251 case 94851343: return getCountElement(); 4252 case -1274492040: return addFilter(); 4253 case -993141291: return addProperty(); 4254 case 951024232: return addConcept(); 4255 default: return super.makeProperty(hash, name); 4256 } 4257 4258 } 4259 4260 @Override 4261 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4262 switch (hash) { 4263 case 116079: /*url*/ return new String[] {"uri"}; 4264 case -1618432855: /*identifier*/ return new String[] {"Identifier"}; 4265 case 351608024: /*version*/ return new String[] {"string"}; 4266 case 3373707: /*name*/ return new String[] {"string"}; 4267 case 110371416: /*title*/ return new String[] {"string"}; 4268 case -892481550: /*status*/ return new String[] {"code"}; 4269 case -404562712: /*experimental*/ return new String[] {"boolean"}; 4270 case 3076014: /*date*/ return new String[] {"dateTime"}; 4271 case 1447404028: /*publisher*/ return new String[] {"string"}; 4272 case 951526432: /*contact*/ return new String[] {"ContactDetail"}; 4273 case -1724546052: /*description*/ return new String[] {"markdown"}; 4274 case -669707736: /*useContext*/ return new String[] {"UsageContext"}; 4275 case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"}; 4276 case -220463842: /*purpose*/ return new String[] {"markdown"}; 4277 case 1522889671: /*copyright*/ return new String[] {"markdown"}; 4278 case -35616442: /*caseSensitive*/ return new String[] {"boolean"}; 4279 case -1410174671: /*valueSet*/ return new String[] {"uri"}; 4280 case 1913078280: /*hierarchyMeaning*/ return new String[] {"code"}; 4281 case 1248023381: /*compositional*/ return new String[] {"boolean"}; 4282 case 617270957: /*versionNeeded*/ return new String[] {"boolean"}; 4283 case 951530617: /*content*/ return new String[] {"code"}; 4284 case 94851343: /*count*/ return new String[] {"unsignedInt"}; 4285 case -1274492040: /*filter*/ return new String[] {}; 4286 case -993141291: /*property*/ return new String[] {}; 4287 case 951024232: /*concept*/ return new String[] {}; 4288 default: return super.getTypesForProperty(hash, name); 4289 } 4290 4291 } 4292 4293 @Override 4294 public Base addChild(String name) throws FHIRException { 4295 if (name.equals("url")) { 4296 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.url"); 4297 } 4298 else if (name.equals("identifier")) { 4299 this.identifier = new Identifier(); 4300 return this.identifier; 4301 } 4302 else if (name.equals("version")) { 4303 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.version"); 4304 } 4305 else if (name.equals("name")) { 4306 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.name"); 4307 } 4308 else if (name.equals("title")) { 4309 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.title"); 4310 } 4311 else if (name.equals("status")) { 4312 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.status"); 4313 } 4314 else if (name.equals("experimental")) { 4315 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.experimental"); 4316 } 4317 else if (name.equals("date")) { 4318 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.date"); 4319 } 4320 else if (name.equals("publisher")) { 4321 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.publisher"); 4322 } 4323 else if (name.equals("contact")) { 4324 return addContact(); 4325 } 4326 else if (name.equals("description")) { 4327 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.description"); 4328 } 4329 else if (name.equals("useContext")) { 4330 return addUseContext(); 4331 } 4332 else if (name.equals("jurisdiction")) { 4333 return addJurisdiction(); 4334 } 4335 else if (name.equals("purpose")) { 4336 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.purpose"); 4337 } 4338 else if (name.equals("copyright")) { 4339 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.copyright"); 4340 } 4341 else if (name.equals("caseSensitive")) { 4342 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.caseSensitive"); 4343 } 4344 else if (name.equals("valueSet")) { 4345 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.valueSet"); 4346 } 4347 else if (name.equals("hierarchyMeaning")) { 4348 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.hierarchyMeaning"); 4349 } 4350 else if (name.equals("compositional")) { 4351 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.compositional"); 4352 } 4353 else if (name.equals("versionNeeded")) { 4354 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.versionNeeded"); 4355 } 4356 else if (name.equals("content")) { 4357 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.content"); 4358 } 4359 else if (name.equals("count")) { 4360 throw new FHIRException("Cannot call addChild on a primitive type CodeSystem.count"); 4361 } 4362 else if (name.equals("filter")) { 4363 return addFilter(); 4364 } 4365 else if (name.equals("property")) { 4366 return addProperty(); 4367 } 4368 else if (name.equals("concept")) { 4369 return addConcept(); 4370 } 4371 else 4372 return super.addChild(name); 4373 } 4374 4375 public String fhirType() { 4376 return "CodeSystem"; 4377 4378 } 4379 4380 public CodeSystem copy() { 4381 CodeSystem dst = new CodeSystem(); 4382 copyValues(dst); 4383 dst.url = url == null ? null : url.copy(); 4384 dst.identifier = identifier == null ? null : identifier.copy(); 4385 dst.version = version == null ? null : version.copy(); 4386 dst.name = name == null ? null : name.copy(); 4387 dst.title = title == null ? null : title.copy(); 4388 dst.status = status == null ? null : status.copy(); 4389 dst.experimental = experimental == null ? null : experimental.copy(); 4390 dst.date = date == null ? null : date.copy(); 4391 dst.publisher = publisher == null ? null : publisher.copy(); 4392 if (contact != null) { 4393 dst.contact = new ArrayList<ContactDetail>(); 4394 for (ContactDetail i : contact) 4395 dst.contact.add(i.copy()); 4396 }; 4397 dst.description = description == null ? null : description.copy(); 4398 if (useContext != null) { 4399 dst.useContext = new ArrayList<UsageContext>(); 4400 for (UsageContext i : useContext) 4401 dst.useContext.add(i.copy()); 4402 }; 4403 if (jurisdiction != null) { 4404 dst.jurisdiction = new ArrayList<CodeableConcept>(); 4405 for (CodeableConcept i : jurisdiction) 4406 dst.jurisdiction.add(i.copy()); 4407 }; 4408 dst.purpose = purpose == null ? null : purpose.copy(); 4409 dst.copyright = copyright == null ? null : copyright.copy(); 4410 dst.caseSensitive = caseSensitive == null ? null : caseSensitive.copy(); 4411 dst.valueSet = valueSet == null ? null : valueSet.copy(); 4412 dst.hierarchyMeaning = hierarchyMeaning == null ? null : hierarchyMeaning.copy(); 4413 dst.compositional = compositional == null ? null : compositional.copy(); 4414 dst.versionNeeded = versionNeeded == null ? null : versionNeeded.copy(); 4415 dst.content = content == null ? null : content.copy(); 4416 dst.count = count == null ? null : count.copy(); 4417 if (filter != null) { 4418 dst.filter = new ArrayList<CodeSystemFilterComponent>(); 4419 for (CodeSystemFilterComponent i : filter) 4420 dst.filter.add(i.copy()); 4421 }; 4422 if (property != null) { 4423 dst.property = new ArrayList<PropertyComponent>(); 4424 for (PropertyComponent i : property) 4425 dst.property.add(i.copy()); 4426 }; 4427 if (concept != null) { 4428 dst.concept = new ArrayList<ConceptDefinitionComponent>(); 4429 for (ConceptDefinitionComponent i : concept) 4430 dst.concept.add(i.copy()); 4431 }; 4432 return dst; 4433 } 4434 4435 protected CodeSystem typedCopy() { 4436 return copy(); 4437 } 4438 4439 @Override 4440 public boolean equalsDeep(Base other_) { 4441 if (!super.equalsDeep(other_)) 4442 return false; 4443 if (!(other_ instanceof CodeSystem)) 4444 return false; 4445 CodeSystem o = (CodeSystem) other_; 4446 return compareDeep(identifier, o.identifier, true) && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true) 4447 && compareDeep(caseSensitive, o.caseSensitive, true) && compareDeep(valueSet, o.valueSet, true) 4448 && compareDeep(hierarchyMeaning, o.hierarchyMeaning, true) && compareDeep(compositional, o.compositional, true) 4449 && compareDeep(versionNeeded, o.versionNeeded, true) && compareDeep(content, o.content, true) && compareDeep(count, o.count, true) 4450 && compareDeep(filter, o.filter, true) && compareDeep(property, o.property, true) && compareDeep(concept, o.concept, true) 4451 ; 4452 } 4453 4454 @Override 4455 public boolean equalsShallow(Base other_) { 4456 if (!super.equalsShallow(other_)) 4457 return false; 4458 if (!(other_ instanceof CodeSystem)) 4459 return false; 4460 CodeSystem o = (CodeSystem) other_; 4461 return compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(caseSensitive, o.caseSensitive, true) 4462 && compareValues(valueSet, o.valueSet, true) && compareValues(hierarchyMeaning, o.hierarchyMeaning, true) 4463 && compareValues(compositional, o.compositional, true) && compareValues(versionNeeded, o.versionNeeded, true) 4464 && compareValues(content, o.content, true) && compareValues(count, o.count, true); 4465 } 4466 4467 public boolean isEmpty() { 4468 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, purpose, copyright 4469 , caseSensitive, valueSet, hierarchyMeaning, compositional, versionNeeded, content 4470 , count, filter, property, concept); 4471 } 4472 4473 @Override 4474 public ResourceType getResourceType() { 4475 return ResourceType.CodeSystem; 4476 } 4477 4478 /** 4479 * Search parameter: <b>date</b> 4480 * <p> 4481 * Description: <b>The code system publication date</b><br> 4482 * Type: <b>date</b><br> 4483 * Path: <b>CodeSystem.date</b><br> 4484 * </p> 4485 */ 4486 @SearchParamDefinition(name="date", path="CodeSystem.date", description="The code system publication date", type="date" ) 4487 public static final String SP_DATE = "date"; 4488 /** 4489 * <b>Fluent Client</b> search parameter constant for <b>date</b> 4490 * <p> 4491 * Description: <b>The code system publication date</b><br> 4492 * Type: <b>date</b><br> 4493 * Path: <b>CodeSystem.date</b><br> 4494 * </p> 4495 */ 4496 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE); 4497 4498 /** 4499 * Search parameter: <b>identifier</b> 4500 * <p> 4501 * Description: <b>External identifier for the code system</b><br> 4502 * Type: <b>token</b><br> 4503 * Path: <b>CodeSystem.identifier</b><br> 4504 * </p> 4505 */ 4506 @SearchParamDefinition(name="identifier", path="CodeSystem.identifier", description="External identifier for the code system", type="token" ) 4507 public static final String SP_IDENTIFIER = "identifier"; 4508 /** 4509 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 4510 * <p> 4511 * Description: <b>External identifier for the code system</b><br> 4512 * Type: <b>token</b><br> 4513 * Path: <b>CodeSystem.identifier</b><br> 4514 * </p> 4515 */ 4516 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER); 4517 4518 /** 4519 * Search parameter: <b>code</b> 4520 * <p> 4521 * Description: <b>A code defined in the code system</b><br> 4522 * Type: <b>token</b><br> 4523 * Path: <b>CodeSystem.concept.code</b><br> 4524 * </p> 4525 */ 4526 @SearchParamDefinition(name="code", path="CodeSystem.concept.code", description="A code defined in the code system", type="token" ) 4527 public static final String SP_CODE = "code"; 4528 /** 4529 * <b>Fluent Client</b> search parameter constant for <b>code</b> 4530 * <p> 4531 * Description: <b>A code defined in the code system</b><br> 4532 * Type: <b>token</b><br> 4533 * Path: <b>CodeSystem.concept.code</b><br> 4534 * </p> 4535 */ 4536 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CODE); 4537 4538 /** 4539 * Search parameter: <b>content-mode</b> 4540 * <p> 4541 * Description: <b>not-present | example | fragment | complete</b><br> 4542 * Type: <b>token</b><br> 4543 * Path: <b>CodeSystem.content</b><br> 4544 * </p> 4545 */ 4546 @SearchParamDefinition(name="content-mode", path="CodeSystem.content", description="not-present | example | fragment | complete", type="token" ) 4547 public static final String SP_CONTENT_MODE = "content-mode"; 4548 /** 4549 * <b>Fluent Client</b> search parameter constant for <b>content-mode</b> 4550 * <p> 4551 * Description: <b>not-present | example | fragment | complete</b><br> 4552 * Type: <b>token</b><br> 4553 * Path: <b>CodeSystem.content</b><br> 4554 * </p> 4555 */ 4556 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTENT_MODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTENT_MODE); 4557 4558 /** 4559 * Search parameter: <b>jurisdiction</b> 4560 * <p> 4561 * Description: <b>Intended jurisdiction for the code system</b><br> 4562 * Type: <b>token</b><br> 4563 * Path: <b>CodeSystem.jurisdiction</b><br> 4564 * </p> 4565 */ 4566 @SearchParamDefinition(name="jurisdiction", path="CodeSystem.jurisdiction", description="Intended jurisdiction for the code system", type="token" ) 4567 public static final String SP_JURISDICTION = "jurisdiction"; 4568 /** 4569 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 4570 * <p> 4571 * Description: <b>Intended jurisdiction for the code system</b><br> 4572 * Type: <b>token</b><br> 4573 * Path: <b>CodeSystem.jurisdiction</b><br> 4574 * </p> 4575 */ 4576 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION); 4577 4578 /** 4579 * Search parameter: <b>description</b> 4580 * <p> 4581 * Description: <b>The description of the code system</b><br> 4582 * Type: <b>string</b><br> 4583 * Path: <b>CodeSystem.description</b><br> 4584 * </p> 4585 */ 4586 @SearchParamDefinition(name="description", path="CodeSystem.description", description="The description of the code system", type="string" ) 4587 public static final String SP_DESCRIPTION = "description"; 4588 /** 4589 * <b>Fluent Client</b> search parameter constant for <b>description</b> 4590 * <p> 4591 * Description: <b>The description of the code system</b><br> 4592 * Type: <b>string</b><br> 4593 * Path: <b>CodeSystem.description</b><br> 4594 * </p> 4595 */ 4596 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION); 4597 4598 /** 4599 * Search parameter: <b>language</b> 4600 * <p> 4601 * Description: <b>A language in which a designation is provided</b><br> 4602 * Type: <b>token</b><br> 4603 * Path: <b>CodeSystem.concept.designation.language</b><br> 4604 * </p> 4605 */ 4606 @SearchParamDefinition(name="language", path="CodeSystem.concept.designation.language", description="A language in which a designation is provided", type="token" ) 4607 public static final String SP_LANGUAGE = "language"; 4608 /** 4609 * <b>Fluent Client</b> search parameter constant for <b>language</b> 4610 * <p> 4611 * Description: <b>A language in which a designation is provided</b><br> 4612 * Type: <b>token</b><br> 4613 * Path: <b>CodeSystem.concept.designation.language</b><br> 4614 * </p> 4615 */ 4616 public static final ca.uhn.fhir.rest.gclient.TokenClientParam LANGUAGE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_LANGUAGE); 4617 4618 /** 4619 * Search parameter: <b>title</b> 4620 * <p> 4621 * Description: <b>The human-friendly name of the code system</b><br> 4622 * Type: <b>string</b><br> 4623 * Path: <b>CodeSystem.title</b><br> 4624 * </p> 4625 */ 4626 @SearchParamDefinition(name="title", path="CodeSystem.title", description="The human-friendly name of the code system", type="string" ) 4627 public static final String SP_TITLE = "title"; 4628 /** 4629 * <b>Fluent Client</b> search parameter constant for <b>title</b> 4630 * <p> 4631 * Description: <b>The human-friendly name of the code system</b><br> 4632 * Type: <b>string</b><br> 4633 * Path: <b>CodeSystem.title</b><br> 4634 * </p> 4635 */ 4636 public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE); 4637 4638 /** 4639 * Search parameter: <b>version</b> 4640 * <p> 4641 * Description: <b>The business version of the code system</b><br> 4642 * Type: <b>token</b><br> 4643 * Path: <b>CodeSystem.version</b><br> 4644 * </p> 4645 */ 4646 @SearchParamDefinition(name="version", path="CodeSystem.version", description="The business version of the code system", type="token" ) 4647 public static final String SP_VERSION = "version"; 4648 /** 4649 * <b>Fluent Client</b> search parameter constant for <b>version</b> 4650 * <p> 4651 * Description: <b>The business version of the code system</b><br> 4652 * Type: <b>token</b><br> 4653 * Path: <b>CodeSystem.version</b><br> 4654 * </p> 4655 */ 4656 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION); 4657 4658 /** 4659 * Search parameter: <b>url</b> 4660 * <p> 4661 * Description: <b>The uri that identifies the code system</b><br> 4662 * Type: <b>uri</b><br> 4663 * Path: <b>CodeSystem.url</b><br> 4664 * </p> 4665 */ 4666 @SearchParamDefinition(name="url", path="CodeSystem.url", description="The uri that identifies the code system", type="uri" ) 4667 public static final String SP_URL = "url"; 4668 /** 4669 * <b>Fluent Client</b> search parameter constant for <b>url</b> 4670 * <p> 4671 * Description: <b>The uri that identifies the code system</b><br> 4672 * Type: <b>uri</b><br> 4673 * Path: <b>CodeSystem.url</b><br> 4674 * </p> 4675 */ 4676 public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL); 4677 4678 /** 4679 * Search parameter: <b>system</b> 4680 * <p> 4681 * Description: <b>The system for any codes defined by this code system (same as 'url')</b><br> 4682 * Type: <b>uri</b><br> 4683 * Path: <b>CodeSystem.url</b><br> 4684 * </p> 4685 */ 4686 @SearchParamDefinition(name="system", path="CodeSystem.url", description="The system for any codes defined by this code system (same as 'url')", type="uri" ) 4687 public static final String SP_SYSTEM = "system"; 4688 /** 4689 * <b>Fluent Client</b> search parameter constant for <b>system</b> 4690 * <p> 4691 * Description: <b>The system for any codes defined by this code system (same as 'url')</b><br> 4692 * Type: <b>uri</b><br> 4693 * Path: <b>CodeSystem.url</b><br> 4694 * </p> 4695 */ 4696 public static final ca.uhn.fhir.rest.gclient.UriClientParam SYSTEM = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_SYSTEM); 4697 4698 /** 4699 * Search parameter: <b>name</b> 4700 * <p> 4701 * Description: <b>Computationally friendly name of the code system</b><br> 4702 * Type: <b>string</b><br> 4703 * Path: <b>CodeSystem.name</b><br> 4704 * </p> 4705 */ 4706 @SearchParamDefinition(name="name", path="CodeSystem.name", description="Computationally friendly name of the code system", type="string" ) 4707 public static final String SP_NAME = "name"; 4708 /** 4709 * <b>Fluent Client</b> search parameter constant for <b>name</b> 4710 * <p> 4711 * Description: <b>Computationally friendly name of the code system</b><br> 4712 * Type: <b>string</b><br> 4713 * Path: <b>CodeSystem.name</b><br> 4714 * </p> 4715 */ 4716 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME); 4717 4718 /** 4719 * Search parameter: <b>publisher</b> 4720 * <p> 4721 * Description: <b>Name of the publisher of the code system</b><br> 4722 * Type: <b>string</b><br> 4723 * Path: <b>CodeSystem.publisher</b><br> 4724 * </p> 4725 */ 4726 @SearchParamDefinition(name="publisher", path="CodeSystem.publisher", description="Name of the publisher of the code system", type="string" ) 4727 public static final String SP_PUBLISHER = "publisher"; 4728 /** 4729 * <b>Fluent Client</b> search parameter constant for <b>publisher</b> 4730 * <p> 4731 * Description: <b>Name of the publisher of the code system</b><br> 4732 * Type: <b>string</b><br> 4733 * Path: <b>CodeSystem.publisher</b><br> 4734 * </p> 4735 */ 4736 public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER); 4737 4738 /** 4739 * Search parameter: <b>status</b> 4740 * <p> 4741 * Description: <b>The current status of the code system</b><br> 4742 * Type: <b>token</b><br> 4743 * Path: <b>CodeSystem.status</b><br> 4744 * </p> 4745 */ 4746 @SearchParamDefinition(name="status", path="CodeSystem.status", description="The current status of the code system", type="token" ) 4747 public static final String SP_STATUS = "status"; 4748 /** 4749 * <b>Fluent Client</b> search parameter constant for <b>status</b> 4750 * <p> 4751 * Description: <b>The current status of the code system</b><br> 4752 * Type: <b>token</b><br> 4753 * Path: <b>CodeSystem.status</b><br> 4754 * </p> 4755 */ 4756 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 4757 4758 4759}