001package org.hl7.fhir.dstu2.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 Wed, Jul 13, 2016 05:32+1000 for FHIR v1.0.2 033import java.util.ArrayList; 034import java.util.Date; 035import java.util.List; 036 037import org.hl7.fhir.dstu2.model.Enumerations.ConformanceResourceStatus; 038import org.hl7.fhir.dstu2.model.Enumerations.ConformanceResourceStatusEnumFactory; 039import ca.uhn.fhir.model.api.annotation.Block; 040import ca.uhn.fhir.model.api.annotation.Child; 041import ca.uhn.fhir.model.api.annotation.Description; 042import ca.uhn.fhir.model.api.annotation.ResourceDef; 043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 044import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 045import org.hl7.fhir.exceptions.FHIRException; 046import org.hl7.fhir.utilities.Utilities; 047 048/** 049 * A set of rules or how FHIR is used to solve a particular problem. This 050 * resource is used to gather all the parts of an implementation guide into a 051 * logical whole, and to publish a computable definition of all the parts. 052 */ 053@ResourceDef(name = "ImplementationGuide", profile = "http://hl7.org/fhir/Profile/ImplementationGuide") 054public class ImplementationGuide extends DomainResource { 055 056 public enum GuideDependencyType { 057 /** 058 * The guide is referred to by URL. 059 */ 060 REFERENCE, 061 /** 062 * The guide is embedded in this guide when published. 063 */ 064 INCLUSION, 065 /** 066 * added to help the parsers 067 */ 068 NULL; 069 070 public static GuideDependencyType fromCode(String codeString) throws FHIRException { 071 if (codeString == null || "".equals(codeString)) 072 return null; 073 if ("reference".equals(codeString)) 074 return REFERENCE; 075 if ("inclusion".equals(codeString)) 076 return INCLUSION; 077 throw new FHIRException("Unknown GuideDependencyType code '" + codeString + "'"); 078 } 079 080 public String toCode() { 081 switch (this) { 082 case REFERENCE: 083 return "reference"; 084 case INCLUSION: 085 return "inclusion"; 086 case NULL: 087 return null; 088 default: 089 return "?"; 090 } 091 } 092 093 public String getSystem() { 094 switch (this) { 095 case REFERENCE: 096 return "http://hl7.org/fhir/guide-dependency-type"; 097 case INCLUSION: 098 return "http://hl7.org/fhir/guide-dependency-type"; 099 case NULL: 100 return null; 101 default: 102 return "?"; 103 } 104 } 105 106 public String getDefinition() { 107 switch (this) { 108 case REFERENCE: 109 return "The guide is referred to by URL."; 110 case INCLUSION: 111 return "The guide is embedded in this guide when published."; 112 case NULL: 113 return null; 114 default: 115 return "?"; 116 } 117 } 118 119 public String getDisplay() { 120 switch (this) { 121 case REFERENCE: 122 return "Reference"; 123 case INCLUSION: 124 return "Inclusion"; 125 case NULL: 126 return null; 127 default: 128 return "?"; 129 } 130 } 131 } 132 133 public static class GuideDependencyTypeEnumFactory implements EnumFactory<GuideDependencyType> { 134 public GuideDependencyType fromCode(String codeString) throws IllegalArgumentException { 135 if (codeString == null || "".equals(codeString)) 136 if (codeString == null || "".equals(codeString)) 137 return null; 138 if ("reference".equals(codeString)) 139 return GuideDependencyType.REFERENCE; 140 if ("inclusion".equals(codeString)) 141 return GuideDependencyType.INCLUSION; 142 throw new IllegalArgumentException("Unknown GuideDependencyType code '" + codeString + "'"); 143 } 144 145 public Enumeration<GuideDependencyType> fromType(Base code) throws FHIRException { 146 if (code == null || code.isEmpty()) 147 return null; 148 String codeString = ((PrimitiveType) code).asStringValue(); 149 if (codeString == null || "".equals(codeString)) 150 return null; 151 if ("reference".equals(codeString)) 152 return new Enumeration<GuideDependencyType>(this, GuideDependencyType.REFERENCE); 153 if ("inclusion".equals(codeString)) 154 return new Enumeration<GuideDependencyType>(this, GuideDependencyType.INCLUSION); 155 throw new FHIRException("Unknown GuideDependencyType code '" + codeString + "'"); 156 } 157 158 public String toCode(GuideDependencyType code) { 159 if (code == GuideDependencyType.REFERENCE) 160 return "reference"; 161 if (code == GuideDependencyType.INCLUSION) 162 return "inclusion"; 163 return "?"; 164 } 165 } 166 167 public enum GuideResourcePurpose { 168 /** 169 * The resource is intended as an example. 170 */ 171 EXAMPLE, 172 /** 173 * The resource defines a value set or concept map used in the implementation 174 * guide. 175 */ 176 TERMINOLOGY, 177 /** 178 * The resource defines a profile (StructureDefinition) that is used in the 179 * implementation guide. 180 */ 181 PROFILE, 182 /** 183 * The resource defines an extension (StructureDefinition) that is used in the 184 * implementation guide. 185 */ 186 EXTENSION, 187 /** 188 * The resource contains a dictionary that is part of the implementation guide. 189 */ 190 DICTIONARY, 191 /** 192 * The resource defines a logical model (in a StructureDefinition) that is used 193 * in the implementation guide. 194 */ 195 LOGICAL, 196 /** 197 * added to help the parsers 198 */ 199 NULL; 200 201 public static GuideResourcePurpose fromCode(String codeString) throws FHIRException { 202 if (codeString == null || "".equals(codeString)) 203 return null; 204 if ("example".equals(codeString)) 205 return EXAMPLE; 206 if ("terminology".equals(codeString)) 207 return TERMINOLOGY; 208 if ("profile".equals(codeString)) 209 return PROFILE; 210 if ("extension".equals(codeString)) 211 return EXTENSION; 212 if ("dictionary".equals(codeString)) 213 return DICTIONARY; 214 if ("logical".equals(codeString)) 215 return LOGICAL; 216 throw new FHIRException("Unknown GuideResourcePurpose code '" + codeString + "'"); 217 } 218 219 public String toCode() { 220 switch (this) { 221 case EXAMPLE: 222 return "example"; 223 case TERMINOLOGY: 224 return "terminology"; 225 case PROFILE: 226 return "profile"; 227 case EXTENSION: 228 return "extension"; 229 case DICTIONARY: 230 return "dictionary"; 231 case LOGICAL: 232 return "logical"; 233 case NULL: 234 return null; 235 default: 236 return "?"; 237 } 238 } 239 240 public String getSystem() { 241 switch (this) { 242 case EXAMPLE: 243 return "http://hl7.org/fhir/guide-resource-purpose"; 244 case TERMINOLOGY: 245 return "http://hl7.org/fhir/guide-resource-purpose"; 246 case PROFILE: 247 return "http://hl7.org/fhir/guide-resource-purpose"; 248 case EXTENSION: 249 return "http://hl7.org/fhir/guide-resource-purpose"; 250 case DICTIONARY: 251 return "http://hl7.org/fhir/guide-resource-purpose"; 252 case LOGICAL: 253 return "http://hl7.org/fhir/guide-resource-purpose"; 254 case NULL: 255 return null; 256 default: 257 return "?"; 258 } 259 } 260 261 public String getDefinition() { 262 switch (this) { 263 case EXAMPLE: 264 return "The resource is intended as an example."; 265 case TERMINOLOGY: 266 return "The resource defines a value set or concept map used in the implementation guide."; 267 case PROFILE: 268 return "The resource defines a profile (StructureDefinition) that is used in the implementation guide."; 269 case EXTENSION: 270 return "The resource defines an extension (StructureDefinition) that is used in the implementation guide."; 271 case DICTIONARY: 272 return "The resource contains a dictionary that is part of the implementation guide."; 273 case LOGICAL: 274 return "The resource defines a logical model (in a StructureDefinition) that is used in the implementation guide."; 275 case NULL: 276 return null; 277 default: 278 return "?"; 279 } 280 } 281 282 public String getDisplay() { 283 switch (this) { 284 case EXAMPLE: 285 return "Example"; 286 case TERMINOLOGY: 287 return "Terminology"; 288 case PROFILE: 289 return "Profile"; 290 case EXTENSION: 291 return "Extension"; 292 case DICTIONARY: 293 return "Dictionary"; 294 case LOGICAL: 295 return "Logical Model"; 296 case NULL: 297 return null; 298 default: 299 return "?"; 300 } 301 } 302 } 303 304 public static class GuideResourcePurposeEnumFactory implements EnumFactory<GuideResourcePurpose> { 305 public GuideResourcePurpose fromCode(String codeString) throws IllegalArgumentException { 306 if (codeString == null || "".equals(codeString)) 307 if (codeString == null || "".equals(codeString)) 308 return null; 309 if ("example".equals(codeString)) 310 return GuideResourcePurpose.EXAMPLE; 311 if ("terminology".equals(codeString)) 312 return GuideResourcePurpose.TERMINOLOGY; 313 if ("profile".equals(codeString)) 314 return GuideResourcePurpose.PROFILE; 315 if ("extension".equals(codeString)) 316 return GuideResourcePurpose.EXTENSION; 317 if ("dictionary".equals(codeString)) 318 return GuideResourcePurpose.DICTIONARY; 319 if ("logical".equals(codeString)) 320 return GuideResourcePurpose.LOGICAL; 321 throw new IllegalArgumentException("Unknown GuideResourcePurpose code '" + codeString + "'"); 322 } 323 324 public Enumeration<GuideResourcePurpose> fromType(Base code) throws FHIRException { 325 if (code == null || code.isEmpty()) 326 return null; 327 String codeString = ((PrimitiveType) code).asStringValue(); 328 if (codeString == null || "".equals(codeString)) 329 return null; 330 if ("example".equals(codeString)) 331 return new Enumeration<GuideResourcePurpose>(this, GuideResourcePurpose.EXAMPLE); 332 if ("terminology".equals(codeString)) 333 return new Enumeration<GuideResourcePurpose>(this, GuideResourcePurpose.TERMINOLOGY); 334 if ("profile".equals(codeString)) 335 return new Enumeration<GuideResourcePurpose>(this, GuideResourcePurpose.PROFILE); 336 if ("extension".equals(codeString)) 337 return new Enumeration<GuideResourcePurpose>(this, GuideResourcePurpose.EXTENSION); 338 if ("dictionary".equals(codeString)) 339 return new Enumeration<GuideResourcePurpose>(this, GuideResourcePurpose.DICTIONARY); 340 if ("logical".equals(codeString)) 341 return new Enumeration<GuideResourcePurpose>(this, GuideResourcePurpose.LOGICAL); 342 throw new FHIRException("Unknown GuideResourcePurpose code '" + codeString + "'"); 343 } 344 345 public String toCode(GuideResourcePurpose code) { 346 if (code == GuideResourcePurpose.EXAMPLE) 347 return "example"; 348 if (code == GuideResourcePurpose.TERMINOLOGY) 349 return "terminology"; 350 if (code == GuideResourcePurpose.PROFILE) 351 return "profile"; 352 if (code == GuideResourcePurpose.EXTENSION) 353 return "extension"; 354 if (code == GuideResourcePurpose.DICTIONARY) 355 return "dictionary"; 356 if (code == GuideResourcePurpose.LOGICAL) 357 return "logical"; 358 return "?"; 359 } 360 } 361 362 public enum GuidePageKind { 363 /** 364 * This is a page of content that is included in the implementation guide. It 365 * has no particular function. 366 */ 367 PAGE, 368 /** 369 * This is a page that represents a human readable rendering of an example. 370 */ 371 EXAMPLE, 372 /** 373 * This is a page that represents a list of resources of one or more types. 374 */ 375 LIST, 376 /** 377 * This is a page showing where an included guide is injected. 378 */ 379 INCLUDE, 380 /** 381 * This is a page that lists the resources of a given type, and also creates 382 * pages for all the listed types as other pages in the section. 383 */ 384 DIRECTORY, 385 /** 386 * This is a page that creates the listed resources as a dictionary. 387 */ 388 DICTIONARY, 389 /** 390 * This is a generated page that contains the table of contents. 391 */ 392 TOC, 393 /** 394 * This is a page that represents a presented resource. This is typically used 395 * for generated conformance resource presentations. 396 */ 397 RESOURCE, 398 /** 399 * added to help the parsers 400 */ 401 NULL; 402 403 public static GuidePageKind fromCode(String codeString) throws FHIRException { 404 if (codeString == null || "".equals(codeString)) 405 return null; 406 if ("page".equals(codeString)) 407 return PAGE; 408 if ("example".equals(codeString)) 409 return EXAMPLE; 410 if ("list".equals(codeString)) 411 return LIST; 412 if ("include".equals(codeString)) 413 return INCLUDE; 414 if ("directory".equals(codeString)) 415 return DIRECTORY; 416 if ("dictionary".equals(codeString)) 417 return DICTIONARY; 418 if ("toc".equals(codeString)) 419 return TOC; 420 if ("resource".equals(codeString)) 421 return RESOURCE; 422 throw new FHIRException("Unknown GuidePageKind code '" + codeString + "'"); 423 } 424 425 public String toCode() { 426 switch (this) { 427 case PAGE: 428 return "page"; 429 case EXAMPLE: 430 return "example"; 431 case LIST: 432 return "list"; 433 case INCLUDE: 434 return "include"; 435 case DIRECTORY: 436 return "directory"; 437 case DICTIONARY: 438 return "dictionary"; 439 case TOC: 440 return "toc"; 441 case RESOURCE: 442 return "resource"; 443 case NULL: 444 return null; 445 default: 446 return "?"; 447 } 448 } 449 450 public String getSystem() { 451 switch (this) { 452 case PAGE: 453 return "http://hl7.org/fhir/guide-page-kind"; 454 case EXAMPLE: 455 return "http://hl7.org/fhir/guide-page-kind"; 456 case LIST: 457 return "http://hl7.org/fhir/guide-page-kind"; 458 case INCLUDE: 459 return "http://hl7.org/fhir/guide-page-kind"; 460 case DIRECTORY: 461 return "http://hl7.org/fhir/guide-page-kind"; 462 case DICTIONARY: 463 return "http://hl7.org/fhir/guide-page-kind"; 464 case TOC: 465 return "http://hl7.org/fhir/guide-page-kind"; 466 case RESOURCE: 467 return "http://hl7.org/fhir/guide-page-kind"; 468 case NULL: 469 return null; 470 default: 471 return "?"; 472 } 473 } 474 475 public String getDefinition() { 476 switch (this) { 477 case PAGE: 478 return "This is a page of content that is included in the implementation guide. It has no particular function."; 479 case EXAMPLE: 480 return "This is a page that represents a human readable rendering of an example."; 481 case LIST: 482 return "This is a page that represents a list of resources of one or more types."; 483 case INCLUDE: 484 return "This is a page showing where an included guide is injected."; 485 case DIRECTORY: 486 return "This is a page that lists the resources of a given type, and also creates pages for all the listed types as other pages in the section."; 487 case DICTIONARY: 488 return "This is a page that creates the listed resources as a dictionary."; 489 case TOC: 490 return "This is a generated page that contains the table of contents."; 491 case RESOURCE: 492 return "This is a page that represents a presented resource. This is typically used for generated conformance resource presentations."; 493 case NULL: 494 return null; 495 default: 496 return "?"; 497 } 498 } 499 500 public String getDisplay() { 501 switch (this) { 502 case PAGE: 503 return "Page"; 504 case EXAMPLE: 505 return "Example"; 506 case LIST: 507 return "List"; 508 case INCLUDE: 509 return "Include"; 510 case DIRECTORY: 511 return "Directory"; 512 case DICTIONARY: 513 return "Dictionary"; 514 case TOC: 515 return "Table Of Contents"; 516 case RESOURCE: 517 return "Resource"; 518 case NULL: 519 return null; 520 default: 521 return "?"; 522 } 523 } 524 } 525 526 public static class GuidePageKindEnumFactory implements EnumFactory<GuidePageKind> { 527 public GuidePageKind fromCode(String codeString) throws IllegalArgumentException { 528 if (codeString == null || "".equals(codeString)) 529 if (codeString == null || "".equals(codeString)) 530 return null; 531 if ("page".equals(codeString)) 532 return GuidePageKind.PAGE; 533 if ("example".equals(codeString)) 534 return GuidePageKind.EXAMPLE; 535 if ("list".equals(codeString)) 536 return GuidePageKind.LIST; 537 if ("include".equals(codeString)) 538 return GuidePageKind.INCLUDE; 539 if ("directory".equals(codeString)) 540 return GuidePageKind.DIRECTORY; 541 if ("dictionary".equals(codeString)) 542 return GuidePageKind.DICTIONARY; 543 if ("toc".equals(codeString)) 544 return GuidePageKind.TOC; 545 if ("resource".equals(codeString)) 546 return GuidePageKind.RESOURCE; 547 throw new IllegalArgumentException("Unknown GuidePageKind code '" + codeString + "'"); 548 } 549 550 public Enumeration<GuidePageKind> fromType(Base code) throws FHIRException { 551 if (code == null || code.isEmpty()) 552 return null; 553 String codeString = ((PrimitiveType) code).asStringValue(); 554 if (codeString == null || "".equals(codeString)) 555 return null; 556 if ("page".equals(codeString)) 557 return new Enumeration<GuidePageKind>(this, GuidePageKind.PAGE); 558 if ("example".equals(codeString)) 559 return new Enumeration<GuidePageKind>(this, GuidePageKind.EXAMPLE); 560 if ("list".equals(codeString)) 561 return new Enumeration<GuidePageKind>(this, GuidePageKind.LIST); 562 if ("include".equals(codeString)) 563 return new Enumeration<GuidePageKind>(this, GuidePageKind.INCLUDE); 564 if ("directory".equals(codeString)) 565 return new Enumeration<GuidePageKind>(this, GuidePageKind.DIRECTORY); 566 if ("dictionary".equals(codeString)) 567 return new Enumeration<GuidePageKind>(this, GuidePageKind.DICTIONARY); 568 if ("toc".equals(codeString)) 569 return new Enumeration<GuidePageKind>(this, GuidePageKind.TOC); 570 if ("resource".equals(codeString)) 571 return new Enumeration<GuidePageKind>(this, GuidePageKind.RESOURCE); 572 throw new FHIRException("Unknown GuidePageKind code '" + codeString + "'"); 573 } 574 575 public String toCode(GuidePageKind code) { 576 if (code == GuidePageKind.PAGE) 577 return "page"; 578 if (code == GuidePageKind.EXAMPLE) 579 return "example"; 580 if (code == GuidePageKind.LIST) 581 return "list"; 582 if (code == GuidePageKind.INCLUDE) 583 return "include"; 584 if (code == GuidePageKind.DIRECTORY) 585 return "directory"; 586 if (code == GuidePageKind.DICTIONARY) 587 return "dictionary"; 588 if (code == GuidePageKind.TOC) 589 return "toc"; 590 if (code == GuidePageKind.RESOURCE) 591 return "resource"; 592 return "?"; 593 } 594 } 595 596 @Block() 597 public static class ImplementationGuideContactComponent extends BackboneElement implements IBaseBackboneElement { 598 /** 599 * The name of an individual to contact regarding the implementation guide. 600 */ 601 @Child(name = "name", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = true) 602 @Description(shortDefinition = "Name of a individual to contact", formalDefinition = "The name of an individual to contact regarding the implementation guide.") 603 protected StringType name; 604 605 /** 606 * Contact details for individual (if a name was provided) or the publisher. 607 */ 608 @Child(name = "telecom", type = { 609 ContactPoint.class }, order = 2, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 610 @Description(shortDefinition = "Contact details for individual or publisher", formalDefinition = "Contact details for individual (if a name was provided) or the publisher.") 611 protected List<ContactPoint> telecom; 612 613 private static final long serialVersionUID = -1179697803L; 614 615 /* 616 * Constructor 617 */ 618 public ImplementationGuideContactComponent() { 619 super(); 620 } 621 622 /** 623 * @return {@link #name} (The name of an individual to contact regarding the 624 * implementation guide.). This is the underlying object with id, value 625 * and extensions. The accessor "getName" gives direct access to the 626 * value 627 */ 628 public StringType getNameElement() { 629 if (this.name == null) 630 if (Configuration.errorOnAutoCreate()) 631 throw new Error("Attempt to auto-create ImplementationGuideContactComponent.name"); 632 else if (Configuration.doAutoCreate()) 633 this.name = new StringType(); // bb 634 return this.name; 635 } 636 637 public boolean hasNameElement() { 638 return this.name != null && !this.name.isEmpty(); 639 } 640 641 public boolean hasName() { 642 return this.name != null && !this.name.isEmpty(); 643 } 644 645 /** 646 * @param value {@link #name} (The name of an individual to contact regarding 647 * the implementation guide.). This is the underlying object with 648 * id, value and extensions. The accessor "getName" gives direct 649 * access to the value 650 */ 651 public ImplementationGuideContactComponent setNameElement(StringType value) { 652 this.name = value; 653 return this; 654 } 655 656 /** 657 * @return The name of an individual to contact regarding the implementation 658 * guide. 659 */ 660 public String getName() { 661 return this.name == null ? null : this.name.getValue(); 662 } 663 664 /** 665 * @param value The name of an individual to contact regarding the 666 * implementation guide. 667 */ 668 public ImplementationGuideContactComponent setName(String value) { 669 if (Utilities.noString(value)) 670 this.name = null; 671 else { 672 if (this.name == null) 673 this.name = new StringType(); 674 this.name.setValue(value); 675 } 676 return this; 677 } 678 679 /** 680 * @return {@link #telecom} (Contact details for individual (if a name was 681 * provided) or the publisher.) 682 */ 683 public List<ContactPoint> getTelecom() { 684 if (this.telecom == null) 685 this.telecom = new ArrayList<ContactPoint>(); 686 return this.telecom; 687 } 688 689 public boolean hasTelecom() { 690 if (this.telecom == null) 691 return false; 692 for (ContactPoint item : this.telecom) 693 if (!item.isEmpty()) 694 return true; 695 return false; 696 } 697 698 /** 699 * @return {@link #telecom} (Contact details for individual (if a name was 700 * provided) or the publisher.) 701 */ 702 // syntactic sugar 703 public ContactPoint addTelecom() { // 3 704 ContactPoint t = new ContactPoint(); 705 if (this.telecom == null) 706 this.telecom = new ArrayList<ContactPoint>(); 707 this.telecom.add(t); 708 return t; 709 } 710 711 // syntactic sugar 712 public ImplementationGuideContactComponent addTelecom(ContactPoint t) { // 3 713 if (t == null) 714 return this; 715 if (this.telecom == null) 716 this.telecom = new ArrayList<ContactPoint>(); 717 this.telecom.add(t); 718 return this; 719 } 720 721 protected void listChildren(List<Property> childrenList) { 722 super.listChildren(childrenList); 723 childrenList.add( 724 new Property("name", "string", "The name of an individual to contact regarding the implementation guide.", 0, 725 java.lang.Integer.MAX_VALUE, name)); 726 childrenList.add(new Property("telecom", "ContactPoint", 727 "Contact details for individual (if a name was provided) or the publisher.", 0, java.lang.Integer.MAX_VALUE, 728 telecom)); 729 } 730 731 @Override 732 public void setProperty(String name, Base value) throws FHIRException { 733 if (name.equals("name")) 734 this.name = castToString(value); // StringType 735 else if (name.equals("telecom")) 736 this.getTelecom().add(castToContactPoint(value)); 737 else 738 super.setProperty(name, value); 739 } 740 741 @Override 742 public Base addChild(String name) throws FHIRException { 743 if (name.equals("name")) { 744 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.name"); 745 } else if (name.equals("telecom")) { 746 return addTelecom(); 747 } else 748 return super.addChild(name); 749 } 750 751 public ImplementationGuideContactComponent copy() { 752 ImplementationGuideContactComponent dst = new ImplementationGuideContactComponent(); 753 copyValues(dst); 754 dst.name = name == null ? null : name.copy(); 755 if (telecom != null) { 756 dst.telecom = new ArrayList<ContactPoint>(); 757 for (ContactPoint i : telecom) 758 dst.telecom.add(i.copy()); 759 } 760 ; 761 return dst; 762 } 763 764 @Override 765 public boolean equalsDeep(Base other) { 766 if (!super.equalsDeep(other)) 767 return false; 768 if (!(other instanceof ImplementationGuideContactComponent)) 769 return false; 770 ImplementationGuideContactComponent o = (ImplementationGuideContactComponent) other; 771 return compareDeep(name, o.name, true) && compareDeep(telecom, o.telecom, true); 772 } 773 774 @Override 775 public boolean equalsShallow(Base other) { 776 if (!super.equalsShallow(other)) 777 return false; 778 if (!(other instanceof ImplementationGuideContactComponent)) 779 return false; 780 ImplementationGuideContactComponent o = (ImplementationGuideContactComponent) other; 781 return compareValues(name, o.name, true); 782 } 783 784 public boolean isEmpty() { 785 return super.isEmpty() && (name == null || name.isEmpty()) && (telecom == null || telecom.isEmpty()); 786 } 787 788 public String fhirType() { 789 return "ImplementationGuide.contact"; 790 791 } 792 793 } 794 795 @Block() 796 public static class ImplementationGuideDependencyComponent extends BackboneElement implements IBaseBackboneElement { 797 /** 798 * How the dependency is represented when the guide is published. 799 */ 800 @Child(name = "type", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = false, summary = true) 801 @Description(shortDefinition = "reference | inclusion", formalDefinition = "How the dependency is represented when the guide is published.") 802 protected Enumeration<GuideDependencyType> type; 803 804 /** 805 * Where the dependency is located. 806 */ 807 @Child(name = "uri", type = { UriType.class }, order = 2, min = 1, max = 1, modifier = false, summary = true) 808 @Description(shortDefinition = "Where to find dependency", formalDefinition = "Where the dependency is located.") 809 protected UriType uri; 810 811 private static final long serialVersionUID = 162447098L; 812 813 /* 814 * Constructor 815 */ 816 public ImplementationGuideDependencyComponent() { 817 super(); 818 } 819 820 /* 821 * Constructor 822 */ 823 public ImplementationGuideDependencyComponent(Enumeration<GuideDependencyType> type, UriType uri) { 824 super(); 825 this.type = type; 826 this.uri = uri; 827 } 828 829 /** 830 * @return {@link #type} (How the dependency is represented when the guide is 831 * published.). This is the underlying object with id, value and 832 * extensions. The accessor "getType" gives direct access to the value 833 */ 834 public Enumeration<GuideDependencyType> getTypeElement() { 835 if (this.type == null) 836 if (Configuration.errorOnAutoCreate()) 837 throw new Error("Attempt to auto-create ImplementationGuideDependencyComponent.type"); 838 else if (Configuration.doAutoCreate()) 839 this.type = new Enumeration<GuideDependencyType>(new GuideDependencyTypeEnumFactory()); // bb 840 return this.type; 841 } 842 843 public boolean hasTypeElement() { 844 return this.type != null && !this.type.isEmpty(); 845 } 846 847 public boolean hasType() { 848 return this.type != null && !this.type.isEmpty(); 849 } 850 851 /** 852 * @param value {@link #type} (How the dependency is represented when the guide 853 * is published.). This is the underlying object with id, value and 854 * extensions. The accessor "getType" gives direct access to the 855 * value 856 */ 857 public ImplementationGuideDependencyComponent setTypeElement(Enumeration<GuideDependencyType> value) { 858 this.type = value; 859 return this; 860 } 861 862 /** 863 * @return How the dependency is represented when the guide is published. 864 */ 865 public GuideDependencyType getType() { 866 return this.type == null ? null : this.type.getValue(); 867 } 868 869 /** 870 * @param value How the dependency is represented when the guide is published. 871 */ 872 public ImplementationGuideDependencyComponent setType(GuideDependencyType value) { 873 if (this.type == null) 874 this.type = new Enumeration<GuideDependencyType>(new GuideDependencyTypeEnumFactory()); 875 this.type.setValue(value); 876 return this; 877 } 878 879 /** 880 * @return {@link #uri} (Where the dependency is located.). This is the 881 * underlying object with id, value and extensions. The accessor 882 * "getUri" gives direct access to the value 883 */ 884 public UriType getUriElement() { 885 if (this.uri == null) 886 if (Configuration.errorOnAutoCreate()) 887 throw new Error("Attempt to auto-create ImplementationGuideDependencyComponent.uri"); 888 else if (Configuration.doAutoCreate()) 889 this.uri = new UriType(); // bb 890 return this.uri; 891 } 892 893 public boolean hasUriElement() { 894 return this.uri != null && !this.uri.isEmpty(); 895 } 896 897 public boolean hasUri() { 898 return this.uri != null && !this.uri.isEmpty(); 899 } 900 901 /** 902 * @param value {@link #uri} (Where the dependency is located.). This is the 903 * underlying object with id, value and extensions. The accessor 904 * "getUri" gives direct access to the value 905 */ 906 public ImplementationGuideDependencyComponent setUriElement(UriType value) { 907 this.uri = value; 908 return this; 909 } 910 911 /** 912 * @return Where the dependency is located. 913 */ 914 public String getUri() { 915 return this.uri == null ? null : this.uri.getValue(); 916 } 917 918 /** 919 * @param value Where the dependency is located. 920 */ 921 public ImplementationGuideDependencyComponent setUri(String value) { 922 if (this.uri == null) 923 this.uri = new UriType(); 924 this.uri.setValue(value); 925 return this; 926 } 927 928 protected void listChildren(List<Property> childrenList) { 929 super.listChildren(childrenList); 930 childrenList.add(new Property("type", "code", "How the dependency is represented when the guide is published.", 0, 931 java.lang.Integer.MAX_VALUE, type)); 932 childrenList 933 .add(new Property("uri", "uri", "Where the dependency is located.", 0, java.lang.Integer.MAX_VALUE, uri)); 934 } 935 936 @Override 937 public void setProperty(String name, Base value) throws FHIRException { 938 if (name.equals("type")) 939 this.type = new GuideDependencyTypeEnumFactory().fromType(value); // Enumeration<GuideDependencyType> 940 else if (name.equals("uri")) 941 this.uri = castToUri(value); // UriType 942 else 943 super.setProperty(name, value); 944 } 945 946 @Override 947 public Base addChild(String name) throws FHIRException { 948 if (name.equals("type")) { 949 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.type"); 950 } else if (name.equals("uri")) { 951 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.uri"); 952 } else 953 return super.addChild(name); 954 } 955 956 public ImplementationGuideDependencyComponent copy() { 957 ImplementationGuideDependencyComponent dst = new ImplementationGuideDependencyComponent(); 958 copyValues(dst); 959 dst.type = type == null ? null : type.copy(); 960 dst.uri = uri == null ? null : uri.copy(); 961 return dst; 962 } 963 964 @Override 965 public boolean equalsDeep(Base other) { 966 if (!super.equalsDeep(other)) 967 return false; 968 if (!(other instanceof ImplementationGuideDependencyComponent)) 969 return false; 970 ImplementationGuideDependencyComponent o = (ImplementationGuideDependencyComponent) other; 971 return compareDeep(type, o.type, true) && compareDeep(uri, o.uri, true); 972 } 973 974 @Override 975 public boolean equalsShallow(Base other) { 976 if (!super.equalsShallow(other)) 977 return false; 978 if (!(other instanceof ImplementationGuideDependencyComponent)) 979 return false; 980 ImplementationGuideDependencyComponent o = (ImplementationGuideDependencyComponent) other; 981 return compareValues(type, o.type, true) && compareValues(uri, o.uri, true); 982 } 983 984 public boolean isEmpty() { 985 return super.isEmpty() && (type == null || type.isEmpty()) && (uri == null || uri.isEmpty()); 986 } 987 988 public String fhirType() { 989 return "ImplementationGuide.dependency"; 990 991 } 992 993 } 994 995 @Block() 996 public static class ImplementationGuidePackageComponent extends BackboneElement implements IBaseBackboneElement { 997 /** 998 * The name for the group, as used in page.package. 999 */ 1000 @Child(name = "name", type = { StringType.class }, order = 1, min = 1, max = 1, modifier = false, summary = true) 1001 @Description(shortDefinition = "Name used .page.package", formalDefinition = "The name for the group, as used in page.package.") 1002 protected StringType name; 1003 1004 /** 1005 * Human readable text describing the package. 1006 */ 1007 @Child(name = "description", type = { 1008 StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false) 1009 @Description(shortDefinition = "Human readable text describing the package", formalDefinition = "Human readable text describing the package.") 1010 protected StringType description; 1011 1012 /** 1013 * A resource that is part of the implementation guide. Conformance resources 1014 * (value set, structure definition, conformance statements etc.) are obvious 1015 * candidates for inclusion, but any kind of resource can be included as an 1016 * example resource. 1017 */ 1018 @Child(name = "resource", type = {}, order = 3, min = 1, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 1019 @Description(shortDefinition = "Resource in the implementation guide", formalDefinition = "A resource that is part of the implementation guide. Conformance resources (value set, structure definition, conformance statements etc.) are obvious candidates for inclusion, but any kind of resource can be included as an example resource.") 1020 protected List<ImplementationGuidePackageResourceComponent> resource; 1021 1022 private static final long serialVersionUID = -701846580L; 1023 1024 /* 1025 * Constructor 1026 */ 1027 public ImplementationGuidePackageComponent() { 1028 super(); 1029 } 1030 1031 /* 1032 * Constructor 1033 */ 1034 public ImplementationGuidePackageComponent(StringType name) { 1035 super(); 1036 this.name = name; 1037 } 1038 1039 /** 1040 * @return {@link #name} (The name for the group, as used in page.package.). 1041 * This is the underlying object with id, value and extensions. The 1042 * accessor "getName" gives direct access to the value 1043 */ 1044 public StringType getNameElement() { 1045 if (this.name == null) 1046 if (Configuration.errorOnAutoCreate()) 1047 throw new Error("Attempt to auto-create ImplementationGuidePackageComponent.name"); 1048 else if (Configuration.doAutoCreate()) 1049 this.name = new StringType(); // bb 1050 return this.name; 1051 } 1052 1053 public boolean hasNameElement() { 1054 return this.name != null && !this.name.isEmpty(); 1055 } 1056 1057 public boolean hasName() { 1058 return this.name != null && !this.name.isEmpty(); 1059 } 1060 1061 /** 1062 * @param value {@link #name} (The name for the group, as used in 1063 * page.package.). This is the underlying object with id, value and 1064 * extensions. The accessor "getName" gives direct access to the 1065 * value 1066 */ 1067 public ImplementationGuidePackageComponent setNameElement(StringType value) { 1068 this.name = value; 1069 return this; 1070 } 1071 1072 /** 1073 * @return The name for the group, as used in page.package. 1074 */ 1075 public String getName() { 1076 return this.name == null ? null : this.name.getValue(); 1077 } 1078 1079 /** 1080 * @param value The name for the group, as used in page.package. 1081 */ 1082 public ImplementationGuidePackageComponent setName(String value) { 1083 if (this.name == null) 1084 this.name = new StringType(); 1085 this.name.setValue(value); 1086 return this; 1087 } 1088 1089 /** 1090 * @return {@link #description} (Human readable text describing the package.). 1091 * This is the underlying object with id, value and extensions. The 1092 * accessor "getDescription" gives direct access to the value 1093 */ 1094 public StringType getDescriptionElement() { 1095 if (this.description == null) 1096 if (Configuration.errorOnAutoCreate()) 1097 throw new Error("Attempt to auto-create ImplementationGuidePackageComponent.description"); 1098 else if (Configuration.doAutoCreate()) 1099 this.description = new StringType(); // bb 1100 return this.description; 1101 } 1102 1103 public boolean hasDescriptionElement() { 1104 return this.description != null && !this.description.isEmpty(); 1105 } 1106 1107 public boolean hasDescription() { 1108 return this.description != null && !this.description.isEmpty(); 1109 } 1110 1111 /** 1112 * @param value {@link #description} (Human readable text describing the 1113 * package.). This is the underlying object with id, value and 1114 * extensions. The accessor "getDescription" gives direct access to 1115 * the value 1116 */ 1117 public ImplementationGuidePackageComponent setDescriptionElement(StringType value) { 1118 this.description = value; 1119 return this; 1120 } 1121 1122 /** 1123 * @return Human readable text describing the package. 1124 */ 1125 public String getDescription() { 1126 return this.description == null ? null : this.description.getValue(); 1127 } 1128 1129 /** 1130 * @param value Human readable text describing the package. 1131 */ 1132 public ImplementationGuidePackageComponent setDescription(String value) { 1133 if (Utilities.noString(value)) 1134 this.description = null; 1135 else { 1136 if (this.description == null) 1137 this.description = new StringType(); 1138 this.description.setValue(value); 1139 } 1140 return this; 1141 } 1142 1143 /** 1144 * @return {@link #resource} (A resource that is part of the implementation 1145 * guide. Conformance resources (value set, structure definition, 1146 * conformance statements etc.) are obvious candidates for inclusion, 1147 * but any kind of resource can be included as an example resource.) 1148 */ 1149 public List<ImplementationGuidePackageResourceComponent> getResource() { 1150 if (this.resource == null) 1151 this.resource = new ArrayList<ImplementationGuidePackageResourceComponent>(); 1152 return this.resource; 1153 } 1154 1155 public boolean hasResource() { 1156 if (this.resource == null) 1157 return false; 1158 for (ImplementationGuidePackageResourceComponent item : this.resource) 1159 if (!item.isEmpty()) 1160 return true; 1161 return false; 1162 } 1163 1164 /** 1165 * @return {@link #resource} (A resource that is part of the implementation 1166 * guide. Conformance resources (value set, structure definition, 1167 * conformance statements etc.) are obvious candidates for inclusion, 1168 * but any kind of resource can be included as an example resource.) 1169 */ 1170 // syntactic sugar 1171 public ImplementationGuidePackageResourceComponent addResource() { // 3 1172 ImplementationGuidePackageResourceComponent t = new ImplementationGuidePackageResourceComponent(); 1173 if (this.resource == null) 1174 this.resource = new ArrayList<ImplementationGuidePackageResourceComponent>(); 1175 this.resource.add(t); 1176 return t; 1177 } 1178 1179 // syntactic sugar 1180 public ImplementationGuidePackageComponent addResource(ImplementationGuidePackageResourceComponent t) { // 3 1181 if (t == null) 1182 return this; 1183 if (this.resource == null) 1184 this.resource = new ArrayList<ImplementationGuidePackageResourceComponent>(); 1185 this.resource.add(t); 1186 return this; 1187 } 1188 1189 protected void listChildren(List<Property> childrenList) { 1190 super.listChildren(childrenList); 1191 childrenList.add(new Property("name", "string", "The name for the group, as used in page.package.", 0, 1192 java.lang.Integer.MAX_VALUE, name)); 1193 childrenList.add(new Property("description", "string", "Human readable text describing the package.", 0, 1194 java.lang.Integer.MAX_VALUE, description)); 1195 childrenList.add(new Property("resource", "", 1196 "A resource that is part of the implementation guide. Conformance resources (value set, structure definition, conformance statements etc.) are obvious candidates for inclusion, but any kind of resource can be included as an example resource.", 1197 0, java.lang.Integer.MAX_VALUE, resource)); 1198 } 1199 1200 @Override 1201 public void setProperty(String name, Base value) throws FHIRException { 1202 if (name.equals("name")) 1203 this.name = castToString(value); // StringType 1204 else if (name.equals("description")) 1205 this.description = castToString(value); // StringType 1206 else if (name.equals("resource")) 1207 this.getResource().add((ImplementationGuidePackageResourceComponent) value); 1208 else 1209 super.setProperty(name, value); 1210 } 1211 1212 @Override 1213 public Base addChild(String name) throws FHIRException { 1214 if (name.equals("name")) { 1215 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.name"); 1216 } else if (name.equals("description")) { 1217 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.description"); 1218 } else if (name.equals("resource")) { 1219 return addResource(); 1220 } else 1221 return super.addChild(name); 1222 } 1223 1224 public ImplementationGuidePackageComponent copy() { 1225 ImplementationGuidePackageComponent dst = new ImplementationGuidePackageComponent(); 1226 copyValues(dst); 1227 dst.name = name == null ? null : name.copy(); 1228 dst.description = description == null ? null : description.copy(); 1229 if (resource != null) { 1230 dst.resource = new ArrayList<ImplementationGuidePackageResourceComponent>(); 1231 for (ImplementationGuidePackageResourceComponent i : resource) 1232 dst.resource.add(i.copy()); 1233 } 1234 ; 1235 return dst; 1236 } 1237 1238 @Override 1239 public boolean equalsDeep(Base other) { 1240 if (!super.equalsDeep(other)) 1241 return false; 1242 if (!(other instanceof ImplementationGuidePackageComponent)) 1243 return false; 1244 ImplementationGuidePackageComponent o = (ImplementationGuidePackageComponent) other; 1245 return compareDeep(name, o.name, true) && compareDeep(description, o.description, true) 1246 && compareDeep(resource, o.resource, true); 1247 } 1248 1249 @Override 1250 public boolean equalsShallow(Base other) { 1251 if (!super.equalsShallow(other)) 1252 return false; 1253 if (!(other instanceof ImplementationGuidePackageComponent)) 1254 return false; 1255 ImplementationGuidePackageComponent o = (ImplementationGuidePackageComponent) other; 1256 return compareValues(name, o.name, true) && compareValues(description, o.description, true); 1257 } 1258 1259 public boolean isEmpty() { 1260 return super.isEmpty() && (name == null || name.isEmpty()) && (description == null || description.isEmpty()) 1261 && (resource == null || resource.isEmpty()); 1262 } 1263 1264 public String fhirType() { 1265 return "ImplementationGuide.package"; 1266 1267 } 1268 1269 } 1270 1271 @Block() 1272 public static class ImplementationGuidePackageResourceComponent extends BackboneElement 1273 implements IBaseBackboneElement { 1274 /** 1275 * Why the resource is included in the guide. 1276 */ 1277 @Child(name = "purpose", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = false, summary = true) 1278 @Description(shortDefinition = "example | terminology | profile | extension | dictionary | logical", formalDefinition = "Why the resource is included in the guide.") 1279 protected Enumeration<GuideResourcePurpose> purpose; 1280 1281 /** 1282 * A human assigned name for the resource. All resources SHOULD have a name, but 1283 * the name may be extracted from the resource (e.g. ValueSet.name). 1284 */ 1285 @Child(name = "name", type = { StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = true) 1286 @Description(shortDefinition = "Human Name for the resource", formalDefinition = "A human assigned name for the resource. All resources SHOULD have a name, but the name may be extracted from the resource (e.g. ValueSet.name).") 1287 protected StringType name; 1288 1289 /** 1290 * A description of the reason that a resource has been included in the 1291 * implementation guide. 1292 */ 1293 @Child(name = "description", type = { 1294 StringType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false) 1295 @Description(shortDefinition = "Reason why included in guide", formalDefinition = "A description of the reason that a resource has been included in the implementation guide.") 1296 protected StringType description; 1297 1298 /** 1299 * A short code that may be used to identify the resource throughout the 1300 * implementation guide. 1301 */ 1302 @Child(name = "acronym", type = { 1303 StringType.class }, order = 4, min = 0, max = 1, modifier = false, summary = false) 1304 @Description(shortDefinition = "Short code to identify the resource", formalDefinition = "A short code that may be used to identify the resource throughout the implementation guide.") 1305 protected StringType acronym; 1306 1307 /** 1308 * Where this resource is found. 1309 */ 1310 @Child(name = "source", type = { UriType.class }, order = 5, min = 1, max = 1, modifier = false, summary = true) 1311 @Description(shortDefinition = "Location of the resource", formalDefinition = "Where this resource is found.") 1312 protected Type source; 1313 1314 /** 1315 * Another resource that this resource is an example for. This is mostly used 1316 * for resources that are included as examples of StructureDefinitions. 1317 */ 1318 @Child(name = "exampleFor", type = { 1319 StructureDefinition.class }, order = 6, min = 0, max = 1, modifier = false, summary = false) 1320 @Description(shortDefinition = "Resource this is an example of (if applicable)", formalDefinition = "Another resource that this resource is an example for. This is mostly used for resources that are included as examples of StructureDefinitions.") 1321 protected Reference exampleFor; 1322 1323 /** 1324 * The actual object that is the target of the reference (Another resource that 1325 * this resource is an example for. This is mostly used for resources that are 1326 * included as examples of StructureDefinitions.) 1327 */ 1328 protected StructureDefinition exampleForTarget; 1329 1330 private static final long serialVersionUID = 428339533L; 1331 1332 /* 1333 * Constructor 1334 */ 1335 public ImplementationGuidePackageResourceComponent() { 1336 super(); 1337 } 1338 1339 /* 1340 * Constructor 1341 */ 1342 public ImplementationGuidePackageResourceComponent(Enumeration<GuideResourcePurpose> purpose, Type source) { 1343 super(); 1344 this.purpose = purpose; 1345 this.source = source; 1346 } 1347 1348 /** 1349 * @return {@link #purpose} (Why the resource is included in the guide.). This 1350 * is the underlying object with id, value and extensions. The accessor 1351 * "getPurpose" gives direct access to the value 1352 */ 1353 public Enumeration<GuideResourcePurpose> getPurposeElement() { 1354 if (this.purpose == null) 1355 if (Configuration.errorOnAutoCreate()) 1356 throw new Error("Attempt to auto-create ImplementationGuidePackageResourceComponent.purpose"); 1357 else if (Configuration.doAutoCreate()) 1358 this.purpose = new Enumeration<GuideResourcePurpose>(new GuideResourcePurposeEnumFactory()); // bb 1359 return this.purpose; 1360 } 1361 1362 public boolean hasPurposeElement() { 1363 return this.purpose != null && !this.purpose.isEmpty(); 1364 } 1365 1366 public boolean hasPurpose() { 1367 return this.purpose != null && !this.purpose.isEmpty(); 1368 } 1369 1370 /** 1371 * @param value {@link #purpose} (Why the resource is included in the guide.). 1372 * This is the underlying object with id, value and extensions. The 1373 * accessor "getPurpose" gives direct access to the value 1374 */ 1375 public ImplementationGuidePackageResourceComponent setPurposeElement(Enumeration<GuideResourcePurpose> value) { 1376 this.purpose = value; 1377 return this; 1378 } 1379 1380 /** 1381 * @return Why the resource is included in the guide. 1382 */ 1383 public GuideResourcePurpose getPurpose() { 1384 return this.purpose == null ? null : this.purpose.getValue(); 1385 } 1386 1387 /** 1388 * @param value Why the resource is included in the guide. 1389 */ 1390 public ImplementationGuidePackageResourceComponent setPurpose(GuideResourcePurpose value) { 1391 if (this.purpose == null) 1392 this.purpose = new Enumeration<GuideResourcePurpose>(new GuideResourcePurposeEnumFactory()); 1393 this.purpose.setValue(value); 1394 return this; 1395 } 1396 1397 /** 1398 * @return {@link #name} (A human assigned name for the resource. All resources 1399 * SHOULD have a name, but the name may be extracted from the resource 1400 * (e.g. ValueSet.name).). This is the underlying object with id, value 1401 * and extensions. The accessor "getName" gives direct access to the 1402 * value 1403 */ 1404 public StringType getNameElement() { 1405 if (this.name == null) 1406 if (Configuration.errorOnAutoCreate()) 1407 throw new Error("Attempt to auto-create ImplementationGuidePackageResourceComponent.name"); 1408 else if (Configuration.doAutoCreate()) 1409 this.name = new StringType(); // bb 1410 return this.name; 1411 } 1412 1413 public boolean hasNameElement() { 1414 return this.name != null && !this.name.isEmpty(); 1415 } 1416 1417 public boolean hasName() { 1418 return this.name != null && !this.name.isEmpty(); 1419 } 1420 1421 /** 1422 * @param value {@link #name} (A human assigned name for the resource. All 1423 * resources SHOULD have a name, but the name may be extracted from 1424 * the resource (e.g. ValueSet.name).). This is the underlying 1425 * object with id, value and extensions. The accessor "getName" 1426 * gives direct access to the value 1427 */ 1428 public ImplementationGuidePackageResourceComponent setNameElement(StringType value) { 1429 this.name = value; 1430 return this; 1431 } 1432 1433 /** 1434 * @return A human assigned name for the resource. All resources SHOULD have a 1435 * name, but the name may be extracted from the resource (e.g. 1436 * ValueSet.name). 1437 */ 1438 public String getName() { 1439 return this.name == null ? null : this.name.getValue(); 1440 } 1441 1442 /** 1443 * @param value A human assigned name for the resource. All resources SHOULD 1444 * have a name, but the name may be extracted from the resource 1445 * (e.g. ValueSet.name). 1446 */ 1447 public ImplementationGuidePackageResourceComponent setName(String value) { 1448 if (Utilities.noString(value)) 1449 this.name = null; 1450 else { 1451 if (this.name == null) 1452 this.name = new StringType(); 1453 this.name.setValue(value); 1454 } 1455 return this; 1456 } 1457 1458 /** 1459 * @return {@link #description} (A description of the reason that a resource has 1460 * been included in the implementation guide.). This is the underlying 1461 * object with id, value and extensions. The accessor "getDescription" 1462 * gives direct access to the value 1463 */ 1464 public StringType getDescriptionElement() { 1465 if (this.description == null) 1466 if (Configuration.errorOnAutoCreate()) 1467 throw new Error("Attempt to auto-create ImplementationGuidePackageResourceComponent.description"); 1468 else if (Configuration.doAutoCreate()) 1469 this.description = new StringType(); // bb 1470 return this.description; 1471 } 1472 1473 public boolean hasDescriptionElement() { 1474 return this.description != null && !this.description.isEmpty(); 1475 } 1476 1477 public boolean hasDescription() { 1478 return this.description != null && !this.description.isEmpty(); 1479 } 1480 1481 /** 1482 * @param value {@link #description} (A description of the reason that a 1483 * resource has been included in the implementation guide.). This 1484 * is the underlying object with id, value and extensions. The 1485 * accessor "getDescription" gives direct access to the value 1486 */ 1487 public ImplementationGuidePackageResourceComponent setDescriptionElement(StringType value) { 1488 this.description = value; 1489 return this; 1490 } 1491 1492 /** 1493 * @return A description of the reason that a resource has been included in the 1494 * implementation guide. 1495 */ 1496 public String getDescription() { 1497 return this.description == null ? null : this.description.getValue(); 1498 } 1499 1500 /** 1501 * @param value A description of the reason that a resource has been included in 1502 * the implementation guide. 1503 */ 1504 public ImplementationGuidePackageResourceComponent setDescription(String value) { 1505 if (Utilities.noString(value)) 1506 this.description = null; 1507 else { 1508 if (this.description == null) 1509 this.description = new StringType(); 1510 this.description.setValue(value); 1511 } 1512 return this; 1513 } 1514 1515 /** 1516 * @return {@link #acronym} (A short code that may be used to identify the 1517 * resource throughout the implementation guide.). This is the 1518 * underlying object with id, value and extensions. The accessor 1519 * "getAcronym" gives direct access to the value 1520 */ 1521 public StringType getAcronymElement() { 1522 if (this.acronym == null) 1523 if (Configuration.errorOnAutoCreate()) 1524 throw new Error("Attempt to auto-create ImplementationGuidePackageResourceComponent.acronym"); 1525 else if (Configuration.doAutoCreate()) 1526 this.acronym = new StringType(); // bb 1527 return this.acronym; 1528 } 1529 1530 public boolean hasAcronymElement() { 1531 return this.acronym != null && !this.acronym.isEmpty(); 1532 } 1533 1534 public boolean hasAcronym() { 1535 return this.acronym != null && !this.acronym.isEmpty(); 1536 } 1537 1538 /** 1539 * @param value {@link #acronym} (A short code that may be used to identify the 1540 * resource throughout the implementation guide.). This is the 1541 * underlying object with id, value and extensions. The accessor 1542 * "getAcronym" gives direct access to the value 1543 */ 1544 public ImplementationGuidePackageResourceComponent setAcronymElement(StringType value) { 1545 this.acronym = value; 1546 return this; 1547 } 1548 1549 /** 1550 * @return A short code that may be used to identify the resource throughout the 1551 * implementation guide. 1552 */ 1553 public String getAcronym() { 1554 return this.acronym == null ? null : this.acronym.getValue(); 1555 } 1556 1557 /** 1558 * @param value A short code that may be used to identify the resource 1559 * throughout the implementation guide. 1560 */ 1561 public ImplementationGuidePackageResourceComponent setAcronym(String value) { 1562 if (Utilities.noString(value)) 1563 this.acronym = null; 1564 else { 1565 if (this.acronym == null) 1566 this.acronym = new StringType(); 1567 this.acronym.setValue(value); 1568 } 1569 return this; 1570 } 1571 1572 /** 1573 * @return {@link #source} (Where this resource is found.) 1574 */ 1575 public Type getSource() { 1576 return this.source; 1577 } 1578 1579 /** 1580 * @return {@link #source} (Where this resource is found.) 1581 */ 1582 public UriType getSourceUriType() throws FHIRException { 1583 if (!(this.source instanceof UriType)) 1584 throw new FHIRException("Type mismatch: the type UriType was expected, but " + this.source.getClass().getName() 1585 + " was encountered"); 1586 return (UriType) this.source; 1587 } 1588 1589 public boolean hasSourceUriType() { 1590 return this.source instanceof UriType; 1591 } 1592 1593 /** 1594 * @return {@link #source} (Where this resource is found.) 1595 */ 1596 public Reference getSourceReference() throws FHIRException { 1597 if (!(this.source instanceof Reference)) 1598 throw new FHIRException("Type mismatch: the type Reference was expected, but " 1599 + this.source.getClass().getName() + " was encountered"); 1600 return (Reference) this.source; 1601 } 1602 1603 public boolean hasSourceReference() { 1604 return this.source instanceof Reference; 1605 } 1606 1607 public boolean hasSource() { 1608 return this.source != null && !this.source.isEmpty(); 1609 } 1610 1611 /** 1612 * @param value {@link #source} (Where this resource is found.) 1613 */ 1614 public ImplementationGuidePackageResourceComponent setSource(Type value) { 1615 this.source = value; 1616 return this; 1617 } 1618 1619 /** 1620 * @return {@link #exampleFor} (Another resource that this resource is an 1621 * example for. This is mostly used for resources that are included as 1622 * examples of StructureDefinitions.) 1623 */ 1624 public Reference getExampleFor() { 1625 if (this.exampleFor == null) 1626 if (Configuration.errorOnAutoCreate()) 1627 throw new Error("Attempt to auto-create ImplementationGuidePackageResourceComponent.exampleFor"); 1628 else if (Configuration.doAutoCreate()) 1629 this.exampleFor = new Reference(); // cc 1630 return this.exampleFor; 1631 } 1632 1633 public boolean hasExampleFor() { 1634 return this.exampleFor != null && !this.exampleFor.isEmpty(); 1635 } 1636 1637 /** 1638 * @param value {@link #exampleFor} (Another resource that this resource is an 1639 * example for. This is mostly used for resources that are included 1640 * as examples of StructureDefinitions.) 1641 */ 1642 public ImplementationGuidePackageResourceComponent setExampleFor(Reference value) { 1643 this.exampleFor = value; 1644 return this; 1645 } 1646 1647 /** 1648 * @return {@link #exampleFor} The actual object that is the target of the 1649 * reference. The reference library doesn't populate this, but you can 1650 * use it to hold the resource if you resolve it. (Another resource that 1651 * this resource is an example for. This is mostly used for resources 1652 * that are included as examples of StructureDefinitions.) 1653 */ 1654 public StructureDefinition getExampleForTarget() { 1655 if (this.exampleForTarget == null) 1656 if (Configuration.errorOnAutoCreate()) 1657 throw new Error("Attempt to auto-create ImplementationGuidePackageResourceComponent.exampleFor"); 1658 else if (Configuration.doAutoCreate()) 1659 this.exampleForTarget = new StructureDefinition(); // aa 1660 return this.exampleForTarget; 1661 } 1662 1663 /** 1664 * @param value {@link #exampleFor} The actual object that is the target of the 1665 * reference. The reference library doesn't use these, but you can 1666 * use it to hold the resource if you resolve it. (Another resource 1667 * that this resource is an example for. This is mostly used for 1668 * resources that are included as examples of 1669 * StructureDefinitions.) 1670 */ 1671 public ImplementationGuidePackageResourceComponent setExampleForTarget(StructureDefinition value) { 1672 this.exampleForTarget = value; 1673 return this; 1674 } 1675 1676 protected void listChildren(List<Property> childrenList) { 1677 super.listChildren(childrenList); 1678 childrenList.add(new Property("purpose", "code", "Why the resource is included in the guide.", 0, 1679 java.lang.Integer.MAX_VALUE, purpose)); 1680 childrenList.add(new Property("name", "string", 1681 "A human assigned name for the resource. All resources SHOULD have a name, but the name may be extracted from the resource (e.g. ValueSet.name).", 1682 0, java.lang.Integer.MAX_VALUE, name)); 1683 childrenList.add(new Property("description", "string", 1684 "A description of the reason that a resource has been included in the implementation guide.", 0, 1685 java.lang.Integer.MAX_VALUE, description)); 1686 childrenList.add(new Property("acronym", "string", 1687 "A short code that may be used to identify the resource throughout the implementation guide.", 0, 1688 java.lang.Integer.MAX_VALUE, acronym)); 1689 childrenList.add(new Property("source[x]", "uri|Reference(Any)", "Where this resource is found.", 0, 1690 java.lang.Integer.MAX_VALUE, source)); 1691 childrenList.add(new Property("exampleFor", "Reference(StructureDefinition)", 1692 "Another resource that this resource is an example for. This is mostly used for resources that are included as examples of StructureDefinitions.", 1693 0, java.lang.Integer.MAX_VALUE, exampleFor)); 1694 } 1695 1696 @Override 1697 public void setProperty(String name, Base value) throws FHIRException { 1698 if (name.equals("purpose")) 1699 this.purpose = new GuideResourcePurposeEnumFactory().fromType(value); // Enumeration<GuideResourcePurpose> 1700 else if (name.equals("name")) 1701 this.name = castToString(value); // StringType 1702 else if (name.equals("description")) 1703 this.description = castToString(value); // StringType 1704 else if (name.equals("acronym")) 1705 this.acronym = castToString(value); // StringType 1706 else if (name.equals("source[x]")) 1707 this.source = (Type) value; // Type 1708 else if (name.equals("exampleFor")) 1709 this.exampleFor = castToReference(value); // Reference 1710 else 1711 super.setProperty(name, value); 1712 } 1713 1714 @Override 1715 public Base addChild(String name) throws FHIRException { 1716 if (name.equals("purpose")) { 1717 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.purpose"); 1718 } else if (name.equals("name")) { 1719 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.name"); 1720 } else if (name.equals("description")) { 1721 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.description"); 1722 } else if (name.equals("acronym")) { 1723 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.acronym"); 1724 } else if (name.equals("sourceUri")) { 1725 this.source = new UriType(); 1726 return this.source; 1727 } else if (name.equals("sourceReference")) { 1728 this.source = new Reference(); 1729 return this.source; 1730 } else if (name.equals("exampleFor")) { 1731 this.exampleFor = new Reference(); 1732 return this.exampleFor; 1733 } else 1734 return super.addChild(name); 1735 } 1736 1737 public ImplementationGuidePackageResourceComponent copy() { 1738 ImplementationGuidePackageResourceComponent dst = new ImplementationGuidePackageResourceComponent(); 1739 copyValues(dst); 1740 dst.purpose = purpose == null ? null : purpose.copy(); 1741 dst.name = name == null ? null : name.copy(); 1742 dst.description = description == null ? null : description.copy(); 1743 dst.acronym = acronym == null ? null : acronym.copy(); 1744 dst.source = source == null ? null : source.copy(); 1745 dst.exampleFor = exampleFor == null ? null : exampleFor.copy(); 1746 return dst; 1747 } 1748 1749 @Override 1750 public boolean equalsDeep(Base other) { 1751 if (!super.equalsDeep(other)) 1752 return false; 1753 if (!(other instanceof ImplementationGuidePackageResourceComponent)) 1754 return false; 1755 ImplementationGuidePackageResourceComponent o = (ImplementationGuidePackageResourceComponent) other; 1756 return compareDeep(purpose, o.purpose, true) && compareDeep(name, o.name, true) 1757 && compareDeep(description, o.description, true) && compareDeep(acronym, o.acronym, true) 1758 && compareDeep(source, o.source, true) && compareDeep(exampleFor, o.exampleFor, true); 1759 } 1760 1761 @Override 1762 public boolean equalsShallow(Base other) { 1763 if (!super.equalsShallow(other)) 1764 return false; 1765 if (!(other instanceof ImplementationGuidePackageResourceComponent)) 1766 return false; 1767 ImplementationGuidePackageResourceComponent o = (ImplementationGuidePackageResourceComponent) other; 1768 return compareValues(purpose, o.purpose, true) && compareValues(name, o.name, true) 1769 && compareValues(description, o.description, true) && compareValues(acronym, o.acronym, true); 1770 } 1771 1772 public boolean isEmpty() { 1773 return super.isEmpty() && (purpose == null || purpose.isEmpty()) && (name == null || name.isEmpty()) 1774 && (description == null || description.isEmpty()) && (acronym == null || acronym.isEmpty()) 1775 && (source == null || source.isEmpty()) && (exampleFor == null || exampleFor.isEmpty()); 1776 } 1777 1778 public String fhirType() { 1779 return "ImplementationGuide.package.resource"; 1780 1781 } 1782 1783 } 1784 1785 @Block() 1786 public static class ImplementationGuideGlobalComponent extends BackboneElement implements IBaseBackboneElement { 1787 /** 1788 * The type of resource that all instances must conform to. 1789 */ 1790 @Child(name = "type", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = false, summary = true) 1791 @Description(shortDefinition = "Type this profiles applies to", formalDefinition = "The type of resource that all instances must conform to.") 1792 protected CodeType type; 1793 1794 /** 1795 * A reference to the profile that all instances must conform to. 1796 */ 1797 @Child(name = "profile", type = { 1798 StructureDefinition.class }, order = 2, min = 1, max = 1, modifier = false, summary = true) 1799 @Description(shortDefinition = "Profile that all resources must conform to", formalDefinition = "A reference to the profile that all instances must conform to.") 1800 protected Reference profile; 1801 1802 /** 1803 * The actual object that is the target of the reference (A reference to the 1804 * profile that all instances must conform to.) 1805 */ 1806 protected StructureDefinition profileTarget; 1807 1808 private static final long serialVersionUID = 2011731959L; 1809 1810 /* 1811 * Constructor 1812 */ 1813 public ImplementationGuideGlobalComponent() { 1814 super(); 1815 } 1816 1817 /* 1818 * Constructor 1819 */ 1820 public ImplementationGuideGlobalComponent(CodeType type, Reference profile) { 1821 super(); 1822 this.type = type; 1823 this.profile = profile; 1824 } 1825 1826 /** 1827 * @return {@link #type} (The type of resource that all instances must conform 1828 * to.). This is the underlying object with id, value and extensions. 1829 * The accessor "getType" gives direct access to the value 1830 */ 1831 public CodeType getTypeElement() { 1832 if (this.type == null) 1833 if (Configuration.errorOnAutoCreate()) 1834 throw new Error("Attempt to auto-create ImplementationGuideGlobalComponent.type"); 1835 else if (Configuration.doAutoCreate()) 1836 this.type = new CodeType(); // bb 1837 return this.type; 1838 } 1839 1840 public boolean hasTypeElement() { 1841 return this.type != null && !this.type.isEmpty(); 1842 } 1843 1844 public boolean hasType() { 1845 return this.type != null && !this.type.isEmpty(); 1846 } 1847 1848 /** 1849 * @param value {@link #type} (The type of resource that all instances must 1850 * conform to.). This is the underlying object with id, value and 1851 * extensions. The accessor "getType" gives direct access to the 1852 * value 1853 */ 1854 public ImplementationGuideGlobalComponent setTypeElement(CodeType value) { 1855 this.type = value; 1856 return this; 1857 } 1858 1859 /** 1860 * @return The type of resource that all instances must conform to. 1861 */ 1862 public String getType() { 1863 return this.type == null ? null : this.type.getValue(); 1864 } 1865 1866 /** 1867 * @param value The type of resource that all instances must conform to. 1868 */ 1869 public ImplementationGuideGlobalComponent setType(String value) { 1870 if (this.type == null) 1871 this.type = new CodeType(); 1872 this.type.setValue(value); 1873 return this; 1874 } 1875 1876 /** 1877 * @return {@link #profile} (A reference to the profile that all instances must 1878 * conform to.) 1879 */ 1880 public Reference getProfile() { 1881 if (this.profile == null) 1882 if (Configuration.errorOnAutoCreate()) 1883 throw new Error("Attempt to auto-create ImplementationGuideGlobalComponent.profile"); 1884 else if (Configuration.doAutoCreate()) 1885 this.profile = new Reference(); // cc 1886 return this.profile; 1887 } 1888 1889 public boolean hasProfile() { 1890 return this.profile != null && !this.profile.isEmpty(); 1891 } 1892 1893 /** 1894 * @param value {@link #profile} (A reference to the profile that all instances 1895 * must conform to.) 1896 */ 1897 public ImplementationGuideGlobalComponent setProfile(Reference value) { 1898 this.profile = value; 1899 return this; 1900 } 1901 1902 /** 1903 * @return {@link #profile} The actual object that is the target of the 1904 * reference. The reference library doesn't populate this, but you can 1905 * use it to hold the resource if you resolve it. (A reference to the 1906 * profile that all instances must conform to.) 1907 */ 1908 public StructureDefinition getProfileTarget() { 1909 if (this.profileTarget == null) 1910 if (Configuration.errorOnAutoCreate()) 1911 throw new Error("Attempt to auto-create ImplementationGuideGlobalComponent.profile"); 1912 else if (Configuration.doAutoCreate()) 1913 this.profileTarget = new StructureDefinition(); // aa 1914 return this.profileTarget; 1915 } 1916 1917 /** 1918 * @param value {@link #profile} The actual object that is the target of the 1919 * reference. The reference library doesn't use these, but you can 1920 * use it to hold the resource if you resolve it. (A reference to 1921 * the profile that all instances must conform to.) 1922 */ 1923 public ImplementationGuideGlobalComponent setProfileTarget(StructureDefinition value) { 1924 this.profileTarget = value; 1925 return this; 1926 } 1927 1928 protected void listChildren(List<Property> childrenList) { 1929 super.listChildren(childrenList); 1930 childrenList.add(new Property("type", "code", "The type of resource that all instances must conform to.", 0, 1931 java.lang.Integer.MAX_VALUE, type)); 1932 childrenList.add(new Property("profile", "Reference(StructureDefinition)", 1933 "A reference to the profile that all instances must conform to.", 0, java.lang.Integer.MAX_VALUE, profile)); 1934 } 1935 1936 @Override 1937 public void setProperty(String name, Base value) throws FHIRException { 1938 if (name.equals("type")) 1939 this.type = castToCode(value); // CodeType 1940 else if (name.equals("profile")) 1941 this.profile = castToReference(value); // Reference 1942 else 1943 super.setProperty(name, value); 1944 } 1945 1946 @Override 1947 public Base addChild(String name) throws FHIRException { 1948 if (name.equals("type")) { 1949 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.type"); 1950 } else if (name.equals("profile")) { 1951 this.profile = new Reference(); 1952 return this.profile; 1953 } else 1954 return super.addChild(name); 1955 } 1956 1957 public ImplementationGuideGlobalComponent copy() { 1958 ImplementationGuideGlobalComponent dst = new ImplementationGuideGlobalComponent(); 1959 copyValues(dst); 1960 dst.type = type == null ? null : type.copy(); 1961 dst.profile = profile == null ? null : profile.copy(); 1962 return dst; 1963 } 1964 1965 @Override 1966 public boolean equalsDeep(Base other) { 1967 if (!super.equalsDeep(other)) 1968 return false; 1969 if (!(other instanceof ImplementationGuideGlobalComponent)) 1970 return false; 1971 ImplementationGuideGlobalComponent o = (ImplementationGuideGlobalComponent) other; 1972 return compareDeep(type, o.type, true) && compareDeep(profile, o.profile, true); 1973 } 1974 1975 @Override 1976 public boolean equalsShallow(Base other) { 1977 if (!super.equalsShallow(other)) 1978 return false; 1979 if (!(other instanceof ImplementationGuideGlobalComponent)) 1980 return false; 1981 ImplementationGuideGlobalComponent o = (ImplementationGuideGlobalComponent) other; 1982 return compareValues(type, o.type, true); 1983 } 1984 1985 public boolean isEmpty() { 1986 return super.isEmpty() && (type == null || type.isEmpty()) && (profile == null || profile.isEmpty()); 1987 } 1988 1989 public String fhirType() { 1990 return "ImplementationGuide.global"; 1991 1992 } 1993 1994 } 1995 1996 @Block() 1997 public static class ImplementationGuidePageComponent extends BackboneElement implements IBaseBackboneElement { 1998 /** 1999 * The source address for the page. 2000 */ 2001 @Child(name = "source", type = { UriType.class }, order = 1, min = 1, max = 1, modifier = false, summary = true) 2002 @Description(shortDefinition = "Where to find that page", formalDefinition = "The source address for the page.") 2003 protected UriType source; 2004 2005 /** 2006 * A short name used to represent this page in navigational structures such as 2007 * table of contents, bread crumbs, etc. 2008 */ 2009 @Child(name = "name", type = { StringType.class }, order = 2, min = 1, max = 1, modifier = false, summary = true) 2010 @Description(shortDefinition = "Short name shown for navigational assistance", formalDefinition = "A short name used to represent this page in navigational structures such as table of contents, bread crumbs, etc.") 2011 protected StringType name; 2012 2013 /** 2014 * The kind of page that this is. Some pages are autogenerated (list, example), 2015 * and other kinds are of interest so that tools can navigate the user to the 2016 * page of interest. 2017 */ 2018 @Child(name = "kind", type = { CodeType.class }, order = 3, min = 1, max = 1, modifier = false, summary = true) 2019 @Description(shortDefinition = "page | example | list | include | directory | dictionary | toc | resource", formalDefinition = "The kind of page that this is. Some pages are autogenerated (list, example), and other kinds are of interest so that tools can navigate the user to the page of interest.") 2020 protected Enumeration<GuidePageKind> kind; 2021 2022 /** 2023 * For constructed pages, what kind of resources to include in the list. 2024 */ 2025 @Child(name = "type", type = { 2026 CodeType.class }, order = 4, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2027 @Description(shortDefinition = "Kind of resource to include in the list", formalDefinition = "For constructed pages, what kind of resources to include in the list.") 2028 protected List<CodeType> type; 2029 2030 /** 2031 * For constructed pages, a list of packages to include in the page (or else 2032 * empty for everything). 2033 */ 2034 @Child(name = "package", type = { 2035 StringType.class }, order = 5, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2036 @Description(shortDefinition = "Name of package to include", formalDefinition = "For constructed pages, a list of packages to include in the page (or else empty for everything).") 2037 protected List<StringType> package_; 2038 2039 /** 2040 * The format of the page. 2041 */ 2042 @Child(name = "format", type = { CodeType.class }, order = 6, min = 0, max = 1, modifier = false, summary = false) 2043 @Description(shortDefinition = "Format of the page (e.g. html, markdown, etc.)", formalDefinition = "The format of the page.") 2044 protected CodeType format; 2045 2046 /** 2047 * Nested Pages/Sections under this page. 2048 */ 2049 @Child(name = "page", type = { 2050 ImplementationGuidePageComponent.class }, order = 7, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2051 @Description(shortDefinition = "Nested Pages / Sections", formalDefinition = "Nested Pages/Sections under this page.") 2052 protected List<ImplementationGuidePageComponent> page; 2053 2054 private static final long serialVersionUID = -1620890043L; 2055 2056 /* 2057 * Constructor 2058 */ 2059 public ImplementationGuidePageComponent() { 2060 super(); 2061 } 2062 2063 /* 2064 * Constructor 2065 */ 2066 public ImplementationGuidePageComponent(UriType source, StringType name, Enumeration<GuidePageKind> kind) { 2067 super(); 2068 this.source = source; 2069 this.name = name; 2070 this.kind = kind; 2071 } 2072 2073 /** 2074 * @return {@link #source} (The source address for the page.). This is the 2075 * underlying object with id, value and extensions. The accessor 2076 * "getSource" gives direct access to the value 2077 */ 2078 public UriType getSourceElement() { 2079 if (this.source == null) 2080 if (Configuration.errorOnAutoCreate()) 2081 throw new Error("Attempt to auto-create ImplementationGuidePageComponent.source"); 2082 else if (Configuration.doAutoCreate()) 2083 this.source = new UriType(); // bb 2084 return this.source; 2085 } 2086 2087 public boolean hasSourceElement() { 2088 return this.source != null && !this.source.isEmpty(); 2089 } 2090 2091 public boolean hasSource() { 2092 return this.source != null && !this.source.isEmpty(); 2093 } 2094 2095 /** 2096 * @param value {@link #source} (The source address for the page.). This is the 2097 * underlying object with id, value and extensions. The accessor 2098 * "getSource" gives direct access to the value 2099 */ 2100 public ImplementationGuidePageComponent setSourceElement(UriType value) { 2101 this.source = value; 2102 return this; 2103 } 2104 2105 /** 2106 * @return The source address for the page. 2107 */ 2108 public String getSource() { 2109 return this.source == null ? null : this.source.getValue(); 2110 } 2111 2112 /** 2113 * @param value The source address for the page. 2114 */ 2115 public ImplementationGuidePageComponent setSource(String value) { 2116 if (this.source == null) 2117 this.source = new UriType(); 2118 this.source.setValue(value); 2119 return this; 2120 } 2121 2122 /** 2123 * @return {@link #name} (A short name used to represent this page in 2124 * navigational structures such as table of contents, bread crumbs, 2125 * etc.). This is the underlying object with id, value and extensions. 2126 * The accessor "getName" gives direct access to the value 2127 */ 2128 public StringType getNameElement() { 2129 if (this.name == null) 2130 if (Configuration.errorOnAutoCreate()) 2131 throw new Error("Attempt to auto-create ImplementationGuidePageComponent.name"); 2132 else if (Configuration.doAutoCreate()) 2133 this.name = new StringType(); // bb 2134 return this.name; 2135 } 2136 2137 public boolean hasNameElement() { 2138 return this.name != null && !this.name.isEmpty(); 2139 } 2140 2141 public boolean hasName() { 2142 return this.name != null && !this.name.isEmpty(); 2143 } 2144 2145 /** 2146 * @param value {@link #name} (A short name used to represent this page in 2147 * navigational structures such as table of contents, bread crumbs, 2148 * etc.). This is the underlying object with id, value and 2149 * extensions. The accessor "getName" gives direct access to the 2150 * value 2151 */ 2152 public ImplementationGuidePageComponent setNameElement(StringType value) { 2153 this.name = value; 2154 return this; 2155 } 2156 2157 /** 2158 * @return A short name used to represent this page in navigational structures 2159 * such as table of contents, bread crumbs, etc. 2160 */ 2161 public String getName() { 2162 return this.name == null ? null : this.name.getValue(); 2163 } 2164 2165 /** 2166 * @param value A short name used to represent this page in navigational 2167 * structures such as table of contents, bread crumbs, etc. 2168 */ 2169 public ImplementationGuidePageComponent setName(String value) { 2170 if (this.name == null) 2171 this.name = new StringType(); 2172 this.name.setValue(value); 2173 return this; 2174 } 2175 2176 /** 2177 * @return {@link #kind} (The kind of page that this is. Some pages are 2178 * autogenerated (list, example), and other kinds are of interest so 2179 * that tools can navigate the user to the page of interest.). This is 2180 * the underlying object with id, value and extensions. The accessor 2181 * "getKind" gives direct access to the value 2182 */ 2183 public Enumeration<GuidePageKind> getKindElement() { 2184 if (this.kind == null) 2185 if (Configuration.errorOnAutoCreate()) 2186 throw new Error("Attempt to auto-create ImplementationGuidePageComponent.kind"); 2187 else if (Configuration.doAutoCreate()) 2188 this.kind = new Enumeration<GuidePageKind>(new GuidePageKindEnumFactory()); // bb 2189 return this.kind; 2190 } 2191 2192 public boolean hasKindElement() { 2193 return this.kind != null && !this.kind.isEmpty(); 2194 } 2195 2196 public boolean hasKind() { 2197 return this.kind != null && !this.kind.isEmpty(); 2198 } 2199 2200 /** 2201 * @param value {@link #kind} (The kind of page that this is. Some pages are 2202 * autogenerated (list, example), and other kinds are of interest 2203 * so that tools can navigate the user to the page of interest.). 2204 * This is the underlying object with id, value and extensions. The 2205 * accessor "getKind" gives direct access to the value 2206 */ 2207 public ImplementationGuidePageComponent setKindElement(Enumeration<GuidePageKind> value) { 2208 this.kind = value; 2209 return this; 2210 } 2211 2212 /** 2213 * @return The kind of page that this is. Some pages are autogenerated (list, 2214 * example), and other kinds are of interest so that tools can navigate 2215 * the user to the page of interest. 2216 */ 2217 public GuidePageKind getKind() { 2218 return this.kind == null ? null : this.kind.getValue(); 2219 } 2220 2221 /** 2222 * @param value The kind of page that this is. Some pages are autogenerated 2223 * (list, example), and other kinds are of interest so that tools 2224 * can navigate the user to the page of interest. 2225 */ 2226 public ImplementationGuidePageComponent setKind(GuidePageKind value) { 2227 if (this.kind == null) 2228 this.kind = new Enumeration<GuidePageKind>(new GuidePageKindEnumFactory()); 2229 this.kind.setValue(value); 2230 return this; 2231 } 2232 2233 /** 2234 * @return {@link #type} (For constructed pages, what kind of resources to 2235 * include in the list.) 2236 */ 2237 public List<CodeType> getType() { 2238 if (this.type == null) 2239 this.type = new ArrayList<CodeType>(); 2240 return this.type; 2241 } 2242 2243 public boolean hasType() { 2244 if (this.type == null) 2245 return false; 2246 for (CodeType item : this.type) 2247 if (!item.isEmpty()) 2248 return true; 2249 return false; 2250 } 2251 2252 /** 2253 * @return {@link #type} (For constructed pages, what kind of resources to 2254 * include in the list.) 2255 */ 2256 // syntactic sugar 2257 public CodeType addTypeElement() {// 2 2258 CodeType t = new CodeType(); 2259 if (this.type == null) 2260 this.type = new ArrayList<CodeType>(); 2261 this.type.add(t); 2262 return t; 2263 } 2264 2265 /** 2266 * @param value {@link #type} (For constructed pages, what kind of resources to 2267 * include in the list.) 2268 */ 2269 public ImplementationGuidePageComponent addType(String value) { // 1 2270 CodeType t = new CodeType(); 2271 t.setValue(value); 2272 if (this.type == null) 2273 this.type = new ArrayList<CodeType>(); 2274 this.type.add(t); 2275 return this; 2276 } 2277 2278 /** 2279 * @param value {@link #type} (For constructed pages, what kind of resources to 2280 * include in the list.) 2281 */ 2282 public boolean hasType(String value) { 2283 if (this.type == null) 2284 return false; 2285 for (CodeType v : this.type) 2286 if (v.equals(value)) // code 2287 return true; 2288 return false; 2289 } 2290 2291 /** 2292 * @return {@link #package_} (For constructed pages, a list of packages to 2293 * include in the page (or else empty for everything).) 2294 */ 2295 public List<StringType> getPackage() { 2296 if (this.package_ == null) 2297 this.package_ = new ArrayList<StringType>(); 2298 return this.package_; 2299 } 2300 2301 public boolean hasPackage() { 2302 if (this.package_ == null) 2303 return false; 2304 for (StringType item : this.package_) 2305 if (!item.isEmpty()) 2306 return true; 2307 return false; 2308 } 2309 2310 /** 2311 * @return {@link #package_} (For constructed pages, a list of packages to 2312 * include in the page (or else empty for everything).) 2313 */ 2314 // syntactic sugar 2315 public StringType addPackageElement() {// 2 2316 StringType t = new StringType(); 2317 if (this.package_ == null) 2318 this.package_ = new ArrayList<StringType>(); 2319 this.package_.add(t); 2320 return t; 2321 } 2322 2323 /** 2324 * @param value {@link #package_} (For constructed pages, a list of packages to 2325 * include in the page (or else empty for everything).) 2326 */ 2327 public ImplementationGuidePageComponent addPackage(String value) { // 1 2328 StringType t = new StringType(); 2329 t.setValue(value); 2330 if (this.package_ == null) 2331 this.package_ = new ArrayList<StringType>(); 2332 this.package_.add(t); 2333 return this; 2334 } 2335 2336 /** 2337 * @param value {@link #package_} (For constructed pages, a list of packages to 2338 * include in the page (or else empty for everything).) 2339 */ 2340 public boolean hasPackage(String value) { 2341 if (this.package_ == null) 2342 return false; 2343 for (StringType v : this.package_) 2344 if (v.equals(value)) // string 2345 return true; 2346 return false; 2347 } 2348 2349 /** 2350 * @return {@link #format} (The format of the page.). This is the underlying 2351 * object with id, value and extensions. The accessor "getFormat" gives 2352 * direct access to the value 2353 */ 2354 public CodeType getFormatElement() { 2355 if (this.format == null) 2356 if (Configuration.errorOnAutoCreate()) 2357 throw new Error("Attempt to auto-create ImplementationGuidePageComponent.format"); 2358 else if (Configuration.doAutoCreate()) 2359 this.format = new CodeType(); // bb 2360 return this.format; 2361 } 2362 2363 public boolean hasFormatElement() { 2364 return this.format != null && !this.format.isEmpty(); 2365 } 2366 2367 public boolean hasFormat() { 2368 return this.format != null && !this.format.isEmpty(); 2369 } 2370 2371 /** 2372 * @param value {@link #format} (The format of the page.). This is the 2373 * underlying object with id, value and extensions. The accessor 2374 * "getFormat" gives direct access to the value 2375 */ 2376 public ImplementationGuidePageComponent setFormatElement(CodeType value) { 2377 this.format = value; 2378 return this; 2379 } 2380 2381 /** 2382 * @return The format of the page. 2383 */ 2384 public String getFormat() { 2385 return this.format == null ? null : this.format.getValue(); 2386 } 2387 2388 /** 2389 * @param value The format of the page. 2390 */ 2391 public ImplementationGuidePageComponent setFormat(String value) { 2392 if (Utilities.noString(value)) 2393 this.format = null; 2394 else { 2395 if (this.format == null) 2396 this.format = new CodeType(); 2397 this.format.setValue(value); 2398 } 2399 return this; 2400 } 2401 2402 /** 2403 * @return {@link #page} (Nested Pages/Sections under this page.) 2404 */ 2405 public List<ImplementationGuidePageComponent> getPage() { 2406 if (this.page == null) 2407 this.page = new ArrayList<ImplementationGuidePageComponent>(); 2408 return this.page; 2409 } 2410 2411 public boolean hasPage() { 2412 if (this.page == null) 2413 return false; 2414 for (ImplementationGuidePageComponent item : this.page) 2415 if (!item.isEmpty()) 2416 return true; 2417 return false; 2418 } 2419 2420 /** 2421 * @return {@link #page} (Nested Pages/Sections under this page.) 2422 */ 2423 // syntactic sugar 2424 public ImplementationGuidePageComponent addPage() { // 3 2425 ImplementationGuidePageComponent t = new ImplementationGuidePageComponent(); 2426 if (this.page == null) 2427 this.page = new ArrayList<ImplementationGuidePageComponent>(); 2428 this.page.add(t); 2429 return t; 2430 } 2431 2432 // syntactic sugar 2433 public ImplementationGuidePageComponent addPage(ImplementationGuidePageComponent t) { // 3 2434 if (t == null) 2435 return this; 2436 if (this.page == null) 2437 this.page = new ArrayList<ImplementationGuidePageComponent>(); 2438 this.page.add(t); 2439 return this; 2440 } 2441 2442 protected void listChildren(List<Property> childrenList) { 2443 super.listChildren(childrenList); 2444 childrenList.add( 2445 new Property("source", "uri", "The source address for the page.", 0, java.lang.Integer.MAX_VALUE, source)); 2446 childrenList.add(new Property("name", "string", 2447 "A short name used to represent this page in navigational structures such as table of contents, bread crumbs, etc.", 2448 0, java.lang.Integer.MAX_VALUE, name)); 2449 childrenList.add(new Property("kind", "code", 2450 "The kind of page that this is. Some pages are autogenerated (list, example), and other kinds are of interest so that tools can navigate the user to the page of interest.", 2451 0, java.lang.Integer.MAX_VALUE, kind)); 2452 childrenList 2453 .add(new Property("type", "code", "For constructed pages, what kind of resources to include in the list.", 0, 2454 java.lang.Integer.MAX_VALUE, type)); 2455 childrenList.add(new Property("package", "string", 2456 "For constructed pages, a list of packages to include in the page (or else empty for everything).", 0, 2457 java.lang.Integer.MAX_VALUE, package_)); 2458 childrenList 2459 .add(new Property("format", "code", "The format of the page.", 0, java.lang.Integer.MAX_VALUE, format)); 2460 childrenList.add(new Property("page", "@ImplementationGuide.page", "Nested Pages/Sections under this page.", 0, 2461 java.lang.Integer.MAX_VALUE, page)); 2462 } 2463 2464 @Override 2465 public void setProperty(String name, Base value) throws FHIRException { 2466 if (name.equals("source")) 2467 this.source = castToUri(value); // UriType 2468 else if (name.equals("name")) 2469 this.name = castToString(value); // StringType 2470 else if (name.equals("kind")) 2471 this.kind = new GuidePageKindEnumFactory().fromType(value); // Enumeration<GuidePageKind> 2472 else if (name.equals("type")) 2473 this.getType().add(castToCode(value)); 2474 else if (name.equals("package")) 2475 this.getPackage().add(castToString(value)); 2476 else if (name.equals("format")) 2477 this.format = castToCode(value); // CodeType 2478 else if (name.equals("page")) 2479 this.getPage().add((ImplementationGuidePageComponent) value); 2480 else 2481 super.setProperty(name, value); 2482 } 2483 2484 @Override 2485 public Base addChild(String name) throws FHIRException { 2486 if (name.equals("source")) { 2487 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.source"); 2488 } else if (name.equals("name")) { 2489 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.name"); 2490 } else if (name.equals("kind")) { 2491 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.kind"); 2492 } else if (name.equals("type")) { 2493 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.type"); 2494 } else if (name.equals("package")) { 2495 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.package"); 2496 } else if (name.equals("format")) { 2497 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.format"); 2498 } else if (name.equals("page")) { 2499 return addPage(); 2500 } else 2501 return super.addChild(name); 2502 } 2503 2504 public ImplementationGuidePageComponent copy() { 2505 ImplementationGuidePageComponent dst = new ImplementationGuidePageComponent(); 2506 copyValues(dst); 2507 dst.source = source == null ? null : source.copy(); 2508 dst.name = name == null ? null : name.copy(); 2509 dst.kind = kind == null ? null : kind.copy(); 2510 if (type != null) { 2511 dst.type = new ArrayList<CodeType>(); 2512 for (CodeType i : type) 2513 dst.type.add(i.copy()); 2514 } 2515 ; 2516 if (package_ != null) { 2517 dst.package_ = new ArrayList<StringType>(); 2518 for (StringType i : package_) 2519 dst.package_.add(i.copy()); 2520 } 2521 ; 2522 dst.format = format == null ? null : format.copy(); 2523 if (page != null) { 2524 dst.page = new ArrayList<ImplementationGuidePageComponent>(); 2525 for (ImplementationGuidePageComponent i : page) 2526 dst.page.add(i.copy()); 2527 } 2528 ; 2529 return dst; 2530 } 2531 2532 @Override 2533 public boolean equalsDeep(Base other) { 2534 if (!super.equalsDeep(other)) 2535 return false; 2536 if (!(other instanceof ImplementationGuidePageComponent)) 2537 return false; 2538 ImplementationGuidePageComponent o = (ImplementationGuidePageComponent) other; 2539 return compareDeep(source, o.source, true) && compareDeep(name, o.name, true) && compareDeep(kind, o.kind, true) 2540 && compareDeep(type, o.type, true) && compareDeep(package_, o.package_, true) 2541 && compareDeep(format, o.format, true) && compareDeep(page, o.page, true); 2542 } 2543 2544 @Override 2545 public boolean equalsShallow(Base other) { 2546 if (!super.equalsShallow(other)) 2547 return false; 2548 if (!(other instanceof ImplementationGuidePageComponent)) 2549 return false; 2550 ImplementationGuidePageComponent o = (ImplementationGuidePageComponent) other; 2551 return compareValues(source, o.source, true) && compareValues(name, o.name, true) 2552 && compareValues(kind, o.kind, true) && compareValues(type, o.type, true) 2553 && compareValues(package_, o.package_, true) && compareValues(format, o.format, true); 2554 } 2555 2556 public boolean isEmpty() { 2557 return super.isEmpty() && (source == null || source.isEmpty()) && (name == null || name.isEmpty()) 2558 && (kind == null || kind.isEmpty()) && (type == null || type.isEmpty()) 2559 && (package_ == null || package_.isEmpty()) && (format == null || format.isEmpty()) 2560 && (page == null || page.isEmpty()); 2561 } 2562 2563 public String fhirType() { 2564 return "ImplementationGuide.page"; 2565 2566 } 2567 2568 } 2569 2570 /** 2571 * An absolute URL that is used to identify this implementation guide when it is 2572 * referenced in a specification, model, design or an instance. This SHALL be a 2573 * URL, SHOULD be globally unique, and SHOULD be an address at which this 2574 * implementation guide is (or will be) published. 2575 */ 2576 @Child(name = "url", type = { UriType.class }, order = 0, min = 1, max = 1, modifier = false, summary = true) 2577 @Description(shortDefinition = "Absolute URL used to reference this Implementation Guide", formalDefinition = "An absolute URL that is used to identify this implementation guide when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this implementation guide is (or will be) published.") 2578 protected UriType url; 2579 2580 /** 2581 * The identifier that is used to identify this version of the Implementation 2582 * Guide when it is referenced in a specification, model, design or instance. 2583 * This is an arbitrary value managed by the Implementation Guide author 2584 * manually. 2585 */ 2586 @Child(name = "version", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = true) 2587 @Description(shortDefinition = "Logical id for this version of the Implementation Guide", formalDefinition = "The identifier that is used to identify this version of the Implementation Guide when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the Implementation Guide author manually.") 2588 protected StringType version; 2589 2590 /** 2591 * A free text natural language name identifying the Implementation Guide. 2592 */ 2593 @Child(name = "name", type = { StringType.class }, order = 2, min = 1, max = 1, modifier = false, summary = true) 2594 @Description(shortDefinition = "Informal name for this Implementation Guide", formalDefinition = "A free text natural language name identifying the Implementation Guide.") 2595 protected StringType name; 2596 2597 /** 2598 * The status of the Implementation Guide. 2599 */ 2600 @Child(name = "status", type = { CodeType.class }, order = 3, min = 1, max = 1, modifier = true, summary = true) 2601 @Description(shortDefinition = "draft | active | retired", formalDefinition = "The status of the Implementation Guide.") 2602 protected Enumeration<ConformanceResourceStatus> status; 2603 2604 /** 2605 * This Implementation Guide was authored for testing purposes (or 2606 * education/evaluation/marketing), and is not intended to be used for genuine 2607 * usage. 2608 */ 2609 @Child(name = "experimental", type = { 2610 BooleanType.class }, order = 4, min = 0, max = 1, modifier = false, summary = true) 2611 @Description(shortDefinition = "If for testing purposes, not real usage", formalDefinition = "This Implementation Guide was authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.") 2612 protected BooleanType experimental; 2613 2614 /** 2615 * The name of the individual or organization that published the implementation 2616 * guide. 2617 */ 2618 @Child(name = "publisher", type = { StringType.class }, order = 5, min = 0, max = 1, modifier = false, summary = true) 2619 @Description(shortDefinition = "Name of the publisher (Organization or individual)", formalDefinition = "The name of the individual or organization that published the implementation guide.") 2620 protected StringType publisher; 2621 2622 /** 2623 * Contacts to assist a user in finding and communicating with the publisher. 2624 */ 2625 @Child(name = "contact", type = {}, order = 6, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 2626 @Description(shortDefinition = "Contact details of the publisher", formalDefinition = "Contacts to assist a user in finding and communicating with the publisher.") 2627 protected List<ImplementationGuideContactComponent> contact; 2628 2629 /** 2630 * The date this version of the implementation guide was published. The date 2631 * must change when the business version changes, if it does, and it must change 2632 * if the status code changes. In addition, it should change when the 2633 * substantive content of the implementation guide changes. 2634 */ 2635 @Child(name = "date", type = { DateTimeType.class }, order = 7, min = 0, max = 1, modifier = false, summary = true) 2636 @Description(shortDefinition = "Date for this version of the Implementation Guide", formalDefinition = "The date this version of the implementation guide was published. The date must change when the business version changes, if it does, and it must change if the status code changes. In addition, it should change when the substantive content of the implementation guide changes.") 2637 protected DateTimeType date; 2638 2639 /** 2640 * A free text natural language description of the Implementation Guide and its 2641 * use. 2642 */ 2643 @Child(name = "description", type = { 2644 StringType.class }, order = 8, min = 0, max = 1, modifier = false, summary = true) 2645 @Description(shortDefinition = "Natural language description of the Implementation Guide", formalDefinition = "A free text natural language description of the Implementation Guide and its use.") 2646 protected StringType description; 2647 2648 /** 2649 * The content was developed with a focus and intent of supporting the contexts 2650 * that are listed. These terms may be used to assist with indexing and 2651 * searching of implementation guides. The most common use of this element is to 2652 * represent the country / jurisdiction for which this implementation guide was 2653 * defined. 2654 */ 2655 @Child(name = "useContext", type = { 2656 CodeableConcept.class }, order = 9, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 2657 @Description(shortDefinition = "The implementation guide is intended to support these contexts", formalDefinition = "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching of implementation guides. The most common use of this element is to represent the country / jurisdiction for which this implementation guide was defined.") 2658 protected List<CodeableConcept> useContext; 2659 2660 /** 2661 * A copyright statement relating to the implementation guide and/or its 2662 * contents. Copyright statements are generally legal restrictions on the use 2663 * and publishing of the details of the constraints and mappings. 2664 */ 2665 @Child(name = "copyright", type = { 2666 StringType.class }, order = 10, min = 0, max = 1, modifier = false, summary = false) 2667 @Description(shortDefinition = "Use and/or publishing restrictions", formalDefinition = "A copyright statement relating to the implementation guide and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the details of the constraints and mappings.") 2668 protected StringType copyright; 2669 2670 /** 2671 * The version of the FHIR specification on which this ImplementationGuide is 2672 * based - this is the formal version of the specification, without the revision 2673 * number, e.g. [publication].[major].[minor], which is 1.0.2 for this version. 2674 */ 2675 @Child(name = "fhirVersion", type = { IdType.class }, order = 11, min = 0, max = 1, modifier = false, summary = true) 2676 @Description(shortDefinition = "FHIR Version this Implementation Guide targets", formalDefinition = "The version of the FHIR specification on which this ImplementationGuide is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 1.0.2 for this version.") 2677 protected IdType fhirVersion; 2678 2679 /** 2680 * Another implementation guide that this implementation depends on. Typically, 2681 * an implementation guide uses value sets, profiles etc.defined in other 2682 * implementation guides. 2683 */ 2684 @Child(name = "dependency", type = {}, order = 12, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 2685 @Description(shortDefinition = "Another Implementation guide this depends on", formalDefinition = "Another implementation guide that this implementation depends on. Typically, an implementation guide uses value sets, profiles etc.defined in other implementation guides.") 2686 protected List<ImplementationGuideDependencyComponent> dependency; 2687 2688 /** 2689 * A logical group of resources. Logical groups can be used when building pages. 2690 */ 2691 @Child(name = "package", type = {}, order = 13, min = 1, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 2692 @Description(shortDefinition = "Group of resources as used in .page.package", formalDefinition = "A logical group of resources. Logical groups can be used when building pages.") 2693 protected List<ImplementationGuidePackageComponent> package_; 2694 2695 /** 2696 * A set of profiles that all resources covered by this implementation guide 2697 * must conform to. 2698 */ 2699 @Child(name = "global", type = {}, order = 14, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = true) 2700 @Description(shortDefinition = "Profiles that apply globally", formalDefinition = "A set of profiles that all resources covered by this implementation guide must conform to.") 2701 protected List<ImplementationGuideGlobalComponent> global; 2702 2703 /** 2704 * A binary file that is included in the implementation guide when it is 2705 * published. 2706 */ 2707 @Child(name = "binary", type = { 2708 UriType.class }, order = 15, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false) 2709 @Description(shortDefinition = "Image, css, script, etc.", formalDefinition = "A binary file that is included in the implementation guide when it is published.") 2710 protected List<UriType> binary; 2711 2712 /** 2713 * A page / section in the implementation guide. The root page is the 2714 * implementation guide home page. 2715 */ 2716 @Child(name = "page", type = {}, order = 16, min = 1, max = 1, modifier = false, summary = true) 2717 @Description(shortDefinition = "Page/Section in the Guide", formalDefinition = "A page / section in the implementation guide. The root page is the implementation guide home page.") 2718 protected ImplementationGuidePageComponent page; 2719 2720 private static final long serialVersionUID = 1150122415L; 2721 2722 /* 2723 * Constructor 2724 */ 2725 public ImplementationGuide() { 2726 super(); 2727 } 2728 2729 /* 2730 * Constructor 2731 */ 2732 public ImplementationGuide(UriType url, StringType name, Enumeration<ConformanceResourceStatus> status, 2733 ImplementationGuidePageComponent page) { 2734 super(); 2735 this.url = url; 2736 this.name = name; 2737 this.status = status; 2738 this.page = page; 2739 } 2740 2741 /** 2742 * @return {@link #url} (An absolute URL that is used to identify this 2743 * implementation guide when it is referenced in a specification, model, 2744 * design or an instance. This SHALL be a URL, SHOULD be globally 2745 * unique, and SHOULD be an address at which this implementation guide 2746 * is (or will be) published.). This is the underlying object with id, 2747 * value and extensions. The accessor "getUrl" gives direct access to 2748 * the value 2749 */ 2750 public UriType getUrlElement() { 2751 if (this.url == null) 2752 if (Configuration.errorOnAutoCreate()) 2753 throw new Error("Attempt to auto-create ImplementationGuide.url"); 2754 else if (Configuration.doAutoCreate()) 2755 this.url = new UriType(); // bb 2756 return this.url; 2757 } 2758 2759 public boolean hasUrlElement() { 2760 return this.url != null && !this.url.isEmpty(); 2761 } 2762 2763 public boolean hasUrl() { 2764 return this.url != null && !this.url.isEmpty(); 2765 } 2766 2767 /** 2768 * @param value {@link #url} (An absolute URL that is used to identify this 2769 * implementation guide when it is referenced in a specification, 2770 * model, design or an instance. This SHALL be a URL, SHOULD be 2771 * globally unique, and SHOULD be an address at which this 2772 * implementation guide is (or will be) published.). This is the 2773 * underlying object with id, value and extensions. The accessor 2774 * "getUrl" gives direct access to the value 2775 */ 2776 public ImplementationGuide setUrlElement(UriType value) { 2777 this.url = value; 2778 return this; 2779 } 2780 2781 /** 2782 * @return An absolute URL that is used to identify this implementation guide 2783 * when it is referenced in a specification, model, design or an 2784 * instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD 2785 * be an address at which this implementation guide is (or will be) 2786 * published. 2787 */ 2788 public String getUrl() { 2789 return this.url == null ? null : this.url.getValue(); 2790 } 2791 2792 /** 2793 * @param value An absolute URL that is used to identify this implementation 2794 * guide when it is referenced in a specification, model, design or 2795 * an instance. This SHALL be a URL, SHOULD be globally unique, and 2796 * SHOULD be an address at which this implementation guide is (or 2797 * will be) published. 2798 */ 2799 public ImplementationGuide setUrl(String value) { 2800 if (this.url == null) 2801 this.url = new UriType(); 2802 this.url.setValue(value); 2803 return this; 2804 } 2805 2806 /** 2807 * @return {@link #version} (The identifier that is used to identify this 2808 * version of the Implementation Guide when it is referenced in a 2809 * specification, model, design or instance. This is an arbitrary value 2810 * managed by the Implementation Guide author manually.). This is the 2811 * underlying object with id, value and extensions. The accessor 2812 * "getVersion" gives direct access to the value 2813 */ 2814 public StringType getVersionElement() { 2815 if (this.version == null) 2816 if (Configuration.errorOnAutoCreate()) 2817 throw new Error("Attempt to auto-create ImplementationGuide.version"); 2818 else if (Configuration.doAutoCreate()) 2819 this.version = new StringType(); // bb 2820 return this.version; 2821 } 2822 2823 public boolean hasVersionElement() { 2824 return this.version != null && !this.version.isEmpty(); 2825 } 2826 2827 public boolean hasVersion() { 2828 return this.version != null && !this.version.isEmpty(); 2829 } 2830 2831 /** 2832 * @param value {@link #version} (The identifier that is used to identify this 2833 * version of the Implementation Guide when it is referenced in a 2834 * specification, model, design or instance. This is an arbitrary 2835 * value managed by the Implementation Guide author manually.). 2836 * This is the underlying object with id, value and extensions. The 2837 * accessor "getVersion" gives direct access to the value 2838 */ 2839 public ImplementationGuide setVersionElement(StringType value) { 2840 this.version = value; 2841 return this; 2842 } 2843 2844 /** 2845 * @return The identifier that is used to identify this version of the 2846 * Implementation Guide when it is referenced in a specification, model, 2847 * design or instance. This is an arbitrary value managed by the 2848 * Implementation Guide author manually. 2849 */ 2850 public String getVersion() { 2851 return this.version == null ? null : this.version.getValue(); 2852 } 2853 2854 /** 2855 * @param value The identifier that is used to identify this version of the 2856 * Implementation Guide when it is referenced in a specification, 2857 * model, design or instance. This is an arbitrary value managed by 2858 * the Implementation Guide author manually. 2859 */ 2860 public ImplementationGuide setVersion(String value) { 2861 if (Utilities.noString(value)) 2862 this.version = null; 2863 else { 2864 if (this.version == null) 2865 this.version = new StringType(); 2866 this.version.setValue(value); 2867 } 2868 return this; 2869 } 2870 2871 /** 2872 * @return {@link #name} (A free text natural language name identifying the 2873 * Implementation Guide.). This is the underlying object with id, value 2874 * and extensions. The accessor "getName" gives direct access to the 2875 * value 2876 */ 2877 public StringType getNameElement() { 2878 if (this.name == null) 2879 if (Configuration.errorOnAutoCreate()) 2880 throw new Error("Attempt to auto-create ImplementationGuide.name"); 2881 else if (Configuration.doAutoCreate()) 2882 this.name = new StringType(); // bb 2883 return this.name; 2884 } 2885 2886 public boolean hasNameElement() { 2887 return this.name != null && !this.name.isEmpty(); 2888 } 2889 2890 public boolean hasName() { 2891 return this.name != null && !this.name.isEmpty(); 2892 } 2893 2894 /** 2895 * @param value {@link #name} (A free text natural language name identifying the 2896 * Implementation Guide.). This is the underlying object with id, 2897 * value and extensions. The accessor "getName" gives direct access 2898 * to the value 2899 */ 2900 public ImplementationGuide setNameElement(StringType value) { 2901 this.name = value; 2902 return this; 2903 } 2904 2905 /** 2906 * @return A free text natural language name identifying the Implementation 2907 * Guide. 2908 */ 2909 public String getName() { 2910 return this.name == null ? null : this.name.getValue(); 2911 } 2912 2913 /** 2914 * @param value A free text natural language name identifying the Implementation 2915 * Guide. 2916 */ 2917 public ImplementationGuide setName(String value) { 2918 if (this.name == null) 2919 this.name = new StringType(); 2920 this.name.setValue(value); 2921 return this; 2922 } 2923 2924 /** 2925 * @return {@link #status} (The status of the Implementation Guide.). This is 2926 * the underlying object with id, value and extensions. The accessor 2927 * "getStatus" gives direct access to the value 2928 */ 2929 public Enumeration<ConformanceResourceStatus> getStatusElement() { 2930 if (this.status == null) 2931 if (Configuration.errorOnAutoCreate()) 2932 throw new Error("Attempt to auto-create ImplementationGuide.status"); 2933 else if (Configuration.doAutoCreate()) 2934 this.status = new Enumeration<ConformanceResourceStatus>(new ConformanceResourceStatusEnumFactory()); // bb 2935 return this.status; 2936 } 2937 2938 public boolean hasStatusElement() { 2939 return this.status != null && !this.status.isEmpty(); 2940 } 2941 2942 public boolean hasStatus() { 2943 return this.status != null && !this.status.isEmpty(); 2944 } 2945 2946 /** 2947 * @param value {@link #status} (The status of the Implementation Guide.). This 2948 * is the underlying object with id, value and extensions. The 2949 * accessor "getStatus" gives direct access to the value 2950 */ 2951 public ImplementationGuide setStatusElement(Enumeration<ConformanceResourceStatus> value) { 2952 this.status = value; 2953 return this; 2954 } 2955 2956 /** 2957 * @return The status of the Implementation Guide. 2958 */ 2959 public ConformanceResourceStatus getStatus() { 2960 return this.status == null ? null : this.status.getValue(); 2961 } 2962 2963 /** 2964 * @param value The status of the Implementation Guide. 2965 */ 2966 public ImplementationGuide setStatus(ConformanceResourceStatus value) { 2967 if (this.status == null) 2968 this.status = new Enumeration<ConformanceResourceStatus>(new ConformanceResourceStatusEnumFactory()); 2969 this.status.setValue(value); 2970 return this; 2971 } 2972 2973 /** 2974 * @return {@link #experimental} (This Implementation Guide was authored for 2975 * testing purposes (or education/evaluation/marketing), and is not 2976 * intended to be used for genuine usage.). This is the underlying 2977 * object with id, value and extensions. The accessor "getExperimental" 2978 * gives direct access to the value 2979 */ 2980 public BooleanType getExperimentalElement() { 2981 if (this.experimental == null) 2982 if (Configuration.errorOnAutoCreate()) 2983 throw new Error("Attempt to auto-create ImplementationGuide.experimental"); 2984 else if (Configuration.doAutoCreate()) 2985 this.experimental = new BooleanType(); // bb 2986 return this.experimental; 2987 } 2988 2989 public boolean hasExperimentalElement() { 2990 return this.experimental != null && !this.experimental.isEmpty(); 2991 } 2992 2993 public boolean hasExperimental() { 2994 return this.experimental != null && !this.experimental.isEmpty(); 2995 } 2996 2997 /** 2998 * @param value {@link #experimental} (This Implementation Guide was authored 2999 * for testing purposes (or education/evaluation/marketing), and is 3000 * not intended to be used for genuine usage.). This is the 3001 * underlying object with id, value and extensions. The accessor 3002 * "getExperimental" gives direct access to the value 3003 */ 3004 public ImplementationGuide setExperimentalElement(BooleanType value) { 3005 this.experimental = value; 3006 return this; 3007 } 3008 3009 /** 3010 * @return This Implementation Guide was authored for testing purposes (or 3011 * education/evaluation/marketing), and is not intended to be used for 3012 * genuine usage. 3013 */ 3014 public boolean getExperimental() { 3015 return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue(); 3016 } 3017 3018 /** 3019 * @param value This Implementation Guide was authored for testing purposes (or 3020 * education/evaluation/marketing), and is not intended to be used 3021 * for genuine usage. 3022 */ 3023 public ImplementationGuide setExperimental(boolean value) { 3024 if (this.experimental == null) 3025 this.experimental = new BooleanType(); 3026 this.experimental.setValue(value); 3027 return this; 3028 } 3029 3030 /** 3031 * @return {@link #publisher} (The name of the individual or organization that 3032 * published the implementation guide.). This is the underlying object 3033 * with id, value and extensions. The accessor "getPublisher" gives 3034 * direct access to the value 3035 */ 3036 public StringType getPublisherElement() { 3037 if (this.publisher == null) 3038 if (Configuration.errorOnAutoCreate()) 3039 throw new Error("Attempt to auto-create ImplementationGuide.publisher"); 3040 else if (Configuration.doAutoCreate()) 3041 this.publisher = new StringType(); // bb 3042 return this.publisher; 3043 } 3044 3045 public boolean hasPublisherElement() { 3046 return this.publisher != null && !this.publisher.isEmpty(); 3047 } 3048 3049 public boolean hasPublisher() { 3050 return this.publisher != null && !this.publisher.isEmpty(); 3051 } 3052 3053 /** 3054 * @param value {@link #publisher} (The name of the individual or organization 3055 * that published the implementation guide.). This is the 3056 * underlying object with id, value and extensions. The accessor 3057 * "getPublisher" gives direct access to the value 3058 */ 3059 public ImplementationGuide setPublisherElement(StringType value) { 3060 this.publisher = value; 3061 return this; 3062 } 3063 3064 /** 3065 * @return The name of the individual or organization that published the 3066 * implementation guide. 3067 */ 3068 public String getPublisher() { 3069 return this.publisher == null ? null : this.publisher.getValue(); 3070 } 3071 3072 /** 3073 * @param value The name of the individual or organization that published the 3074 * implementation guide. 3075 */ 3076 public ImplementationGuide setPublisher(String value) { 3077 if (Utilities.noString(value)) 3078 this.publisher = null; 3079 else { 3080 if (this.publisher == null) 3081 this.publisher = new StringType(); 3082 this.publisher.setValue(value); 3083 } 3084 return this; 3085 } 3086 3087 /** 3088 * @return {@link #contact} (Contacts to assist a user in finding and 3089 * communicating with the publisher.) 3090 */ 3091 public List<ImplementationGuideContactComponent> getContact() { 3092 if (this.contact == null) 3093 this.contact = new ArrayList<ImplementationGuideContactComponent>(); 3094 return this.contact; 3095 } 3096 3097 public boolean hasContact() { 3098 if (this.contact == null) 3099 return false; 3100 for (ImplementationGuideContactComponent item : this.contact) 3101 if (!item.isEmpty()) 3102 return true; 3103 return false; 3104 } 3105 3106 /** 3107 * @return {@link #contact} (Contacts to assist a user in finding and 3108 * communicating with the publisher.) 3109 */ 3110 // syntactic sugar 3111 public ImplementationGuideContactComponent addContact() { // 3 3112 ImplementationGuideContactComponent t = new ImplementationGuideContactComponent(); 3113 if (this.contact == null) 3114 this.contact = new ArrayList<ImplementationGuideContactComponent>(); 3115 this.contact.add(t); 3116 return t; 3117 } 3118 3119 // syntactic sugar 3120 public ImplementationGuide addContact(ImplementationGuideContactComponent t) { // 3 3121 if (t == null) 3122 return this; 3123 if (this.contact == null) 3124 this.contact = new ArrayList<ImplementationGuideContactComponent>(); 3125 this.contact.add(t); 3126 return this; 3127 } 3128 3129 /** 3130 * @return {@link #date} (The date this version of the implementation guide was 3131 * published. The date must change when the business version changes, if 3132 * it does, and it must change if the status code changes. In addition, 3133 * it should change when the substantive content of the implementation 3134 * guide changes.). This is the underlying object with id, value and 3135 * extensions. The accessor "getDate" gives direct access to the value 3136 */ 3137 public DateTimeType getDateElement() { 3138 if (this.date == null) 3139 if (Configuration.errorOnAutoCreate()) 3140 throw new Error("Attempt to auto-create ImplementationGuide.date"); 3141 else if (Configuration.doAutoCreate()) 3142 this.date = new DateTimeType(); // bb 3143 return this.date; 3144 } 3145 3146 public boolean hasDateElement() { 3147 return this.date != null && !this.date.isEmpty(); 3148 } 3149 3150 public boolean hasDate() { 3151 return this.date != null && !this.date.isEmpty(); 3152 } 3153 3154 /** 3155 * @param value {@link #date} (The date this version of the implementation guide 3156 * was published. The date must change when the business version 3157 * changes, if it does, and it must change if the status code 3158 * changes. In addition, it should change when the substantive 3159 * content of the implementation guide changes.). This is the 3160 * underlying object with id, value and extensions. The accessor 3161 * "getDate" gives direct access to the value 3162 */ 3163 public ImplementationGuide setDateElement(DateTimeType value) { 3164 this.date = value; 3165 return this; 3166 } 3167 3168 /** 3169 * @return The date this version of the implementation guide was published. The 3170 * date must change when the business version changes, if it does, and 3171 * it must change if the status code changes. In addition, it should 3172 * change when the substantive content of the implementation guide 3173 * changes. 3174 */ 3175 public Date getDate() { 3176 return this.date == null ? null : this.date.getValue(); 3177 } 3178 3179 /** 3180 * @param value The date this version of the implementation guide was published. 3181 * The date must change when the business version changes, if it 3182 * does, and it must change if the status code changes. In 3183 * addition, it should change when the substantive content of the 3184 * implementation guide changes. 3185 */ 3186 public ImplementationGuide setDate(Date value) { 3187 if (value == null) 3188 this.date = null; 3189 else { 3190 if (this.date == null) 3191 this.date = new DateTimeType(); 3192 this.date.setValue(value); 3193 } 3194 return this; 3195 } 3196 3197 /** 3198 * @return {@link #description} (A free text natural language description of the 3199 * Implementation Guide and its use.). This is the underlying object 3200 * with id, value and extensions. The accessor "getDescription" gives 3201 * direct access to the value 3202 */ 3203 public StringType getDescriptionElement() { 3204 if (this.description == null) 3205 if (Configuration.errorOnAutoCreate()) 3206 throw new Error("Attempt to auto-create ImplementationGuide.description"); 3207 else if (Configuration.doAutoCreate()) 3208 this.description = new StringType(); // bb 3209 return this.description; 3210 } 3211 3212 public boolean hasDescriptionElement() { 3213 return this.description != null && !this.description.isEmpty(); 3214 } 3215 3216 public boolean hasDescription() { 3217 return this.description != null && !this.description.isEmpty(); 3218 } 3219 3220 /** 3221 * @param value {@link #description} (A free text natural language description 3222 * of the Implementation Guide and its use.). This is the 3223 * underlying object with id, value and extensions. The accessor 3224 * "getDescription" gives direct access to the value 3225 */ 3226 public ImplementationGuide setDescriptionElement(StringType value) { 3227 this.description = value; 3228 return this; 3229 } 3230 3231 /** 3232 * @return A free text natural language description of the Implementation Guide 3233 * and its use. 3234 */ 3235 public String getDescription() { 3236 return this.description == null ? null : this.description.getValue(); 3237 } 3238 3239 /** 3240 * @param value A free text natural language description of the Implementation 3241 * Guide and its use. 3242 */ 3243 public ImplementationGuide setDescription(String value) { 3244 if (Utilities.noString(value)) 3245 this.description = null; 3246 else { 3247 if (this.description == null) 3248 this.description = new StringType(); 3249 this.description.setValue(value); 3250 } 3251 return this; 3252 } 3253 3254 /** 3255 * @return {@link #useContext} (The content was developed with a focus and 3256 * intent of supporting the contexts that are listed. These terms may be 3257 * used to assist with indexing and searching of implementation guides. 3258 * The most common use of this element is to represent the country / 3259 * jurisdiction for which this implementation guide was defined.) 3260 */ 3261 public List<CodeableConcept> getUseContext() { 3262 if (this.useContext == null) 3263 this.useContext = new ArrayList<CodeableConcept>(); 3264 return this.useContext; 3265 } 3266 3267 public boolean hasUseContext() { 3268 if (this.useContext == null) 3269 return false; 3270 for (CodeableConcept item : this.useContext) 3271 if (!item.isEmpty()) 3272 return true; 3273 return false; 3274 } 3275 3276 /** 3277 * @return {@link #useContext} (The content was developed with a focus and 3278 * intent of supporting the contexts that are listed. These terms may be 3279 * used to assist with indexing and searching of implementation guides. 3280 * The most common use of this element is to represent the country / 3281 * jurisdiction for which this implementation guide was defined.) 3282 */ 3283 // syntactic sugar 3284 public CodeableConcept addUseContext() { // 3 3285 CodeableConcept t = new CodeableConcept(); 3286 if (this.useContext == null) 3287 this.useContext = new ArrayList<CodeableConcept>(); 3288 this.useContext.add(t); 3289 return t; 3290 } 3291 3292 // syntactic sugar 3293 public ImplementationGuide addUseContext(CodeableConcept t) { // 3 3294 if (t == null) 3295 return this; 3296 if (this.useContext == null) 3297 this.useContext = new ArrayList<CodeableConcept>(); 3298 this.useContext.add(t); 3299 return this; 3300 } 3301 3302 /** 3303 * @return {@link #copyright} (A copyright statement relating to the 3304 * implementation guide and/or its contents. Copyright statements are 3305 * generally legal restrictions on the use and publishing of the details 3306 * of the constraints and mappings.). This is the underlying object with 3307 * id, value and extensions. The accessor "getCopyright" gives direct 3308 * access to the value 3309 */ 3310 public StringType getCopyrightElement() { 3311 if (this.copyright == null) 3312 if (Configuration.errorOnAutoCreate()) 3313 throw new Error("Attempt to auto-create ImplementationGuide.copyright"); 3314 else if (Configuration.doAutoCreate()) 3315 this.copyright = new StringType(); // bb 3316 return this.copyright; 3317 } 3318 3319 public boolean hasCopyrightElement() { 3320 return this.copyright != null && !this.copyright.isEmpty(); 3321 } 3322 3323 public boolean hasCopyright() { 3324 return this.copyright != null && !this.copyright.isEmpty(); 3325 } 3326 3327 /** 3328 * @param value {@link #copyright} (A copyright statement relating to the 3329 * implementation guide and/or its contents. Copyright statements 3330 * are generally legal restrictions on the use and publishing of 3331 * the details of the constraints and mappings.). This is the 3332 * underlying object with id, value and extensions. The accessor 3333 * "getCopyright" gives direct access to the value 3334 */ 3335 public ImplementationGuide setCopyrightElement(StringType value) { 3336 this.copyright = value; 3337 return this; 3338 } 3339 3340 /** 3341 * @return A copyright statement relating to the implementation guide and/or its 3342 * contents. Copyright statements are generally legal restrictions on 3343 * the use and publishing of the details of the constraints and 3344 * mappings. 3345 */ 3346 public String getCopyright() { 3347 return this.copyright == null ? null : this.copyright.getValue(); 3348 } 3349 3350 /** 3351 * @param value A copyright statement relating to the implementation guide 3352 * and/or its contents. Copyright statements are generally legal 3353 * restrictions on the use and publishing of the details of the 3354 * constraints and mappings. 3355 */ 3356 public ImplementationGuide setCopyright(String value) { 3357 if (Utilities.noString(value)) 3358 this.copyright = null; 3359 else { 3360 if (this.copyright == null) 3361 this.copyright = new StringType(); 3362 this.copyright.setValue(value); 3363 } 3364 return this; 3365 } 3366 3367 /** 3368 * @return {@link #fhirVersion} (The version of the FHIR specification on which 3369 * this ImplementationGuide is based - this is the formal version of the 3370 * specification, without the revision number, e.g. 3371 * [publication].[major].[minor], which is 1.0.2 for this version.). 3372 * This is the underlying object with id, value and extensions. The 3373 * accessor "getFhirVersion" gives direct access to the value 3374 */ 3375 public IdType getFhirVersionElement() { 3376 if (this.fhirVersion == null) 3377 if (Configuration.errorOnAutoCreate()) 3378 throw new Error("Attempt to auto-create ImplementationGuide.fhirVersion"); 3379 else if (Configuration.doAutoCreate()) 3380 this.fhirVersion = new IdType(); // bb 3381 return this.fhirVersion; 3382 } 3383 3384 public boolean hasFhirVersionElement() { 3385 return this.fhirVersion != null && !this.fhirVersion.isEmpty(); 3386 } 3387 3388 public boolean hasFhirVersion() { 3389 return this.fhirVersion != null && !this.fhirVersion.isEmpty(); 3390 } 3391 3392 /** 3393 * @param value {@link #fhirVersion} (The version of the FHIR specification on 3394 * which this ImplementationGuide is based - this is the formal 3395 * version of the specification, without the revision number, e.g. 3396 * [publication].[major].[minor], which is 1.0.2 for this 3397 * version.). This is the underlying object with id, value and 3398 * extensions. The accessor "getFhirVersion" gives direct access to 3399 * the value 3400 */ 3401 public ImplementationGuide setFhirVersionElement(IdType value) { 3402 this.fhirVersion = value; 3403 return this; 3404 } 3405 3406 /** 3407 * @return The version of the FHIR specification on which this 3408 * ImplementationGuide is based - this is the formal version of the 3409 * specification, without the revision number, e.g. 3410 * [publication].[major].[minor], which is 1.0.2 for this version. 3411 */ 3412 public String getFhirVersion() { 3413 return this.fhirVersion == null ? null : this.fhirVersion.getValue(); 3414 } 3415 3416 /** 3417 * @param value The version of the FHIR specification on which this 3418 * ImplementationGuide is based - this is the formal version of the 3419 * specification, without the revision number, e.g. 3420 * [publication].[major].[minor], which is 1.0.2 for this version. 3421 */ 3422 public ImplementationGuide setFhirVersion(String value) { 3423 if (Utilities.noString(value)) 3424 this.fhirVersion = null; 3425 else { 3426 if (this.fhirVersion == null) 3427 this.fhirVersion = new IdType(); 3428 this.fhirVersion.setValue(value); 3429 } 3430 return this; 3431 } 3432 3433 /** 3434 * @return {@link #dependency} (Another implementation guide that this 3435 * implementation depends on. Typically, an implementation guide uses 3436 * value sets, profiles etc.defined in other implementation guides.) 3437 */ 3438 public List<ImplementationGuideDependencyComponent> getDependency() { 3439 if (this.dependency == null) 3440 this.dependency = new ArrayList<ImplementationGuideDependencyComponent>(); 3441 return this.dependency; 3442 } 3443 3444 public boolean hasDependency() { 3445 if (this.dependency == null) 3446 return false; 3447 for (ImplementationGuideDependencyComponent item : this.dependency) 3448 if (!item.isEmpty()) 3449 return true; 3450 return false; 3451 } 3452 3453 /** 3454 * @return {@link #dependency} (Another implementation guide that this 3455 * implementation depends on. Typically, an implementation guide uses 3456 * value sets, profiles etc.defined in other implementation guides.) 3457 */ 3458 // syntactic sugar 3459 public ImplementationGuideDependencyComponent addDependency() { // 3 3460 ImplementationGuideDependencyComponent t = new ImplementationGuideDependencyComponent(); 3461 if (this.dependency == null) 3462 this.dependency = new ArrayList<ImplementationGuideDependencyComponent>(); 3463 this.dependency.add(t); 3464 return t; 3465 } 3466 3467 // syntactic sugar 3468 public ImplementationGuide addDependency(ImplementationGuideDependencyComponent t) { // 3 3469 if (t == null) 3470 return this; 3471 if (this.dependency == null) 3472 this.dependency = new ArrayList<ImplementationGuideDependencyComponent>(); 3473 this.dependency.add(t); 3474 return this; 3475 } 3476 3477 /** 3478 * @return {@link #package_} (A logical group of resources. Logical groups can 3479 * be used when building pages.) 3480 */ 3481 public List<ImplementationGuidePackageComponent> getPackage() { 3482 if (this.package_ == null) 3483 this.package_ = new ArrayList<ImplementationGuidePackageComponent>(); 3484 return this.package_; 3485 } 3486 3487 public boolean hasPackage() { 3488 if (this.package_ == null) 3489 return false; 3490 for (ImplementationGuidePackageComponent item : this.package_) 3491 if (!item.isEmpty()) 3492 return true; 3493 return false; 3494 } 3495 3496 /** 3497 * @return {@link #package_} (A logical group of resources. Logical groups can 3498 * be used when building pages.) 3499 */ 3500 // syntactic sugar 3501 public ImplementationGuidePackageComponent addPackage() { // 3 3502 ImplementationGuidePackageComponent t = new ImplementationGuidePackageComponent(); 3503 if (this.package_ == null) 3504 this.package_ = new ArrayList<ImplementationGuidePackageComponent>(); 3505 this.package_.add(t); 3506 return t; 3507 } 3508 3509 // syntactic sugar 3510 public ImplementationGuide addPackage(ImplementationGuidePackageComponent t) { // 3 3511 if (t == null) 3512 return this; 3513 if (this.package_ == null) 3514 this.package_ = new ArrayList<ImplementationGuidePackageComponent>(); 3515 this.package_.add(t); 3516 return this; 3517 } 3518 3519 /** 3520 * @return {@link #global} (A set of profiles that all resources covered by this 3521 * implementation guide must conform to.) 3522 */ 3523 public List<ImplementationGuideGlobalComponent> getGlobal() { 3524 if (this.global == null) 3525 this.global = new ArrayList<ImplementationGuideGlobalComponent>(); 3526 return this.global; 3527 } 3528 3529 public boolean hasGlobal() { 3530 if (this.global == null) 3531 return false; 3532 for (ImplementationGuideGlobalComponent item : this.global) 3533 if (!item.isEmpty()) 3534 return true; 3535 return false; 3536 } 3537 3538 /** 3539 * @return {@link #global} (A set of profiles that all resources covered by this 3540 * implementation guide must conform to.) 3541 */ 3542 // syntactic sugar 3543 public ImplementationGuideGlobalComponent addGlobal() { // 3 3544 ImplementationGuideGlobalComponent t = new ImplementationGuideGlobalComponent(); 3545 if (this.global == null) 3546 this.global = new ArrayList<ImplementationGuideGlobalComponent>(); 3547 this.global.add(t); 3548 return t; 3549 } 3550 3551 // syntactic sugar 3552 public ImplementationGuide addGlobal(ImplementationGuideGlobalComponent t) { // 3 3553 if (t == null) 3554 return this; 3555 if (this.global == null) 3556 this.global = new ArrayList<ImplementationGuideGlobalComponent>(); 3557 this.global.add(t); 3558 return this; 3559 } 3560 3561 /** 3562 * @return {@link #binary} (A binary file that is included in the implementation 3563 * guide when it is published.) 3564 */ 3565 public List<UriType> getBinary() { 3566 if (this.binary == null) 3567 this.binary = new ArrayList<UriType>(); 3568 return this.binary; 3569 } 3570 3571 public boolean hasBinary() { 3572 if (this.binary == null) 3573 return false; 3574 for (UriType item : this.binary) 3575 if (!item.isEmpty()) 3576 return true; 3577 return false; 3578 } 3579 3580 /** 3581 * @return {@link #binary} (A binary file that is included in the implementation 3582 * guide when it is published.) 3583 */ 3584 // syntactic sugar 3585 public UriType addBinaryElement() {// 2 3586 UriType t = new UriType(); 3587 if (this.binary == null) 3588 this.binary = new ArrayList<UriType>(); 3589 this.binary.add(t); 3590 return t; 3591 } 3592 3593 /** 3594 * @param value {@link #binary} (A binary file that is included in the 3595 * implementation guide when it is published.) 3596 */ 3597 public ImplementationGuide addBinary(String value) { // 1 3598 UriType t = new UriType(); 3599 t.setValue(value); 3600 if (this.binary == null) 3601 this.binary = new ArrayList<UriType>(); 3602 this.binary.add(t); 3603 return this; 3604 } 3605 3606 /** 3607 * @param value {@link #binary} (A binary file that is included in the 3608 * implementation guide when it is published.) 3609 */ 3610 public boolean hasBinary(String value) { 3611 if (this.binary == null) 3612 return false; 3613 for (UriType v : this.binary) 3614 if (v.equals(value)) // uri 3615 return true; 3616 return false; 3617 } 3618 3619 /** 3620 * @return {@link #page} (A page / section in the implementation guide. The root 3621 * page is the implementation guide home page.) 3622 */ 3623 public ImplementationGuidePageComponent getPage() { 3624 if (this.page == null) 3625 if (Configuration.errorOnAutoCreate()) 3626 throw new Error("Attempt to auto-create ImplementationGuide.page"); 3627 else if (Configuration.doAutoCreate()) 3628 this.page = new ImplementationGuidePageComponent(); // cc 3629 return this.page; 3630 } 3631 3632 public boolean hasPage() { 3633 return this.page != null && !this.page.isEmpty(); 3634 } 3635 3636 /** 3637 * @param value {@link #page} (A page / section in the implementation guide. The 3638 * root page is the implementation guide home page.) 3639 */ 3640 public ImplementationGuide setPage(ImplementationGuidePageComponent value) { 3641 this.page = value; 3642 return this; 3643 } 3644 3645 protected void listChildren(List<Property> childrenList) { 3646 super.listChildren(childrenList); 3647 childrenList.add(new Property("url", "uri", 3648 "An absolute URL that is used to identify this implementation guide when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this implementation guide is (or will be) published.", 3649 0, java.lang.Integer.MAX_VALUE, url)); 3650 childrenList.add(new Property("version", "string", 3651 "The identifier that is used to identify this version of the Implementation Guide when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the Implementation Guide author manually.", 3652 0, java.lang.Integer.MAX_VALUE, version)); 3653 childrenList 3654 .add(new Property("name", "string", "A free text natural language name identifying the Implementation Guide.", 3655 0, java.lang.Integer.MAX_VALUE, name)); 3656 childrenList.add(new Property("status", "code", "The status of the Implementation Guide.", 0, 3657 java.lang.Integer.MAX_VALUE, status)); 3658 childrenList.add(new Property("experimental", "boolean", 3659 "This Implementation Guide was authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 3660 0, java.lang.Integer.MAX_VALUE, experimental)); 3661 childrenList.add(new Property("publisher", "string", 3662 "The name of the individual or organization that published the implementation guide.", 0, 3663 java.lang.Integer.MAX_VALUE, publisher)); 3664 childrenList 3665 .add(new Property("contact", "", "Contacts to assist a user in finding and communicating with the publisher.", 3666 0, java.lang.Integer.MAX_VALUE, contact)); 3667 childrenList.add(new Property("date", "dateTime", 3668 "The date this version of the implementation guide was published. The date must change when the business version changes, if it does, and it must change if the status code changes. In addition, it should change when the substantive content of the implementation guide changes.", 3669 0, java.lang.Integer.MAX_VALUE, date)); 3670 childrenList.add(new Property("description", "string", 3671 "A free text natural language description of the Implementation Guide and its use.", 0, 3672 java.lang.Integer.MAX_VALUE, description)); 3673 childrenList.add(new Property("useContext", "CodeableConcept", 3674 "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching of implementation guides. The most common use of this element is to represent the country / jurisdiction for which this implementation guide was defined.", 3675 0, java.lang.Integer.MAX_VALUE, useContext)); 3676 childrenList.add(new Property("copyright", "string", 3677 "A copyright statement relating to the implementation guide and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the details of the constraints and mappings.", 3678 0, java.lang.Integer.MAX_VALUE, copyright)); 3679 childrenList.add(new Property("fhirVersion", "id", 3680 "The version of the FHIR specification on which this ImplementationGuide is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 1.0.2 for this version.", 3681 0, java.lang.Integer.MAX_VALUE, fhirVersion)); 3682 childrenList.add(new Property("dependency", "", 3683 "Another implementation guide that this implementation depends on. Typically, an implementation guide uses value sets, profiles etc.defined in other implementation guides.", 3684 0, java.lang.Integer.MAX_VALUE, dependency)); 3685 childrenList.add( 3686 new Property("package", "", "A logical group of resources. Logical groups can be used when building pages.", 0, 3687 java.lang.Integer.MAX_VALUE, package_)); 3688 childrenList.add(new Property("global", "", 3689 "A set of profiles that all resources covered by this implementation guide must conform to.", 0, 3690 java.lang.Integer.MAX_VALUE, global)); 3691 childrenList.add(new Property("binary", "uri", 3692 "A binary file that is included in the implementation guide when it is published.", 0, 3693 java.lang.Integer.MAX_VALUE, binary)); 3694 childrenList.add(new Property("page", "", 3695 "A page / section in the implementation guide. The root page is the implementation guide home page.", 0, 3696 java.lang.Integer.MAX_VALUE, page)); 3697 } 3698 3699 @Override 3700 public void setProperty(String name, Base value) throws FHIRException { 3701 if (name.equals("url")) 3702 this.url = castToUri(value); // UriType 3703 else if (name.equals("version")) 3704 this.version = castToString(value); // StringType 3705 else if (name.equals("name")) 3706 this.name = castToString(value); // StringType 3707 else if (name.equals("status")) 3708 this.status = new ConformanceResourceStatusEnumFactory().fromType(value); // Enumeration<ConformanceResourceStatus> 3709 else if (name.equals("experimental")) 3710 this.experimental = castToBoolean(value); // BooleanType 3711 else if (name.equals("publisher")) 3712 this.publisher = castToString(value); // StringType 3713 else if (name.equals("contact")) 3714 this.getContact().add((ImplementationGuideContactComponent) value); 3715 else if (name.equals("date")) 3716 this.date = castToDateTime(value); // DateTimeType 3717 else if (name.equals("description")) 3718 this.description = castToString(value); // StringType 3719 else if (name.equals("useContext")) 3720 this.getUseContext().add(castToCodeableConcept(value)); 3721 else if (name.equals("copyright")) 3722 this.copyright = castToString(value); // StringType 3723 else if (name.equals("fhirVersion")) 3724 this.fhirVersion = castToId(value); // IdType 3725 else if (name.equals("dependency")) 3726 this.getDependency().add((ImplementationGuideDependencyComponent) value); 3727 else if (name.equals("package")) 3728 this.getPackage().add((ImplementationGuidePackageComponent) value); 3729 else if (name.equals("global")) 3730 this.getGlobal().add((ImplementationGuideGlobalComponent) value); 3731 else if (name.equals("binary")) 3732 this.getBinary().add(castToUri(value)); 3733 else if (name.equals("page")) 3734 this.page = (ImplementationGuidePageComponent) value; // ImplementationGuidePageComponent 3735 else 3736 super.setProperty(name, value); 3737 } 3738 3739 @Override 3740 public Base addChild(String name) throws FHIRException { 3741 if (name.equals("url")) { 3742 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.url"); 3743 } else if (name.equals("version")) { 3744 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.version"); 3745 } else if (name.equals("name")) { 3746 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.name"); 3747 } else if (name.equals("status")) { 3748 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.status"); 3749 } else if (name.equals("experimental")) { 3750 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.experimental"); 3751 } else if (name.equals("publisher")) { 3752 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.publisher"); 3753 } else if (name.equals("contact")) { 3754 return addContact(); 3755 } else if (name.equals("date")) { 3756 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.date"); 3757 } else if (name.equals("description")) { 3758 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.description"); 3759 } else if (name.equals("useContext")) { 3760 return addUseContext(); 3761 } else if (name.equals("copyright")) { 3762 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.copyright"); 3763 } else if (name.equals("fhirVersion")) { 3764 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.fhirVersion"); 3765 } else if (name.equals("dependency")) { 3766 return addDependency(); 3767 } else if (name.equals("package")) { 3768 return addPackage(); 3769 } else if (name.equals("global")) { 3770 return addGlobal(); 3771 } else if (name.equals("binary")) { 3772 throw new FHIRException("Cannot call addChild on a singleton property ImplementationGuide.binary"); 3773 } else if (name.equals("page")) { 3774 this.page = new ImplementationGuidePageComponent(); 3775 return this.page; 3776 } else 3777 return super.addChild(name); 3778 } 3779 3780 public String fhirType() { 3781 return "ImplementationGuide"; 3782 3783 } 3784 3785 public ImplementationGuide copy() { 3786 ImplementationGuide dst = new ImplementationGuide(); 3787 copyValues(dst); 3788 dst.url = url == null ? null : url.copy(); 3789 dst.version = version == null ? null : version.copy(); 3790 dst.name = name == null ? null : name.copy(); 3791 dst.status = status == null ? null : status.copy(); 3792 dst.experimental = experimental == null ? null : experimental.copy(); 3793 dst.publisher = publisher == null ? null : publisher.copy(); 3794 if (contact != null) { 3795 dst.contact = new ArrayList<ImplementationGuideContactComponent>(); 3796 for (ImplementationGuideContactComponent i : contact) 3797 dst.contact.add(i.copy()); 3798 } 3799 ; 3800 dst.date = date == null ? null : date.copy(); 3801 dst.description = description == null ? null : description.copy(); 3802 if (useContext != null) { 3803 dst.useContext = new ArrayList<CodeableConcept>(); 3804 for (CodeableConcept i : useContext) 3805 dst.useContext.add(i.copy()); 3806 } 3807 ; 3808 dst.copyright = copyright == null ? null : copyright.copy(); 3809 dst.fhirVersion = fhirVersion == null ? null : fhirVersion.copy(); 3810 if (dependency != null) { 3811 dst.dependency = new ArrayList<ImplementationGuideDependencyComponent>(); 3812 for (ImplementationGuideDependencyComponent i : dependency) 3813 dst.dependency.add(i.copy()); 3814 } 3815 ; 3816 if (package_ != null) { 3817 dst.package_ = new ArrayList<ImplementationGuidePackageComponent>(); 3818 for (ImplementationGuidePackageComponent i : package_) 3819 dst.package_.add(i.copy()); 3820 } 3821 ; 3822 if (global != null) { 3823 dst.global = new ArrayList<ImplementationGuideGlobalComponent>(); 3824 for (ImplementationGuideGlobalComponent i : global) 3825 dst.global.add(i.copy()); 3826 } 3827 ; 3828 if (binary != null) { 3829 dst.binary = new ArrayList<UriType>(); 3830 for (UriType i : binary) 3831 dst.binary.add(i.copy()); 3832 } 3833 ; 3834 dst.page = page == null ? null : page.copy(); 3835 return dst; 3836 } 3837 3838 protected ImplementationGuide typedCopy() { 3839 return copy(); 3840 } 3841 3842 @Override 3843 public boolean equalsDeep(Base other) { 3844 if (!super.equalsDeep(other)) 3845 return false; 3846 if (!(other instanceof ImplementationGuide)) 3847 return false; 3848 ImplementationGuide o = (ImplementationGuide) other; 3849 return compareDeep(url, o.url, true) && compareDeep(version, o.version, true) && compareDeep(name, o.name, true) 3850 && compareDeep(status, o.status, true) && compareDeep(experimental, o.experimental, true) 3851 && compareDeep(publisher, o.publisher, true) && compareDeep(contact, o.contact, true) 3852 && compareDeep(date, o.date, true) && compareDeep(description, o.description, true) 3853 && compareDeep(useContext, o.useContext, true) && compareDeep(copyright, o.copyright, true) 3854 && compareDeep(fhirVersion, o.fhirVersion, true) && compareDeep(dependency, o.dependency, true) 3855 && compareDeep(package_, o.package_, true) && compareDeep(global, o.global, true) 3856 && compareDeep(binary, o.binary, true) && compareDeep(page, o.page, true); 3857 } 3858 3859 @Override 3860 public boolean equalsShallow(Base other) { 3861 if (!super.equalsShallow(other)) 3862 return false; 3863 if (!(other instanceof ImplementationGuide)) 3864 return false; 3865 ImplementationGuide o = (ImplementationGuide) other; 3866 return compareValues(url, o.url, true) && compareValues(version, o.version, true) 3867 && compareValues(name, o.name, true) && compareValues(status, o.status, true) 3868 && compareValues(experimental, o.experimental, true) && compareValues(publisher, o.publisher, true) 3869 && compareValues(date, o.date, true) && compareValues(description, o.description, true) 3870 && compareValues(copyright, o.copyright, true) && compareValues(fhirVersion, o.fhirVersion, true) 3871 && compareValues(binary, o.binary, true); 3872 } 3873 3874 public boolean isEmpty() { 3875 return super.isEmpty() && (url == null || url.isEmpty()) && (version == null || version.isEmpty()) 3876 && (name == null || name.isEmpty()) && (status == null || status.isEmpty()) 3877 && (experimental == null || experimental.isEmpty()) && (publisher == null || publisher.isEmpty()) 3878 && (contact == null || contact.isEmpty()) && (date == null || date.isEmpty()) 3879 && (description == null || description.isEmpty()) && (useContext == null || useContext.isEmpty()) 3880 && (copyright == null || copyright.isEmpty()) && (fhirVersion == null || fhirVersion.isEmpty()) 3881 && (dependency == null || dependency.isEmpty()) && (package_ == null || package_.isEmpty()) 3882 && (global == null || global.isEmpty()) && (binary == null || binary.isEmpty()) 3883 && (page == null || page.isEmpty()); 3884 } 3885 3886 @Override 3887 public ResourceType getResourceType() { 3888 return ResourceType.ImplementationGuide; 3889 } 3890 3891 @SearchParamDefinition(name = "date", path = "ImplementationGuide.date", description = "The implementation guide publication date", type = "date") 3892 public static final String SP_DATE = "date"; 3893 @SearchParamDefinition(name = "dependency", path = "ImplementationGuide.dependency.uri", description = "Where to find dependency", type = "uri") 3894 public static final String SP_DEPENDENCY = "dependency"; 3895 @SearchParamDefinition(name = "name", path = "ImplementationGuide.name", description = "Name of the implementation guide", type = "string") 3896 public static final String SP_NAME = "name"; 3897 @SearchParamDefinition(name = "context", path = "ImplementationGuide.useContext", description = "A use context assigned to the structure", type = "token") 3898 public static final String SP_CONTEXT = "context"; 3899 @SearchParamDefinition(name = "publisher", path = "ImplementationGuide.publisher", description = "Name of the publisher of the implementation guide", type = "string") 3900 public static final String SP_PUBLISHER = "publisher"; 3901 @SearchParamDefinition(name = "description", path = "ImplementationGuide.description", description = "Text search in the description of the implementation guide", type = "string") 3902 public static final String SP_DESCRIPTION = "description"; 3903 @SearchParamDefinition(name = "experimental", path = "ImplementationGuide.experimental", description = "If for testing purposes, not real usage", type = "token") 3904 public static final String SP_EXPERIMENTAL = "experimental"; 3905 @SearchParamDefinition(name = "version", path = "ImplementationGuide.version", description = "The version identifier of the implementation guide", type = "token") 3906 public static final String SP_VERSION = "version"; 3907 @SearchParamDefinition(name = "url", path = "ImplementationGuide.url", description = "Absolute URL used to reference this Implementation Guide", type = "uri") 3908 public static final String SP_URL = "url"; 3909 @SearchParamDefinition(name = "status", path = "ImplementationGuide.status", description = "The current status of the implementation guide", type = "token") 3910 public static final String SP_STATUS = "status"; 3911 3912}