001package org.hl7.fhir.r4.model; 002 003 004 005/* 006 Copyright (c) 2011+, HL7, Inc. 007 All rights reserved. 008 009 Redistribution and use in source and binary forms, with or without modification, 010 are permitted provided that the following conditions are met: 011 012 * Redistributions of source code must retain the above copyright notice, this 013 list of conditions and the following disclaimer. 014 * Redistributions in binary form must reproduce the above copyright notice, 015 this list of conditions and the following disclaimer in the documentation 016 and/or other materials provided with the distribution. 017 * Neither the name of HL7 nor the names of its contributors may be used to 018 endorse or promote products derived from this software without specific 019 prior written permission. 020 021 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 022 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 023 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 024 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 025 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 026 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 028 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 029 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 030 POSSIBILITY OF SUCH DAMAGE. 031 032*/ 033 034 035// Generated on Tue, May 12, 2020 07:26+1000 for FHIR v4.0.1 036 037import java.util.*; 038 039import org.hl7.fhir.utilities.Utilities; 040import org.hl7.fhir.r4.model.Enumerations.*; 041import ca.uhn.fhir.model.api.annotation.ResourceDef; 042import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 043import ca.uhn.fhir.model.api.annotation.Child; 044import ca.uhn.fhir.model.api.annotation.ChildOrder; 045import ca.uhn.fhir.model.api.annotation.Description; 046import ca.uhn.fhir.model.api.annotation.Block; 047import org.hl7.fhir.instance.model.api.*; 048import org.hl7.fhir.exceptions.FHIRException; 049/** 050 * A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a "System" used within the Identifier and Coding data types. 051 */ 052@ResourceDef(name="NamingSystem", profile="http://hl7.org/fhir/StructureDefinition/NamingSystem") 053@ChildOrder(names={"name", "status", "kind", "date", "publisher", "contact", "responsible", "type", "description", "useContext", "jurisdiction", "usage", "uniqueId"}) 054public class NamingSystem extends MetadataResource { 055 056 public enum NamingSystemType { 057 /** 058 * The naming system is used to define concepts and symbols to represent those concepts; e.g. UCUM, LOINC, NDC code, local lab codes, etc. 059 */ 060 CODESYSTEM, 061 /** 062 * The naming system is used to manage identifiers (e.g. license numbers, order numbers, etc.). 063 */ 064 IDENTIFIER, 065 /** 066 * The naming system is used as the root for other identifiers and naming systems. 067 */ 068 ROOT, 069 /** 070 * added to help the parsers with the generic types 071 */ 072 NULL; 073 public static NamingSystemType fromCode(String codeString) throws FHIRException { 074 if (codeString == null || "".equals(codeString)) 075 return null; 076 if ("codesystem".equals(codeString)) 077 return CODESYSTEM; 078 if ("identifier".equals(codeString)) 079 return IDENTIFIER; 080 if ("root".equals(codeString)) 081 return ROOT; 082 if (Configuration.isAcceptInvalidEnums()) 083 return null; 084 else 085 throw new FHIRException("Unknown NamingSystemType code '"+codeString+"'"); 086 } 087 public String toCode() { 088 switch (this) { 089 case CODESYSTEM: return "codesystem"; 090 case IDENTIFIER: return "identifier"; 091 case ROOT: return "root"; 092 default: return "?"; 093 } 094 } 095 public String getSystem() { 096 switch (this) { 097 case CODESYSTEM: return "http://hl7.org/fhir/namingsystem-type"; 098 case IDENTIFIER: return "http://hl7.org/fhir/namingsystem-type"; 099 case ROOT: return "http://hl7.org/fhir/namingsystem-type"; 100 default: return "?"; 101 } 102 } 103 public String getDefinition() { 104 switch (this) { 105 case CODESYSTEM: return "The naming system is used to define concepts and symbols to represent those concepts; e.g. UCUM, LOINC, NDC code, local lab codes, etc."; 106 case IDENTIFIER: return "The naming system is used to manage identifiers (e.g. license numbers, order numbers, etc.)."; 107 case ROOT: return "The naming system is used as the root for other identifiers and naming systems."; 108 default: return "?"; 109 } 110 } 111 public String getDisplay() { 112 switch (this) { 113 case CODESYSTEM: return "Code System"; 114 case IDENTIFIER: return "Identifier"; 115 case ROOT: return "Root"; 116 default: return "?"; 117 } 118 } 119 } 120 121 public static class NamingSystemTypeEnumFactory implements EnumFactory<NamingSystemType> { 122 public NamingSystemType fromCode(String codeString) throws IllegalArgumentException { 123 if (codeString == null || "".equals(codeString)) 124 if (codeString == null || "".equals(codeString)) 125 return null; 126 if ("codesystem".equals(codeString)) 127 return NamingSystemType.CODESYSTEM; 128 if ("identifier".equals(codeString)) 129 return NamingSystemType.IDENTIFIER; 130 if ("root".equals(codeString)) 131 return NamingSystemType.ROOT; 132 throw new IllegalArgumentException("Unknown NamingSystemType code '"+codeString+"'"); 133 } 134 public Enumeration<NamingSystemType> fromType(Base code) throws FHIRException { 135 if (code == null) 136 return null; 137 if (code.isEmpty()) 138 return new Enumeration<NamingSystemType>(this); 139 String codeString = ((PrimitiveType) code).asStringValue(); 140 if (codeString == null || "".equals(codeString)) 141 return null; 142 if ("codesystem".equals(codeString)) 143 return new Enumeration<NamingSystemType>(this, NamingSystemType.CODESYSTEM); 144 if ("identifier".equals(codeString)) 145 return new Enumeration<NamingSystemType>(this, NamingSystemType.IDENTIFIER); 146 if ("root".equals(codeString)) 147 return new Enumeration<NamingSystemType>(this, NamingSystemType.ROOT); 148 throw new FHIRException("Unknown NamingSystemType code '"+codeString+"'"); 149 } 150 public String toCode(NamingSystemType code) { 151 if (code == NamingSystemType.CODESYSTEM) 152 return "codesystem"; 153 if (code == NamingSystemType.IDENTIFIER) 154 return "identifier"; 155 if (code == NamingSystemType.ROOT) 156 return "root"; 157 return "?"; 158 } 159 public String toSystem(NamingSystemType code) { 160 return code.getSystem(); 161 } 162 } 163 164 public enum NamingSystemIdentifierType { 165 /** 166 * An ISO object identifier; e.g. 1.2.3.4.5. 167 */ 168 OID, 169 /** 170 * A universally unique identifier of the form a5afddf4-e880-459b-876e-e4591b0acc11. 171 */ 172 UUID, 173 /** 174 * A uniform resource identifier (ideally a URL - uniform resource locator); e.g. http://unitsofmeasure.org. 175 */ 176 URI, 177 /** 178 * Some other type of unique identifier; e.g. HL7-assigned reserved string such as LN for LOINC. 179 */ 180 OTHER, 181 /** 182 * added to help the parsers with the generic types 183 */ 184 NULL; 185 public static NamingSystemIdentifierType fromCode(String codeString) throws FHIRException { 186 if (codeString == null || "".equals(codeString)) 187 return null; 188 if ("oid".equals(codeString)) 189 return OID; 190 if ("uuid".equals(codeString)) 191 return UUID; 192 if ("uri".equals(codeString)) 193 return URI; 194 if ("other".equals(codeString)) 195 return OTHER; 196 if (Configuration.isAcceptInvalidEnums()) 197 return null; 198 else 199 throw new FHIRException("Unknown NamingSystemIdentifierType code '"+codeString+"'"); 200 } 201 public String toCode() { 202 switch (this) { 203 case OID: return "oid"; 204 case UUID: return "uuid"; 205 case URI: return "uri"; 206 case OTHER: return "other"; 207 default: return "?"; 208 } 209 } 210 public String getSystem() { 211 switch (this) { 212 case OID: return "http://hl7.org/fhir/namingsystem-identifier-type"; 213 case UUID: return "http://hl7.org/fhir/namingsystem-identifier-type"; 214 case URI: return "http://hl7.org/fhir/namingsystem-identifier-type"; 215 case OTHER: return "http://hl7.org/fhir/namingsystem-identifier-type"; 216 default: return "?"; 217 } 218 } 219 public String getDefinition() { 220 switch (this) { 221 case OID: return "An ISO object identifier; e.g. 1.2.3.4.5."; 222 case UUID: return "A universally unique identifier of the form a5afddf4-e880-459b-876e-e4591b0acc11."; 223 case URI: return "A uniform resource identifier (ideally a URL - uniform resource locator); e.g. http://unitsofmeasure.org."; 224 case OTHER: return "Some other type of unique identifier; e.g. HL7-assigned reserved string such as LN for LOINC."; 225 default: return "?"; 226 } 227 } 228 public String getDisplay() { 229 switch (this) { 230 case OID: return "OID"; 231 case UUID: return "UUID"; 232 case URI: return "URI"; 233 case OTHER: return "Other"; 234 default: return "?"; 235 } 236 } 237 } 238 239 public static class NamingSystemIdentifierTypeEnumFactory implements EnumFactory<NamingSystemIdentifierType> { 240 public NamingSystemIdentifierType fromCode(String codeString) throws IllegalArgumentException { 241 if (codeString == null || "".equals(codeString)) 242 if (codeString == null || "".equals(codeString)) 243 return null; 244 if ("oid".equals(codeString)) 245 return NamingSystemIdentifierType.OID; 246 if ("uuid".equals(codeString)) 247 return NamingSystemIdentifierType.UUID; 248 if ("uri".equals(codeString)) 249 return NamingSystemIdentifierType.URI; 250 if ("other".equals(codeString)) 251 return NamingSystemIdentifierType.OTHER; 252 throw new IllegalArgumentException("Unknown NamingSystemIdentifierType code '"+codeString+"'"); 253 } 254 public Enumeration<NamingSystemIdentifierType> fromType(Base code) throws FHIRException { 255 if (code == null) 256 return null; 257 if (code.isEmpty()) 258 return new Enumeration<NamingSystemIdentifierType>(this); 259 String codeString = ((PrimitiveType) code).asStringValue(); 260 if (codeString == null || "".equals(codeString)) 261 return null; 262 if ("oid".equals(codeString)) 263 return new Enumeration<NamingSystemIdentifierType>(this, NamingSystemIdentifierType.OID); 264 if ("uuid".equals(codeString)) 265 return new Enumeration<NamingSystemIdentifierType>(this, NamingSystemIdentifierType.UUID); 266 if ("uri".equals(codeString)) 267 return new Enumeration<NamingSystemIdentifierType>(this, NamingSystemIdentifierType.URI); 268 if ("other".equals(codeString)) 269 return new Enumeration<NamingSystemIdentifierType>(this, NamingSystemIdentifierType.OTHER); 270 throw new FHIRException("Unknown NamingSystemIdentifierType code '"+codeString+"'"); 271 } 272 public String toCode(NamingSystemIdentifierType code) { 273 if (code == NamingSystemIdentifierType.OID) 274 return "oid"; 275 if (code == NamingSystemIdentifierType.UUID) 276 return "uuid"; 277 if (code == NamingSystemIdentifierType.URI) 278 return "uri"; 279 if (code == NamingSystemIdentifierType.OTHER) 280 return "other"; 281 return "?"; 282 } 283 public String toSystem(NamingSystemIdentifierType code) { 284 return code.getSystem(); 285 } 286 } 287 288 @Block() 289 public static class NamingSystemUniqueIdComponent extends BackboneElement implements IBaseBackboneElement { 290 /** 291 * Identifies the unique identifier scheme used for this particular identifier. 292 */ 293 @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 294 @Description(shortDefinition="oid | uuid | uri | other", formalDefinition="Identifies the unique identifier scheme used for this particular identifier." ) 295 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/namingsystem-identifier-type") 296 protected Enumeration<NamingSystemIdentifierType> type; 297 298 /** 299 * The string that should be sent over the wire to identify the code system or identifier system. 300 */ 301 @Child(name = "value", type = {StringType.class}, order=2, min=1, max=1, modifier=false, summary=true) 302 @Description(shortDefinition="The unique identifier", formalDefinition="The string that should be sent over the wire to identify the code system or identifier system." ) 303 protected StringType value; 304 305 /** 306 * Indicates whether this identifier is the "preferred" identifier of this type. 307 */ 308 @Child(name = "preferred", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=false) 309 @Description(shortDefinition="Is this the id that should be used for this type", formalDefinition="Indicates whether this identifier is the \"preferred\" identifier of this type." ) 310 protected BooleanType preferred; 311 312 /** 313 * Notes about the past or intended usage of this identifier. 314 */ 315 @Child(name = "comment", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false) 316 @Description(shortDefinition="Notes about identifier usage", formalDefinition="Notes about the past or intended usage of this identifier." ) 317 protected StringType comment; 318 319 /** 320 * Identifies the period of time over which this identifier is considered appropriate to refer to the naming system. Outside of this window, the identifier might be non-deterministic. 321 */ 322 @Child(name = "period", type = {Period.class}, order=5, min=0, max=1, modifier=false, summary=false) 323 @Description(shortDefinition="When is identifier valid?", formalDefinition="Identifies the period of time over which this identifier is considered appropriate to refer to the naming system. Outside of this window, the identifier might be non-deterministic." ) 324 protected Period period; 325 326 private static final long serialVersionUID = -1458889328L; 327 328 /** 329 * Constructor 330 */ 331 public NamingSystemUniqueIdComponent() { 332 super(); 333 } 334 335 /** 336 * Constructor 337 */ 338 public NamingSystemUniqueIdComponent(Enumeration<NamingSystemIdentifierType> type, StringType value) { 339 super(); 340 this.type = type; 341 this.value = value; 342 } 343 344 /** 345 * @return {@link #type} (Identifies the unique identifier scheme used for this particular identifier.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 346 */ 347 public Enumeration<NamingSystemIdentifierType> getTypeElement() { 348 if (this.type == null) 349 if (Configuration.errorOnAutoCreate()) 350 throw new Error("Attempt to auto-create NamingSystemUniqueIdComponent.type"); 351 else if (Configuration.doAutoCreate()) 352 this.type = new Enumeration<NamingSystemIdentifierType>(new NamingSystemIdentifierTypeEnumFactory()); // bb 353 return this.type; 354 } 355 356 public boolean hasTypeElement() { 357 return this.type != null && !this.type.isEmpty(); 358 } 359 360 public boolean hasType() { 361 return this.type != null && !this.type.isEmpty(); 362 } 363 364 /** 365 * @param value {@link #type} (Identifies the unique identifier scheme used for this particular identifier.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 366 */ 367 public NamingSystemUniqueIdComponent setTypeElement(Enumeration<NamingSystemIdentifierType> value) { 368 this.type = value; 369 return this; 370 } 371 372 /** 373 * @return Identifies the unique identifier scheme used for this particular identifier. 374 */ 375 public NamingSystemIdentifierType getType() { 376 return this.type == null ? null : this.type.getValue(); 377 } 378 379 /** 380 * @param value Identifies the unique identifier scheme used for this particular identifier. 381 */ 382 public NamingSystemUniqueIdComponent setType(NamingSystemIdentifierType value) { 383 if (this.type == null) 384 this.type = new Enumeration<NamingSystemIdentifierType>(new NamingSystemIdentifierTypeEnumFactory()); 385 this.type.setValue(value); 386 return this; 387 } 388 389 /** 390 * @return {@link #value} (The string that should be sent over the wire to identify the code system or identifier system.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value 391 */ 392 public StringType getValueElement() { 393 if (this.value == null) 394 if (Configuration.errorOnAutoCreate()) 395 throw new Error("Attempt to auto-create NamingSystemUniqueIdComponent.value"); 396 else if (Configuration.doAutoCreate()) 397 this.value = new StringType(); // bb 398 return this.value; 399 } 400 401 public boolean hasValueElement() { 402 return this.value != null && !this.value.isEmpty(); 403 } 404 405 public boolean hasValue() { 406 return this.value != null && !this.value.isEmpty(); 407 } 408 409 /** 410 * @param value {@link #value} (The string that should be sent over the wire to identify the code system or identifier system.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value 411 */ 412 public NamingSystemUniqueIdComponent setValueElement(StringType value) { 413 this.value = value; 414 return this; 415 } 416 417 /** 418 * @return The string that should be sent over the wire to identify the code system or identifier system. 419 */ 420 public String getValue() { 421 return this.value == null ? null : this.value.getValue(); 422 } 423 424 /** 425 * @param value The string that should be sent over the wire to identify the code system or identifier system. 426 */ 427 public NamingSystemUniqueIdComponent setValue(String value) { 428 if (this.value == null) 429 this.value = new StringType(); 430 this.value.setValue(value); 431 return this; 432 } 433 434 /** 435 * @return {@link #preferred} (Indicates whether this identifier is the "preferred" identifier of this type.). This is the underlying object with id, value and extensions. The accessor "getPreferred" gives direct access to the value 436 */ 437 public BooleanType getPreferredElement() { 438 if (this.preferred == null) 439 if (Configuration.errorOnAutoCreate()) 440 throw new Error("Attempt to auto-create NamingSystemUniqueIdComponent.preferred"); 441 else if (Configuration.doAutoCreate()) 442 this.preferred = new BooleanType(); // bb 443 return this.preferred; 444 } 445 446 public boolean hasPreferredElement() { 447 return this.preferred != null && !this.preferred.isEmpty(); 448 } 449 450 public boolean hasPreferred() { 451 return this.preferred != null && !this.preferred.isEmpty(); 452 } 453 454 /** 455 * @param value {@link #preferred} (Indicates whether this identifier is the "preferred" identifier of this type.). This is the underlying object with id, value and extensions. The accessor "getPreferred" gives direct access to the value 456 */ 457 public NamingSystemUniqueIdComponent setPreferredElement(BooleanType value) { 458 this.preferred = value; 459 return this; 460 } 461 462 /** 463 * @return Indicates whether this identifier is the "preferred" identifier of this type. 464 */ 465 public boolean getPreferred() { 466 return this.preferred == null || this.preferred.isEmpty() ? false : this.preferred.getValue(); 467 } 468 469 /** 470 * @param value Indicates whether this identifier is the "preferred" identifier of this type. 471 */ 472 public NamingSystemUniqueIdComponent setPreferred(boolean value) { 473 if (this.preferred == null) 474 this.preferred = new BooleanType(); 475 this.preferred.setValue(value); 476 return this; 477 } 478 479 /** 480 * @return {@link #comment} (Notes about the past or intended usage of this identifier.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value 481 */ 482 public StringType getCommentElement() { 483 if (this.comment == null) 484 if (Configuration.errorOnAutoCreate()) 485 throw new Error("Attempt to auto-create NamingSystemUniqueIdComponent.comment"); 486 else if (Configuration.doAutoCreate()) 487 this.comment = new StringType(); // bb 488 return this.comment; 489 } 490 491 public boolean hasCommentElement() { 492 return this.comment != null && !this.comment.isEmpty(); 493 } 494 495 public boolean hasComment() { 496 return this.comment != null && !this.comment.isEmpty(); 497 } 498 499 /** 500 * @param value {@link #comment} (Notes about the past or intended usage of this identifier.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value 501 */ 502 public NamingSystemUniqueIdComponent setCommentElement(StringType value) { 503 this.comment = value; 504 return this; 505 } 506 507 /** 508 * @return Notes about the past or intended usage of this identifier. 509 */ 510 public String getComment() { 511 return this.comment == null ? null : this.comment.getValue(); 512 } 513 514 /** 515 * @param value Notes about the past or intended usage of this identifier. 516 */ 517 public NamingSystemUniqueIdComponent setComment(String value) { 518 if (Utilities.noString(value)) 519 this.comment = null; 520 else { 521 if (this.comment == null) 522 this.comment = new StringType(); 523 this.comment.setValue(value); 524 } 525 return this; 526 } 527 528 /** 529 * @return {@link #period} (Identifies the period of time over which this identifier is considered appropriate to refer to the naming system. Outside of this window, the identifier might be non-deterministic.) 530 */ 531 public Period getPeriod() { 532 if (this.period == null) 533 if (Configuration.errorOnAutoCreate()) 534 throw new Error("Attempt to auto-create NamingSystemUniqueIdComponent.period"); 535 else if (Configuration.doAutoCreate()) 536 this.period = new Period(); // cc 537 return this.period; 538 } 539 540 public boolean hasPeriod() { 541 return this.period != null && !this.period.isEmpty(); 542 } 543 544 /** 545 * @param value {@link #period} (Identifies the period of time over which this identifier is considered appropriate to refer to the naming system. Outside of this window, the identifier might be non-deterministic.) 546 */ 547 public NamingSystemUniqueIdComponent setPeriod(Period value) { 548 this.period = value; 549 return this; 550 } 551 552 protected void listChildren(List<Property> children) { 553 super.listChildren(children); 554 children.add(new Property("type", "code", "Identifies the unique identifier scheme used for this particular identifier.", 0, 1, type)); 555 children.add(new Property("value", "string", "The string that should be sent over the wire to identify the code system or identifier system.", 0, 1, value)); 556 children.add(new Property("preferred", "boolean", "Indicates whether this identifier is the \"preferred\" identifier of this type.", 0, 1, preferred)); 557 children.add(new Property("comment", "string", "Notes about the past or intended usage of this identifier.", 0, 1, comment)); 558 children.add(new Property("period", "Period", "Identifies the period of time over which this identifier is considered appropriate to refer to the naming system. Outside of this window, the identifier might be non-deterministic.", 0, 1, period)); 559 } 560 561 @Override 562 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 563 switch (_hash) { 564 case 3575610: /*type*/ return new Property("type", "code", "Identifies the unique identifier scheme used for this particular identifier.", 0, 1, type); 565 case 111972721: /*value*/ return new Property("value", "string", "The string that should be sent over the wire to identify the code system or identifier system.", 0, 1, value); 566 case -1294005119: /*preferred*/ return new Property("preferred", "boolean", "Indicates whether this identifier is the \"preferred\" identifier of this type.", 0, 1, preferred); 567 case 950398559: /*comment*/ return new Property("comment", "string", "Notes about the past or intended usage of this identifier.", 0, 1, comment); 568 case -991726143: /*period*/ return new Property("period", "Period", "Identifies the period of time over which this identifier is considered appropriate to refer to the naming system. Outside of this window, the identifier might be non-deterministic.", 0, 1, period); 569 default: return super.getNamedProperty(_hash, _name, _checkValid); 570 } 571 572 } 573 574 @Override 575 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 576 switch (hash) { 577 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<NamingSystemIdentifierType> 578 case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // StringType 579 case -1294005119: /*preferred*/ return this.preferred == null ? new Base[0] : new Base[] {this.preferred}; // BooleanType 580 case 950398559: /*comment*/ return this.comment == null ? new Base[0] : new Base[] {this.comment}; // StringType 581 case -991726143: /*period*/ return this.period == null ? new Base[0] : new Base[] {this.period}; // Period 582 default: return super.getProperty(hash, name, checkValid); 583 } 584 585 } 586 587 @Override 588 public Base setProperty(int hash, String name, Base value) throws FHIRException { 589 switch (hash) { 590 case 3575610: // type 591 value = new NamingSystemIdentifierTypeEnumFactory().fromType(castToCode(value)); 592 this.type = (Enumeration) value; // Enumeration<NamingSystemIdentifierType> 593 return value; 594 case 111972721: // value 595 this.value = castToString(value); // StringType 596 return value; 597 case -1294005119: // preferred 598 this.preferred = castToBoolean(value); // BooleanType 599 return value; 600 case 950398559: // comment 601 this.comment = castToString(value); // StringType 602 return value; 603 case -991726143: // period 604 this.period = castToPeriod(value); // Period 605 return value; 606 default: return super.setProperty(hash, name, value); 607 } 608 609 } 610 611 @Override 612 public Base setProperty(String name, Base value) throws FHIRException { 613 if (name.equals("type")) { 614 value = new NamingSystemIdentifierTypeEnumFactory().fromType(castToCode(value)); 615 this.type = (Enumeration) value; // Enumeration<NamingSystemIdentifierType> 616 } else if (name.equals("value")) { 617 this.value = castToString(value); // StringType 618 } else if (name.equals("preferred")) { 619 this.preferred = castToBoolean(value); // BooleanType 620 } else if (name.equals("comment")) { 621 this.comment = castToString(value); // StringType 622 } else if (name.equals("period")) { 623 this.period = castToPeriod(value); // Period 624 } else 625 return super.setProperty(name, value); 626 return value; 627 } 628 629 @Override 630 public Base makeProperty(int hash, String name) throws FHIRException { 631 switch (hash) { 632 case 3575610: return getTypeElement(); 633 case 111972721: return getValueElement(); 634 case -1294005119: return getPreferredElement(); 635 case 950398559: return getCommentElement(); 636 case -991726143: return getPeriod(); 637 default: return super.makeProperty(hash, name); 638 } 639 640 } 641 642 @Override 643 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 644 switch (hash) { 645 case 3575610: /*type*/ return new String[] {"code"}; 646 case 111972721: /*value*/ return new String[] {"string"}; 647 case -1294005119: /*preferred*/ return new String[] {"boolean"}; 648 case 950398559: /*comment*/ return new String[] {"string"}; 649 case -991726143: /*period*/ return new String[] {"Period"}; 650 default: return super.getTypesForProperty(hash, name); 651 } 652 653 } 654 655 @Override 656 public Base addChild(String name) throws FHIRException { 657 if (name.equals("type")) { 658 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.type"); 659 } 660 else if (name.equals("value")) { 661 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.value"); 662 } 663 else if (name.equals("preferred")) { 664 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.preferred"); 665 } 666 else if (name.equals("comment")) { 667 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.comment"); 668 } 669 else if (name.equals("period")) { 670 this.period = new Period(); 671 return this.period; 672 } 673 else 674 return super.addChild(name); 675 } 676 677 public NamingSystemUniqueIdComponent copy() { 678 NamingSystemUniqueIdComponent dst = new NamingSystemUniqueIdComponent(); 679 copyValues(dst); 680 return dst; 681 } 682 683 public void copyValues(NamingSystemUniqueIdComponent dst) { 684 super.copyValues(dst); 685 dst.type = type == null ? null : type.copy(); 686 dst.value = value == null ? null : value.copy(); 687 dst.preferred = preferred == null ? null : preferred.copy(); 688 dst.comment = comment == null ? null : comment.copy(); 689 dst.period = period == null ? null : period.copy(); 690 } 691 692 @Override 693 public boolean equalsDeep(Base other_) { 694 if (!super.equalsDeep(other_)) 695 return false; 696 if (!(other_ instanceof NamingSystemUniqueIdComponent)) 697 return false; 698 NamingSystemUniqueIdComponent o = (NamingSystemUniqueIdComponent) other_; 699 return compareDeep(type, o.type, true) && compareDeep(value, o.value, true) && compareDeep(preferred, o.preferred, true) 700 && compareDeep(comment, o.comment, true) && compareDeep(period, o.period, true); 701 } 702 703 @Override 704 public boolean equalsShallow(Base other_) { 705 if (!super.equalsShallow(other_)) 706 return false; 707 if (!(other_ instanceof NamingSystemUniqueIdComponent)) 708 return false; 709 NamingSystemUniqueIdComponent o = (NamingSystemUniqueIdComponent) other_; 710 return compareValues(type, o.type, true) && compareValues(value, o.value, true) && compareValues(preferred, o.preferred, true) 711 && compareValues(comment, o.comment, true); 712 } 713 714 public boolean isEmpty() { 715 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, value, preferred, comment 716 , period); 717 } 718 719 public String fhirType() { 720 return "NamingSystem.uniqueId"; 721 722 } 723 724 } 725 726 /** 727 * Indicates the purpose for the naming system - what kinds of things does it make unique? 728 */ 729 @Child(name = "kind", type = {CodeType.class}, order=0, min=1, max=1, modifier=false, summary=true) 730 @Description(shortDefinition="codesystem | identifier | root", formalDefinition="Indicates the purpose for the naming system - what kinds of things does it make unique?" ) 731 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/namingsystem-type") 732 protected Enumeration<NamingSystemType> kind; 733 734 /** 735 * The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision. 736 */ 737 @Child(name = "responsible", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=false) 738 @Description(shortDefinition="Who maintains system namespace?", formalDefinition="The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision." ) 739 protected StringType responsible; 740 741 /** 742 * Categorizes a naming system for easier search by grouping related naming systems. 743 */ 744 @Child(name = "type", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=false) 745 @Description(shortDefinition="e.g. driver, provider, patient, bank etc.", formalDefinition="Categorizes a naming system for easier search by grouping related naming systems." ) 746 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/identifier-type") 747 protected CodeableConcept type; 748 749 /** 750 * Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc. 751 */ 752 @Child(name = "usage", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false) 753 @Description(shortDefinition="How/where is it used", formalDefinition="Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc." ) 754 protected StringType usage; 755 756 /** 757 * Indicates how the system may be identified when referenced in electronic exchange. 758 */ 759 @Child(name = "uniqueId", type = {}, order=4, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 760 @Description(shortDefinition="Unique identifiers used for system", formalDefinition="Indicates how the system may be identified when referenced in electronic exchange." ) 761 protected List<NamingSystemUniqueIdComponent> uniqueId; 762 763 private static final long serialVersionUID = 1686086580L; 764 765 /** 766 * Constructor 767 */ 768 public NamingSystem() { 769 super(); 770 } 771 772 /** 773 * Constructor 774 */ 775 public NamingSystem(StringType name, Enumeration<PublicationStatus> status, Enumeration<NamingSystemType> kind, DateTimeType date) { 776 super(); 777 this.name = name; 778 this.status = status; 779 this.kind = kind; 780 this.date = date; 781 } 782 783 /** 784 * @return {@link #name} (A natural language name identifying the naming 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 785 */ 786 public StringType getNameElement() { 787 if (this.name == null) 788 if (Configuration.errorOnAutoCreate()) 789 throw new Error("Attempt to auto-create NamingSystem.name"); 790 else if (Configuration.doAutoCreate()) 791 this.name = new StringType(); // bb 792 return this.name; 793 } 794 795 public boolean hasNameElement() { 796 return this.name != null && !this.name.isEmpty(); 797 } 798 799 public boolean hasName() { 800 return this.name != null && !this.name.isEmpty(); 801 } 802 803 /** 804 * @param value {@link #name} (A natural language name identifying the naming 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 805 */ 806 public NamingSystem setNameElement(StringType value) { 807 this.name = value; 808 return this; 809 } 810 811 /** 812 * @return A natural language name identifying the naming system. This name should be usable as an identifier for the module by machine processing applications such as code generation. 813 */ 814 public String getName() { 815 return this.name == null ? null : this.name.getValue(); 816 } 817 818 /** 819 * @param value A natural language name identifying the naming system. This name should be usable as an identifier for the module by machine processing applications such as code generation. 820 */ 821 public NamingSystem setName(String value) { 822 if (this.name == null) 823 this.name = new StringType(); 824 this.name.setValue(value); 825 return this; 826 } 827 828 /** 829 * @return {@link #status} (The status of this naming 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 830 */ 831 public Enumeration<PublicationStatus> getStatusElement() { 832 if (this.status == null) 833 if (Configuration.errorOnAutoCreate()) 834 throw new Error("Attempt to auto-create NamingSystem.status"); 835 else if (Configuration.doAutoCreate()) 836 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 837 return this.status; 838 } 839 840 public boolean hasStatusElement() { 841 return this.status != null && !this.status.isEmpty(); 842 } 843 844 public boolean hasStatus() { 845 return this.status != null && !this.status.isEmpty(); 846 } 847 848 /** 849 * @param value {@link #status} (The status of this naming 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 850 */ 851 public NamingSystem setStatusElement(Enumeration<PublicationStatus> value) { 852 this.status = value; 853 return this; 854 } 855 856 /** 857 * @return The status of this naming system. Enables tracking the life-cycle of the content. 858 */ 859 public PublicationStatus getStatus() { 860 return this.status == null ? null : this.status.getValue(); 861 } 862 863 /** 864 * @param value The status of this naming system. Enables tracking the life-cycle of the content. 865 */ 866 public NamingSystem setStatus(PublicationStatus value) { 867 if (this.status == null) 868 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 869 this.status.setValue(value); 870 return this; 871 } 872 873 /** 874 * @return {@link #kind} (Indicates the purpose for the naming system - what kinds of things does it make unique?). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value 875 */ 876 public Enumeration<NamingSystemType> getKindElement() { 877 if (this.kind == null) 878 if (Configuration.errorOnAutoCreate()) 879 throw new Error("Attempt to auto-create NamingSystem.kind"); 880 else if (Configuration.doAutoCreate()) 881 this.kind = new Enumeration<NamingSystemType>(new NamingSystemTypeEnumFactory()); // bb 882 return this.kind; 883 } 884 885 public boolean hasKindElement() { 886 return this.kind != null && !this.kind.isEmpty(); 887 } 888 889 public boolean hasKind() { 890 return this.kind != null && !this.kind.isEmpty(); 891 } 892 893 /** 894 * @param value {@link #kind} (Indicates the purpose for the naming system - what kinds of things does it make unique?). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value 895 */ 896 public NamingSystem setKindElement(Enumeration<NamingSystemType> value) { 897 this.kind = value; 898 return this; 899 } 900 901 /** 902 * @return Indicates the purpose for the naming system - what kinds of things does it make unique? 903 */ 904 public NamingSystemType getKind() { 905 return this.kind == null ? null : this.kind.getValue(); 906 } 907 908 /** 909 * @param value Indicates the purpose for the naming system - what kinds of things does it make unique? 910 */ 911 public NamingSystem setKind(NamingSystemType value) { 912 if (this.kind == null) 913 this.kind = new Enumeration<NamingSystemType>(new NamingSystemTypeEnumFactory()); 914 this.kind.setValue(value); 915 return this; 916 } 917 918 /** 919 * @return {@link #date} (The date (and optionally time) when the naming system was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the naming system changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 920 */ 921 public DateTimeType getDateElement() { 922 if (this.date == null) 923 if (Configuration.errorOnAutoCreate()) 924 throw new Error("Attempt to auto-create NamingSystem.date"); 925 else if (Configuration.doAutoCreate()) 926 this.date = new DateTimeType(); // bb 927 return this.date; 928 } 929 930 public boolean hasDateElement() { 931 return this.date != null && !this.date.isEmpty(); 932 } 933 934 public boolean hasDate() { 935 return this.date != null && !this.date.isEmpty(); 936 } 937 938 /** 939 * @param value {@link #date} (The date (and optionally time) when the naming system was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the naming system changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 940 */ 941 public NamingSystem setDateElement(DateTimeType value) { 942 this.date = value; 943 return this; 944 } 945 946 /** 947 * @return The date (and optionally time) when the naming system was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the naming system changes. 948 */ 949 public Date getDate() { 950 return this.date == null ? null : this.date.getValue(); 951 } 952 953 /** 954 * @param value The date (and optionally time) when the naming system was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the naming system changes. 955 */ 956 public NamingSystem setDate(Date value) { 957 if (this.date == null) 958 this.date = new DateTimeType(); 959 this.date.setValue(value); 960 return this; 961 } 962 963 /** 964 * @return {@link #publisher} (The name of the organization or individual that published the naming system.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 965 */ 966 public StringType getPublisherElement() { 967 if (this.publisher == null) 968 if (Configuration.errorOnAutoCreate()) 969 throw new Error("Attempt to auto-create NamingSystem.publisher"); 970 else if (Configuration.doAutoCreate()) 971 this.publisher = new StringType(); // bb 972 return this.publisher; 973 } 974 975 public boolean hasPublisherElement() { 976 return this.publisher != null && !this.publisher.isEmpty(); 977 } 978 979 public boolean hasPublisher() { 980 return this.publisher != null && !this.publisher.isEmpty(); 981 } 982 983 /** 984 * @param value {@link #publisher} (The name of the organization or individual that published the naming system.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 985 */ 986 public NamingSystem setPublisherElement(StringType value) { 987 this.publisher = value; 988 return this; 989 } 990 991 /** 992 * @return The name of the organization or individual that published the naming system. 993 */ 994 public String getPublisher() { 995 return this.publisher == null ? null : this.publisher.getValue(); 996 } 997 998 /** 999 * @param value The name of the organization or individual that published the naming system. 1000 */ 1001 public NamingSystem setPublisher(String value) { 1002 if (Utilities.noString(value)) 1003 this.publisher = null; 1004 else { 1005 if (this.publisher == null) 1006 this.publisher = new StringType(); 1007 this.publisher.setValue(value); 1008 } 1009 return this; 1010 } 1011 1012 /** 1013 * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.) 1014 */ 1015 public List<ContactDetail> getContact() { 1016 if (this.contact == null) 1017 this.contact = new ArrayList<ContactDetail>(); 1018 return this.contact; 1019 } 1020 1021 /** 1022 * @return Returns a reference to <code>this</code> for easy method chaining 1023 */ 1024 public NamingSystem setContact(List<ContactDetail> theContact) { 1025 this.contact = theContact; 1026 return this; 1027 } 1028 1029 public boolean hasContact() { 1030 if (this.contact == null) 1031 return false; 1032 for (ContactDetail item : this.contact) 1033 if (!item.isEmpty()) 1034 return true; 1035 return false; 1036 } 1037 1038 public ContactDetail addContact() { //3 1039 ContactDetail t = new ContactDetail(); 1040 if (this.contact == null) 1041 this.contact = new ArrayList<ContactDetail>(); 1042 this.contact.add(t); 1043 return t; 1044 } 1045 1046 public NamingSystem addContact(ContactDetail t) { //3 1047 if (t == null) 1048 return this; 1049 if (this.contact == null) 1050 this.contact = new ArrayList<ContactDetail>(); 1051 this.contact.add(t); 1052 return this; 1053 } 1054 1055 /** 1056 * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist 1057 */ 1058 public ContactDetail getContactFirstRep() { 1059 if (getContact().isEmpty()) { 1060 addContact(); 1061 } 1062 return getContact().get(0); 1063 } 1064 1065 /** 1066 * @return {@link #responsible} (The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision.). This is the underlying object with id, value and extensions. The accessor "getResponsible" gives direct access to the value 1067 */ 1068 public StringType getResponsibleElement() { 1069 if (this.responsible == null) 1070 if (Configuration.errorOnAutoCreate()) 1071 throw new Error("Attempt to auto-create NamingSystem.responsible"); 1072 else if (Configuration.doAutoCreate()) 1073 this.responsible = new StringType(); // bb 1074 return this.responsible; 1075 } 1076 1077 public boolean hasResponsibleElement() { 1078 return this.responsible != null && !this.responsible.isEmpty(); 1079 } 1080 1081 public boolean hasResponsible() { 1082 return this.responsible != null && !this.responsible.isEmpty(); 1083 } 1084 1085 /** 1086 * @param value {@link #responsible} (The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision.). This is the underlying object with id, value and extensions. The accessor "getResponsible" gives direct access to the value 1087 */ 1088 public NamingSystem setResponsibleElement(StringType value) { 1089 this.responsible = value; 1090 return this; 1091 } 1092 1093 /** 1094 * @return The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision. 1095 */ 1096 public String getResponsible() { 1097 return this.responsible == null ? null : this.responsible.getValue(); 1098 } 1099 1100 /** 1101 * @param value The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision. 1102 */ 1103 public NamingSystem setResponsible(String value) { 1104 if (Utilities.noString(value)) 1105 this.responsible = null; 1106 else { 1107 if (this.responsible == null) 1108 this.responsible = new StringType(); 1109 this.responsible.setValue(value); 1110 } 1111 return this; 1112 } 1113 1114 /** 1115 * @return {@link #type} (Categorizes a naming system for easier search by grouping related naming systems.) 1116 */ 1117 public CodeableConcept getType() { 1118 if (this.type == null) 1119 if (Configuration.errorOnAutoCreate()) 1120 throw new Error("Attempt to auto-create NamingSystem.type"); 1121 else if (Configuration.doAutoCreate()) 1122 this.type = new CodeableConcept(); // cc 1123 return this.type; 1124 } 1125 1126 public boolean hasType() { 1127 return this.type != null && !this.type.isEmpty(); 1128 } 1129 1130 /** 1131 * @param value {@link #type} (Categorizes a naming system for easier search by grouping related naming systems.) 1132 */ 1133 public NamingSystem setType(CodeableConcept value) { 1134 this.type = value; 1135 return this; 1136 } 1137 1138 /** 1139 * @return {@link #description} (A free text natural language description of the naming system from a consumer's perspective. Details about what the namespace identifies including scope, granularity, version labeling, etc.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1140 */ 1141 public MarkdownType getDescriptionElement() { 1142 if (this.description == null) 1143 if (Configuration.errorOnAutoCreate()) 1144 throw new Error("Attempt to auto-create NamingSystem.description"); 1145 else if (Configuration.doAutoCreate()) 1146 this.description = new MarkdownType(); // bb 1147 return this.description; 1148 } 1149 1150 public boolean hasDescriptionElement() { 1151 return this.description != null && !this.description.isEmpty(); 1152 } 1153 1154 public boolean hasDescription() { 1155 return this.description != null && !this.description.isEmpty(); 1156 } 1157 1158 /** 1159 * @param value {@link #description} (A free text natural language description of the naming system from a consumer's perspective. Details about what the namespace identifies including scope, granularity, version labeling, etc.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1160 */ 1161 public NamingSystem setDescriptionElement(MarkdownType value) { 1162 this.description = value; 1163 return this; 1164 } 1165 1166 /** 1167 * @return A free text natural language description of the naming system from a consumer's perspective. Details about what the namespace identifies including scope, granularity, version labeling, etc. 1168 */ 1169 public String getDescription() { 1170 return this.description == null ? null : this.description.getValue(); 1171 } 1172 1173 /** 1174 * @param value A free text natural language description of the naming system from a consumer's perspective. Details about what the namespace identifies including scope, granularity, version labeling, etc. 1175 */ 1176 public NamingSystem setDescription(String value) { 1177 if (value == null) 1178 this.description = null; 1179 else { 1180 if (this.description == null) 1181 this.description = new MarkdownType(); 1182 this.description.setValue(value); 1183 } 1184 return this; 1185 } 1186 1187 /** 1188 * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate naming system instances.) 1189 */ 1190 public List<UsageContext> getUseContext() { 1191 if (this.useContext == null) 1192 this.useContext = new ArrayList<UsageContext>(); 1193 return this.useContext; 1194 } 1195 1196 /** 1197 * @return Returns a reference to <code>this</code> for easy method chaining 1198 */ 1199 public NamingSystem setUseContext(List<UsageContext> theUseContext) { 1200 this.useContext = theUseContext; 1201 return this; 1202 } 1203 1204 public boolean hasUseContext() { 1205 if (this.useContext == null) 1206 return false; 1207 for (UsageContext item : this.useContext) 1208 if (!item.isEmpty()) 1209 return true; 1210 return false; 1211 } 1212 1213 public UsageContext addUseContext() { //3 1214 UsageContext t = new UsageContext(); 1215 if (this.useContext == null) 1216 this.useContext = new ArrayList<UsageContext>(); 1217 this.useContext.add(t); 1218 return t; 1219 } 1220 1221 public NamingSystem addUseContext(UsageContext t) { //3 1222 if (t == null) 1223 return this; 1224 if (this.useContext == null) 1225 this.useContext = new ArrayList<UsageContext>(); 1226 this.useContext.add(t); 1227 return this; 1228 } 1229 1230 /** 1231 * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist 1232 */ 1233 public UsageContext getUseContextFirstRep() { 1234 if (getUseContext().isEmpty()) { 1235 addUseContext(); 1236 } 1237 return getUseContext().get(0); 1238 } 1239 1240 /** 1241 * @return {@link #jurisdiction} (A legal or geographic region in which the naming system is intended to be used.) 1242 */ 1243 public List<CodeableConcept> getJurisdiction() { 1244 if (this.jurisdiction == null) 1245 this.jurisdiction = new ArrayList<CodeableConcept>(); 1246 return this.jurisdiction; 1247 } 1248 1249 /** 1250 * @return Returns a reference to <code>this</code> for easy method chaining 1251 */ 1252 public NamingSystem setJurisdiction(List<CodeableConcept> theJurisdiction) { 1253 this.jurisdiction = theJurisdiction; 1254 return this; 1255 } 1256 1257 public boolean hasJurisdiction() { 1258 if (this.jurisdiction == null) 1259 return false; 1260 for (CodeableConcept item : this.jurisdiction) 1261 if (!item.isEmpty()) 1262 return true; 1263 return false; 1264 } 1265 1266 public CodeableConcept addJurisdiction() { //3 1267 CodeableConcept t = new CodeableConcept(); 1268 if (this.jurisdiction == null) 1269 this.jurisdiction = new ArrayList<CodeableConcept>(); 1270 this.jurisdiction.add(t); 1271 return t; 1272 } 1273 1274 public NamingSystem addJurisdiction(CodeableConcept t) { //3 1275 if (t == null) 1276 return this; 1277 if (this.jurisdiction == null) 1278 this.jurisdiction = new ArrayList<CodeableConcept>(); 1279 this.jurisdiction.add(t); 1280 return this; 1281 } 1282 1283 /** 1284 * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist 1285 */ 1286 public CodeableConcept getJurisdictionFirstRep() { 1287 if (getJurisdiction().isEmpty()) { 1288 addJurisdiction(); 1289 } 1290 return getJurisdiction().get(0); 1291 } 1292 1293 /** 1294 * @return {@link #usage} (Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc.). This is the underlying object with id, value and extensions. The accessor "getUsage" gives direct access to the value 1295 */ 1296 public StringType getUsageElement() { 1297 if (this.usage == null) 1298 if (Configuration.errorOnAutoCreate()) 1299 throw new Error("Attempt to auto-create NamingSystem.usage"); 1300 else if (Configuration.doAutoCreate()) 1301 this.usage = new StringType(); // bb 1302 return this.usage; 1303 } 1304 1305 public boolean hasUsageElement() { 1306 return this.usage != null && !this.usage.isEmpty(); 1307 } 1308 1309 public boolean hasUsage() { 1310 return this.usage != null && !this.usage.isEmpty(); 1311 } 1312 1313 /** 1314 * @param value {@link #usage} (Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc.). This is the underlying object with id, value and extensions. The accessor "getUsage" gives direct access to the value 1315 */ 1316 public NamingSystem setUsageElement(StringType value) { 1317 this.usage = value; 1318 return this; 1319 } 1320 1321 /** 1322 * @return Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc. 1323 */ 1324 public String getUsage() { 1325 return this.usage == null ? null : this.usage.getValue(); 1326 } 1327 1328 /** 1329 * @param value Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc. 1330 */ 1331 public NamingSystem setUsage(String value) { 1332 if (Utilities.noString(value)) 1333 this.usage = null; 1334 else { 1335 if (this.usage == null) 1336 this.usage = new StringType(); 1337 this.usage.setValue(value); 1338 } 1339 return this; 1340 } 1341 1342 /** 1343 * @return {@link #uniqueId} (Indicates how the system may be identified when referenced in electronic exchange.) 1344 */ 1345 public List<NamingSystemUniqueIdComponent> getUniqueId() { 1346 if (this.uniqueId == null) 1347 this.uniqueId = new ArrayList<NamingSystemUniqueIdComponent>(); 1348 return this.uniqueId; 1349 } 1350 1351 /** 1352 * @return Returns a reference to <code>this</code> for easy method chaining 1353 */ 1354 public NamingSystem setUniqueId(List<NamingSystemUniqueIdComponent> theUniqueId) { 1355 this.uniqueId = theUniqueId; 1356 return this; 1357 } 1358 1359 public boolean hasUniqueId() { 1360 if (this.uniqueId == null) 1361 return false; 1362 for (NamingSystemUniqueIdComponent item : this.uniqueId) 1363 if (!item.isEmpty()) 1364 return true; 1365 return false; 1366 } 1367 1368 public NamingSystemUniqueIdComponent addUniqueId() { //3 1369 NamingSystemUniqueIdComponent t = new NamingSystemUniqueIdComponent(); 1370 if (this.uniqueId == null) 1371 this.uniqueId = new ArrayList<NamingSystemUniqueIdComponent>(); 1372 this.uniqueId.add(t); 1373 return t; 1374 } 1375 1376 public NamingSystem addUniqueId(NamingSystemUniqueIdComponent t) { //3 1377 if (t == null) 1378 return this; 1379 if (this.uniqueId == null) 1380 this.uniqueId = new ArrayList<NamingSystemUniqueIdComponent>(); 1381 this.uniqueId.add(t); 1382 return this; 1383 } 1384 1385 /** 1386 * @return The first repetition of repeating field {@link #uniqueId}, creating it if it does not already exist 1387 */ 1388 public NamingSystemUniqueIdComponent getUniqueIdFirstRep() { 1389 if (getUniqueId().isEmpty()) { 1390 addUniqueId(); 1391 } 1392 return getUniqueId().get(0); 1393 } 1394 1395 protected void listChildren(List<Property> children) { 1396 super.listChildren(children); 1397 children.add(new Property("name", "string", "A natural language name identifying the naming system. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name)); 1398 children.add(new Property("status", "code", "The status of this naming system. Enables tracking the life-cycle of the content.", 0, 1, status)); 1399 children.add(new Property("kind", "code", "Indicates the purpose for the naming system - what kinds of things does it make unique?", 0, 1, kind)); 1400 children.add(new Property("date", "dateTime", "The date (and optionally time) when the naming system was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the naming system changes.", 0, 1, date)); 1401 children.add(new Property("publisher", "string", "The name of the organization or individual that published the naming system.", 0, 1, publisher)); 1402 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)); 1403 children.add(new Property("responsible", "string", "The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision.", 0, 1, responsible)); 1404 children.add(new Property("type", "CodeableConcept", "Categorizes a naming system for easier search by grouping related naming systems.", 0, 1, type)); 1405 children.add(new Property("description", "markdown", "A free text natural language description of the naming system from a consumer's perspective. Details about what the namespace identifies including scope, granularity, version labeling, etc.", 0, 1, description)); 1406 children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate naming system instances.", 0, java.lang.Integer.MAX_VALUE, useContext)); 1407 children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the naming system is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction)); 1408 children.add(new Property("usage", "string", "Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc.", 0, 1, usage)); 1409 children.add(new Property("uniqueId", "", "Indicates how the system may be identified when referenced in electronic exchange.", 0, java.lang.Integer.MAX_VALUE, uniqueId)); 1410 } 1411 1412 @Override 1413 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1414 switch (_hash) { 1415 case 3373707: /*name*/ return new Property("name", "string", "A natural language name identifying the naming system. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name); 1416 case -892481550: /*status*/ return new Property("status", "code", "The status of this naming system. Enables tracking the life-cycle of the content.", 0, 1, status); 1417 case 3292052: /*kind*/ return new Property("kind", "code", "Indicates the purpose for the naming system - what kinds of things does it make unique?", 0, 1, kind); 1418 case 3076014: /*date*/ return new Property("date", "dateTime", "The date (and optionally time) when the naming system was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the naming system changes.", 0, 1, date); 1419 case 1447404028: /*publisher*/ return new Property("publisher", "string", "The name of the organization or individual that published the naming system.", 0, 1, publisher); 1420 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); 1421 case 1847674614: /*responsible*/ return new Property("responsible", "string", "The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision.", 0, 1, responsible); 1422 case 3575610: /*type*/ return new Property("type", "CodeableConcept", "Categorizes a naming system for easier search by grouping related naming systems.", 0, 1, type); 1423 case -1724546052: /*description*/ return new Property("description", "markdown", "A free text natural language description of the naming system from a consumer's perspective. Details about what the namespace identifies including scope, granularity, version labeling, etc.", 0, 1, description); 1424 case -669707736: /*useContext*/ return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate naming system instances.", 0, java.lang.Integer.MAX_VALUE, useContext); 1425 case -507075711: /*jurisdiction*/ return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the naming system is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction); 1426 case 111574433: /*usage*/ return new Property("usage", "string", "Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc.", 0, 1, usage); 1427 case -294460212: /*uniqueId*/ return new Property("uniqueId", "", "Indicates how the system may be identified when referenced in electronic exchange.", 0, java.lang.Integer.MAX_VALUE, uniqueId); 1428 default: return super.getNamedProperty(_hash, _name, _checkValid); 1429 } 1430 1431 } 1432 1433 @Override 1434 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1435 switch (hash) { 1436 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 1437 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus> 1438 case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<NamingSystemType> 1439 case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType 1440 case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType 1441 case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 1442 case 1847674614: /*responsible*/ return this.responsible == null ? new Base[0] : new Base[] {this.responsible}; // StringType 1443 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept 1444 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 1445 case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 1446 case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 1447 case 111574433: /*usage*/ return this.usage == null ? new Base[0] : new Base[] {this.usage}; // StringType 1448 case -294460212: /*uniqueId*/ return this.uniqueId == null ? new Base[0] : this.uniqueId.toArray(new Base[this.uniqueId.size()]); // NamingSystemUniqueIdComponent 1449 default: return super.getProperty(hash, name, checkValid); 1450 } 1451 1452 } 1453 1454 @Override 1455 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1456 switch (hash) { 1457 case 3373707: // name 1458 this.name = castToString(value); // StringType 1459 return value; 1460 case -892481550: // status 1461 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 1462 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 1463 return value; 1464 case 3292052: // kind 1465 value = new NamingSystemTypeEnumFactory().fromType(castToCode(value)); 1466 this.kind = (Enumeration) value; // Enumeration<NamingSystemType> 1467 return value; 1468 case 3076014: // date 1469 this.date = castToDateTime(value); // DateTimeType 1470 return value; 1471 case 1447404028: // publisher 1472 this.publisher = castToString(value); // StringType 1473 return value; 1474 case 951526432: // contact 1475 this.getContact().add(castToContactDetail(value)); // ContactDetail 1476 return value; 1477 case 1847674614: // responsible 1478 this.responsible = castToString(value); // StringType 1479 return value; 1480 case 3575610: // type 1481 this.type = castToCodeableConcept(value); // CodeableConcept 1482 return value; 1483 case -1724546052: // description 1484 this.description = castToMarkdown(value); // MarkdownType 1485 return value; 1486 case -669707736: // useContext 1487 this.getUseContext().add(castToUsageContext(value)); // UsageContext 1488 return value; 1489 case -507075711: // jurisdiction 1490 this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept 1491 return value; 1492 case 111574433: // usage 1493 this.usage = castToString(value); // StringType 1494 return value; 1495 case -294460212: // uniqueId 1496 this.getUniqueId().add((NamingSystemUniqueIdComponent) value); // NamingSystemUniqueIdComponent 1497 return value; 1498 default: return super.setProperty(hash, name, value); 1499 } 1500 1501 } 1502 1503 @Override 1504 public Base setProperty(String name, Base value) throws FHIRException { 1505 if (name.equals("name")) { 1506 this.name = castToString(value); // StringType 1507 } else if (name.equals("status")) { 1508 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 1509 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 1510 } else if (name.equals("kind")) { 1511 value = new NamingSystemTypeEnumFactory().fromType(castToCode(value)); 1512 this.kind = (Enumeration) value; // Enumeration<NamingSystemType> 1513 } else if (name.equals("date")) { 1514 this.date = castToDateTime(value); // DateTimeType 1515 } else if (name.equals("publisher")) { 1516 this.publisher = castToString(value); // StringType 1517 } else if (name.equals("contact")) { 1518 this.getContact().add(castToContactDetail(value)); 1519 } else if (name.equals("responsible")) { 1520 this.responsible = castToString(value); // StringType 1521 } else if (name.equals("type")) { 1522 this.type = castToCodeableConcept(value); // CodeableConcept 1523 } else if (name.equals("description")) { 1524 this.description = castToMarkdown(value); // MarkdownType 1525 } else if (name.equals("useContext")) { 1526 this.getUseContext().add(castToUsageContext(value)); 1527 } else if (name.equals("jurisdiction")) { 1528 this.getJurisdiction().add(castToCodeableConcept(value)); 1529 } else if (name.equals("usage")) { 1530 this.usage = castToString(value); // StringType 1531 } else if (name.equals("uniqueId")) { 1532 this.getUniqueId().add((NamingSystemUniqueIdComponent) value); 1533 } else 1534 return super.setProperty(name, value); 1535 return value; 1536 } 1537 1538 @Override 1539 public Base makeProperty(int hash, String name) throws FHIRException { 1540 switch (hash) { 1541 case 3373707: return getNameElement(); 1542 case -892481550: return getStatusElement(); 1543 case 3292052: return getKindElement(); 1544 case 3076014: return getDateElement(); 1545 case 1447404028: return getPublisherElement(); 1546 case 951526432: return addContact(); 1547 case 1847674614: return getResponsibleElement(); 1548 case 3575610: return getType(); 1549 case -1724546052: return getDescriptionElement(); 1550 case -669707736: return addUseContext(); 1551 case -507075711: return addJurisdiction(); 1552 case 111574433: return getUsageElement(); 1553 case -294460212: return addUniqueId(); 1554 default: return super.makeProperty(hash, name); 1555 } 1556 1557 } 1558 1559 @Override 1560 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1561 switch (hash) { 1562 case 3373707: /*name*/ return new String[] {"string"}; 1563 case -892481550: /*status*/ return new String[] {"code"}; 1564 case 3292052: /*kind*/ return new String[] {"code"}; 1565 case 3076014: /*date*/ return new String[] {"dateTime"}; 1566 case 1447404028: /*publisher*/ return new String[] {"string"}; 1567 case 951526432: /*contact*/ return new String[] {"ContactDetail"}; 1568 case 1847674614: /*responsible*/ return new String[] {"string"}; 1569 case 3575610: /*type*/ return new String[] {"CodeableConcept"}; 1570 case -1724546052: /*description*/ return new String[] {"markdown"}; 1571 case -669707736: /*useContext*/ return new String[] {"UsageContext"}; 1572 case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"}; 1573 case 111574433: /*usage*/ return new String[] {"string"}; 1574 case -294460212: /*uniqueId*/ return new String[] {}; 1575 default: return super.getTypesForProperty(hash, name); 1576 } 1577 1578 } 1579 1580 @Override 1581 public Base addChild(String name) throws FHIRException { 1582 if (name.equals("name")) { 1583 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.name"); 1584 } 1585 else if (name.equals("status")) { 1586 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.status"); 1587 } 1588 else if (name.equals("kind")) { 1589 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.kind"); 1590 } 1591 else if (name.equals("date")) { 1592 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.date"); 1593 } 1594 else if (name.equals("publisher")) { 1595 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.publisher"); 1596 } 1597 else if (name.equals("contact")) { 1598 return addContact(); 1599 } 1600 else if (name.equals("responsible")) { 1601 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.responsible"); 1602 } 1603 else if (name.equals("type")) { 1604 this.type = new CodeableConcept(); 1605 return this.type; 1606 } 1607 else if (name.equals("description")) { 1608 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.description"); 1609 } 1610 else if (name.equals("useContext")) { 1611 return addUseContext(); 1612 } 1613 else if (name.equals("jurisdiction")) { 1614 return addJurisdiction(); 1615 } 1616 else if (name.equals("usage")) { 1617 throw new FHIRException("Cannot call addChild on a primitive type NamingSystem.usage"); 1618 } 1619 else if (name.equals("uniqueId")) { 1620 return addUniqueId(); 1621 } 1622 else 1623 return super.addChild(name); 1624 } 1625 1626 public String fhirType() { 1627 return "NamingSystem"; 1628 1629 } 1630 1631 public NamingSystem copy() { 1632 NamingSystem dst = new NamingSystem(); 1633 copyValues(dst); 1634 return dst; 1635 } 1636 1637 public void copyValues(NamingSystem dst) { 1638 super.copyValues(dst); 1639 dst.name = name == null ? null : name.copy(); 1640 dst.status = status == null ? null : status.copy(); 1641 dst.kind = kind == null ? null : kind.copy(); 1642 dst.date = date == null ? null : date.copy(); 1643 dst.publisher = publisher == null ? null : publisher.copy(); 1644 if (contact != null) { 1645 dst.contact = new ArrayList<ContactDetail>(); 1646 for (ContactDetail i : contact) 1647 dst.contact.add(i.copy()); 1648 }; 1649 dst.responsible = responsible == null ? null : responsible.copy(); 1650 dst.type = type == null ? null : type.copy(); 1651 dst.description = description == null ? null : description.copy(); 1652 if (useContext != null) { 1653 dst.useContext = new ArrayList<UsageContext>(); 1654 for (UsageContext i : useContext) 1655 dst.useContext.add(i.copy()); 1656 }; 1657 if (jurisdiction != null) { 1658 dst.jurisdiction = new ArrayList<CodeableConcept>(); 1659 for (CodeableConcept i : jurisdiction) 1660 dst.jurisdiction.add(i.copy()); 1661 }; 1662 dst.usage = usage == null ? null : usage.copy(); 1663 if (uniqueId != null) { 1664 dst.uniqueId = new ArrayList<NamingSystemUniqueIdComponent>(); 1665 for (NamingSystemUniqueIdComponent i : uniqueId) 1666 dst.uniqueId.add(i.copy()); 1667 }; 1668 } 1669 1670 protected NamingSystem typedCopy() { 1671 return copy(); 1672 } 1673 1674 @Override 1675 public boolean equalsDeep(Base other_) { 1676 if (!super.equalsDeep(other_)) 1677 return false; 1678 if (!(other_ instanceof NamingSystem)) 1679 return false; 1680 NamingSystem o = (NamingSystem) other_; 1681 return compareDeep(kind, o.kind, true) && compareDeep(responsible, o.responsible, true) && compareDeep(type, o.type, true) 1682 && compareDeep(usage, o.usage, true) && compareDeep(uniqueId, o.uniqueId, true); 1683 } 1684 1685 @Override 1686 public boolean equalsShallow(Base other_) { 1687 if (!super.equalsShallow(other_)) 1688 return false; 1689 if (!(other_ instanceof NamingSystem)) 1690 return false; 1691 NamingSystem o = (NamingSystem) other_; 1692 return compareValues(kind, o.kind, true) && compareValues(responsible, o.responsible, true) && compareValues(usage, o.usage, true) 1693 ; 1694 } 1695 1696 public boolean isEmpty() { 1697 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(kind, responsible, type 1698 , usage, uniqueId); 1699 } 1700 1701 @Override 1702 public ResourceType getResourceType() { 1703 return ResourceType.NamingSystem; 1704 } 1705 1706 /** 1707 * Search parameter: <b>date</b> 1708 * <p> 1709 * Description: <b>The naming system publication date</b><br> 1710 * Type: <b>date</b><br> 1711 * Path: <b>NamingSystem.date</b><br> 1712 * </p> 1713 */ 1714 @SearchParamDefinition(name="date", path="NamingSystem.date", description="The naming system publication date", type="date" ) 1715 public static final String SP_DATE = "date"; 1716 /** 1717 * <b>Fluent Client</b> search parameter constant for <b>date</b> 1718 * <p> 1719 * Description: <b>The naming system publication date</b><br> 1720 * Type: <b>date</b><br> 1721 * Path: <b>NamingSystem.date</b><br> 1722 * </p> 1723 */ 1724 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE); 1725 1726 /** 1727 * Search parameter: <b>period</b> 1728 * <p> 1729 * Description: <b>When is identifier valid?</b><br> 1730 * Type: <b>date</b><br> 1731 * Path: <b>NamingSystem.uniqueId.period</b><br> 1732 * </p> 1733 */ 1734 @SearchParamDefinition(name="period", path="NamingSystem.uniqueId.period", description="When is identifier valid?", type="date" ) 1735 public static final String SP_PERIOD = "period"; 1736 /** 1737 * <b>Fluent Client</b> search parameter constant for <b>period</b> 1738 * <p> 1739 * Description: <b>When is identifier valid?</b><br> 1740 * Type: <b>date</b><br> 1741 * Path: <b>NamingSystem.uniqueId.period</b><br> 1742 * </p> 1743 */ 1744 public static final ca.uhn.fhir.rest.gclient.DateClientParam PERIOD = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_PERIOD); 1745 1746 /** 1747 * Search parameter: <b>context-type-value</b> 1748 * <p> 1749 * Description: <b>A use context type and value assigned to the naming system</b><br> 1750 * Type: <b>composite</b><br> 1751 * Path: <b></b><br> 1752 * </p> 1753 */ 1754 @SearchParamDefinition(name="context-type-value", path="NamingSystem.useContext", description="A use context type and value assigned to the naming system", type="composite", compositeOf={"context-type", "context"} ) 1755 public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value"; 1756 /** 1757 * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b> 1758 * <p> 1759 * Description: <b>A use context type and value assigned to the naming system</b><br> 1760 * Type: <b>composite</b><br> 1761 * Path: <b></b><br> 1762 * </p> 1763 */ 1764 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CONTEXT_TYPE_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>(SP_CONTEXT_TYPE_VALUE); 1765 1766 /** 1767 * Search parameter: <b>kind</b> 1768 * <p> 1769 * Description: <b>codesystem | identifier | root</b><br> 1770 * Type: <b>token</b><br> 1771 * Path: <b>NamingSystem.kind</b><br> 1772 * </p> 1773 */ 1774 @SearchParamDefinition(name="kind", path="NamingSystem.kind", description="codesystem | identifier | root", type="token" ) 1775 public static final String SP_KIND = "kind"; 1776 /** 1777 * <b>Fluent Client</b> search parameter constant for <b>kind</b> 1778 * <p> 1779 * Description: <b>codesystem | identifier | root</b><br> 1780 * Type: <b>token</b><br> 1781 * Path: <b>NamingSystem.kind</b><br> 1782 * </p> 1783 */ 1784 public static final ca.uhn.fhir.rest.gclient.TokenClientParam KIND = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_KIND); 1785 1786 /** 1787 * Search parameter: <b>jurisdiction</b> 1788 * <p> 1789 * Description: <b>Intended jurisdiction for the naming system</b><br> 1790 * Type: <b>token</b><br> 1791 * Path: <b>NamingSystem.jurisdiction</b><br> 1792 * </p> 1793 */ 1794 @SearchParamDefinition(name="jurisdiction", path="NamingSystem.jurisdiction", description="Intended jurisdiction for the naming system", type="token" ) 1795 public static final String SP_JURISDICTION = "jurisdiction"; 1796 /** 1797 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 1798 * <p> 1799 * Description: <b>Intended jurisdiction for the naming system</b><br> 1800 * Type: <b>token</b><br> 1801 * Path: <b>NamingSystem.jurisdiction</b><br> 1802 * </p> 1803 */ 1804 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION); 1805 1806 /** 1807 * Search parameter: <b>description</b> 1808 * <p> 1809 * Description: <b>The description of the naming system</b><br> 1810 * Type: <b>string</b><br> 1811 * Path: <b>NamingSystem.description</b><br> 1812 * </p> 1813 */ 1814 @SearchParamDefinition(name="description", path="NamingSystem.description", description="The description of the naming system", type="string" ) 1815 public static final String SP_DESCRIPTION = "description"; 1816 /** 1817 * <b>Fluent Client</b> search parameter constant for <b>description</b> 1818 * <p> 1819 * Description: <b>The description of the naming system</b><br> 1820 * Type: <b>string</b><br> 1821 * Path: <b>NamingSystem.description</b><br> 1822 * </p> 1823 */ 1824 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION); 1825 1826 /** 1827 * Search parameter: <b>context-type</b> 1828 * <p> 1829 * Description: <b>A type of use context assigned to the naming system</b><br> 1830 * Type: <b>token</b><br> 1831 * Path: <b>NamingSystem.useContext.code</b><br> 1832 * </p> 1833 */ 1834 @SearchParamDefinition(name="context-type", path="NamingSystem.useContext.code", description="A type of use context assigned to the naming system", type="token" ) 1835 public static final String SP_CONTEXT_TYPE = "context-type"; 1836 /** 1837 * <b>Fluent Client</b> search parameter constant for <b>context-type</b> 1838 * <p> 1839 * Description: <b>A type of use context assigned to the naming system</b><br> 1840 * Type: <b>token</b><br> 1841 * Path: <b>NamingSystem.useContext.code</b><br> 1842 * </p> 1843 */ 1844 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE); 1845 1846 /** 1847 * Search parameter: <b>type</b> 1848 * <p> 1849 * Description: <b>e.g. driver, provider, patient, bank etc.</b><br> 1850 * Type: <b>token</b><br> 1851 * Path: <b>NamingSystem.type</b><br> 1852 * </p> 1853 */ 1854 @SearchParamDefinition(name="type", path="NamingSystem.type", description="e.g. driver, provider, patient, bank etc.", type="token" ) 1855 public static final String SP_TYPE = "type"; 1856 /** 1857 * <b>Fluent Client</b> search parameter constant for <b>type</b> 1858 * <p> 1859 * Description: <b>e.g. driver, provider, patient, bank etc.</b><br> 1860 * Type: <b>token</b><br> 1861 * Path: <b>NamingSystem.type</b><br> 1862 * </p> 1863 */ 1864 public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE); 1865 1866 /** 1867 * Search parameter: <b>id-type</b> 1868 * <p> 1869 * Description: <b>oid | uuid | uri | other</b><br> 1870 * Type: <b>token</b><br> 1871 * Path: <b>NamingSystem.uniqueId.type</b><br> 1872 * </p> 1873 */ 1874 @SearchParamDefinition(name="id-type", path="NamingSystem.uniqueId.type", description="oid | uuid | uri | other", type="token" ) 1875 public static final String SP_ID_TYPE = "id-type"; 1876 /** 1877 * <b>Fluent Client</b> search parameter constant for <b>id-type</b> 1878 * <p> 1879 * Description: <b>oid | uuid | uri | other</b><br> 1880 * Type: <b>token</b><br> 1881 * Path: <b>NamingSystem.uniqueId.type</b><br> 1882 * </p> 1883 */ 1884 public static final ca.uhn.fhir.rest.gclient.TokenClientParam ID_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_ID_TYPE); 1885 1886 /** 1887 * Search parameter: <b>context-quantity</b> 1888 * <p> 1889 * Description: <b>A quantity- or range-valued use context assigned to the naming system</b><br> 1890 * Type: <b>quantity</b><br> 1891 * Path: <b>NamingSystem.useContext.valueQuantity, NamingSystem.useContext.valueRange</b><br> 1892 * </p> 1893 */ 1894 @SearchParamDefinition(name="context-quantity", path="(NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range)", description="A quantity- or range-valued use context assigned to the naming system", type="quantity" ) 1895 public static final String SP_CONTEXT_QUANTITY = "context-quantity"; 1896 /** 1897 * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b> 1898 * <p> 1899 * Description: <b>A quantity- or range-valued use context assigned to the naming system</b><br> 1900 * Type: <b>quantity</b><br> 1901 * Path: <b>NamingSystem.useContext.valueQuantity, NamingSystem.useContext.valueRange</b><br> 1902 * </p> 1903 */ 1904 public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY); 1905 1906 /** 1907 * Search parameter: <b>responsible</b> 1908 * <p> 1909 * Description: <b>Who maintains system namespace?</b><br> 1910 * Type: <b>string</b><br> 1911 * Path: <b>NamingSystem.responsible</b><br> 1912 * </p> 1913 */ 1914 @SearchParamDefinition(name="responsible", path="NamingSystem.responsible", description="Who maintains system namespace?", type="string" ) 1915 public static final String SP_RESPONSIBLE = "responsible"; 1916 /** 1917 * <b>Fluent Client</b> search parameter constant for <b>responsible</b> 1918 * <p> 1919 * Description: <b>Who maintains system namespace?</b><br> 1920 * Type: <b>string</b><br> 1921 * Path: <b>NamingSystem.responsible</b><br> 1922 * </p> 1923 */ 1924 public static final ca.uhn.fhir.rest.gclient.StringClientParam RESPONSIBLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_RESPONSIBLE); 1925 1926 /** 1927 * Search parameter: <b>contact</b> 1928 * <p> 1929 * Description: <b>Name of an individual to contact</b><br> 1930 * Type: <b>string</b><br> 1931 * Path: <b>NamingSystem.contact.name</b><br> 1932 * </p> 1933 */ 1934 @SearchParamDefinition(name="contact", path="NamingSystem.contact.name", description="Name of an individual to contact", type="string" ) 1935 public static final String SP_CONTACT = "contact"; 1936 /** 1937 * <b>Fluent Client</b> search parameter constant for <b>contact</b> 1938 * <p> 1939 * Description: <b>Name of an individual to contact</b><br> 1940 * Type: <b>string</b><br> 1941 * Path: <b>NamingSystem.contact.name</b><br> 1942 * </p> 1943 */ 1944 public static final ca.uhn.fhir.rest.gclient.StringClientParam CONTACT = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_CONTACT); 1945 1946 /** 1947 * Search parameter: <b>name</b> 1948 * <p> 1949 * Description: <b>Computationally friendly name of the naming system</b><br> 1950 * Type: <b>string</b><br> 1951 * Path: <b>NamingSystem.name</b><br> 1952 * </p> 1953 */ 1954 @SearchParamDefinition(name="name", path="NamingSystem.name", description="Computationally friendly name of the naming system", type="string" ) 1955 public static final String SP_NAME = "name"; 1956 /** 1957 * <b>Fluent Client</b> search parameter constant for <b>name</b> 1958 * <p> 1959 * Description: <b>Computationally friendly name of the naming system</b><br> 1960 * Type: <b>string</b><br> 1961 * Path: <b>NamingSystem.name</b><br> 1962 * </p> 1963 */ 1964 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME); 1965 1966 /** 1967 * Search parameter: <b>context</b> 1968 * <p> 1969 * Description: <b>A use context assigned to the naming system</b><br> 1970 * Type: <b>token</b><br> 1971 * Path: <b>NamingSystem.useContext.valueCodeableConcept</b><br> 1972 * </p> 1973 */ 1974 @SearchParamDefinition(name="context", path="(NamingSystem.useContext.value as CodeableConcept)", description="A use context assigned to the naming system", type="token" ) 1975 public static final String SP_CONTEXT = "context"; 1976 /** 1977 * <b>Fluent Client</b> search parameter constant for <b>context</b> 1978 * <p> 1979 * Description: <b>A use context assigned to the naming system</b><br> 1980 * Type: <b>token</b><br> 1981 * Path: <b>NamingSystem.useContext.valueCodeableConcept</b><br> 1982 * </p> 1983 */ 1984 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT); 1985 1986 /** 1987 * Search parameter: <b>publisher</b> 1988 * <p> 1989 * Description: <b>Name of the publisher of the naming system</b><br> 1990 * Type: <b>string</b><br> 1991 * Path: <b>NamingSystem.publisher</b><br> 1992 * </p> 1993 */ 1994 @SearchParamDefinition(name="publisher", path="NamingSystem.publisher", description="Name of the publisher of the naming system", type="string" ) 1995 public static final String SP_PUBLISHER = "publisher"; 1996 /** 1997 * <b>Fluent Client</b> search parameter constant for <b>publisher</b> 1998 * <p> 1999 * Description: <b>Name of the publisher of the naming system</b><br> 2000 * Type: <b>string</b><br> 2001 * Path: <b>NamingSystem.publisher</b><br> 2002 * </p> 2003 */ 2004 public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER); 2005 2006 /** 2007 * Search parameter: <b>telecom</b> 2008 * <p> 2009 * Description: <b>Contact details for individual or organization</b><br> 2010 * Type: <b>token</b><br> 2011 * Path: <b>NamingSystem.contact.telecom</b><br> 2012 * </p> 2013 */ 2014 @SearchParamDefinition(name="telecom", path="NamingSystem.contact.telecom", description="Contact details for individual or organization", type="token" ) 2015 public static final String SP_TELECOM = "telecom"; 2016 /** 2017 * <b>Fluent Client</b> search parameter constant for <b>telecom</b> 2018 * <p> 2019 * Description: <b>Contact details for individual or organization</b><br> 2020 * Type: <b>token</b><br> 2021 * Path: <b>NamingSystem.contact.telecom</b><br> 2022 * </p> 2023 */ 2024 public static final ca.uhn.fhir.rest.gclient.TokenClientParam TELECOM = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TELECOM); 2025 2026 /** 2027 * Search parameter: <b>value</b> 2028 * <p> 2029 * Description: <b>The unique identifier</b><br> 2030 * Type: <b>string</b><br> 2031 * Path: <b>NamingSystem.uniqueId.value</b><br> 2032 * </p> 2033 */ 2034 @SearchParamDefinition(name="value", path="NamingSystem.uniqueId.value", description="The unique identifier", type="string" ) 2035 public static final String SP_VALUE = "value"; 2036 /** 2037 * <b>Fluent Client</b> search parameter constant for <b>value</b> 2038 * <p> 2039 * Description: <b>The unique identifier</b><br> 2040 * Type: <b>string</b><br> 2041 * Path: <b>NamingSystem.uniqueId.value</b><br> 2042 * </p> 2043 */ 2044 public static final ca.uhn.fhir.rest.gclient.StringClientParam VALUE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_VALUE); 2045 2046 /** 2047 * Search parameter: <b>context-type-quantity</b> 2048 * <p> 2049 * Description: <b>A use context type and quantity- or range-based value assigned to the naming system</b><br> 2050 * Type: <b>composite</b><br> 2051 * Path: <b></b><br> 2052 * </p> 2053 */ 2054 @SearchParamDefinition(name="context-type-quantity", path="NamingSystem.useContext", description="A use context type and quantity- or range-based value assigned to the naming system", type="composite", compositeOf={"context-type", "context-quantity"} ) 2055 public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity"; 2056 /** 2057 * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b> 2058 * <p> 2059 * Description: <b>A use context type and quantity- or range-based value assigned to the naming system</b><br> 2060 * Type: <b>composite</b><br> 2061 * Path: <b></b><br> 2062 * </p> 2063 */ 2064 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam> CONTEXT_TYPE_QUANTITY = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam>(SP_CONTEXT_TYPE_QUANTITY); 2065 2066 /** 2067 * Search parameter: <b>status</b> 2068 * <p> 2069 * Description: <b>The current status of the naming system</b><br> 2070 * Type: <b>token</b><br> 2071 * Path: <b>NamingSystem.status</b><br> 2072 * </p> 2073 */ 2074 @SearchParamDefinition(name="status", path="NamingSystem.status", description="The current status of the naming system", type="token" ) 2075 public static final String SP_STATUS = "status"; 2076 /** 2077 * <b>Fluent Client</b> search parameter constant for <b>status</b> 2078 * <p> 2079 * Description: <b>The current status of the naming system</b><br> 2080 * Type: <b>token</b><br> 2081 * Path: <b>NamingSystem.status</b><br> 2082 * </p> 2083 */ 2084 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 2085 2086 2087}