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