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