001package org.hl7.fhir.dstu3.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 Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.1 033 034import java.util.*; 035 036import org.hl7.fhir.utilities.Utilities; 037import org.hl7.fhir.dstu3.model.Enumerations.*; 038import ca.uhn.fhir.model.api.annotation.ResourceDef; 039import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 040import ca.uhn.fhir.model.api.annotation.Child; 041import ca.uhn.fhir.model.api.annotation.ChildOrder; 042import ca.uhn.fhir.model.api.annotation.Description; 043import ca.uhn.fhir.model.api.annotation.Block; 044import org.hl7.fhir.instance.model.api.*; 045import org.hl7.fhir.exceptions.FHIRException; 046import org.hl7.fhir.exceptions.FHIRFormatError; 047/** 048 * A search parameter that defines a named search item that can be used to search/filter on a resource. 049 */ 050@ResourceDef(name="SearchParameter", profile="http://hl7.org/fhir/StructureDefinition/SearchParameter") 051@ChildOrder(names={"url", "version", "name", "status", "experimental", "date", "publisher", "contact", "useContext", "jurisdiction", "purpose", "code", "base", "type", "derivedFrom", "description", "expression", "xpath", "xpathUsage", "target", "comparator", "modifier", "chain", "component"}) 052public class SearchParameter extends MetadataResource { 053 054 public enum XPathUsageType { 055 /** 056 * The search parameter is derived directly from the selected nodes based on the type definitions. 057 */ 058 NORMAL, 059 /** 060 * The search parameter is derived by a phonetic transform from the selected nodes. 061 */ 062 PHONETIC, 063 /** 064 * The search parameter is based on a spatial transform of the selected nodes. 065 */ 066 NEARBY, 067 /** 068 * The search parameter is based on a spatial transform of the selected nodes, using physical distance from the middle. 069 */ 070 DISTANCE, 071 /** 072 * The interpretation of the xpath statement is unknown (and can't be automated). 073 */ 074 OTHER, 075 /** 076 * added to help the parsers with the generic types 077 */ 078 NULL; 079 public static XPathUsageType fromCode(String codeString) throws FHIRException { 080 if (codeString == null || "".equals(codeString)) 081 return null; 082 if ("normal".equals(codeString)) 083 return NORMAL; 084 if ("phonetic".equals(codeString)) 085 return PHONETIC; 086 if ("nearby".equals(codeString)) 087 return NEARBY; 088 if ("distance".equals(codeString)) 089 return DISTANCE; 090 if ("other".equals(codeString)) 091 return OTHER; 092 if (Configuration.isAcceptInvalidEnums()) 093 return null; 094 else 095 throw new FHIRException("Unknown XPathUsageType code '"+codeString+"'"); 096 } 097 public String toCode() { 098 switch (this) { 099 case NORMAL: return "normal"; 100 case PHONETIC: return "phonetic"; 101 case NEARBY: return "nearby"; 102 case DISTANCE: return "distance"; 103 case OTHER: return "other"; 104 default: return "?"; 105 } 106 } 107 public String getSystem() { 108 switch (this) { 109 case NORMAL: return "http://hl7.org/fhir/search-xpath-usage"; 110 case PHONETIC: return "http://hl7.org/fhir/search-xpath-usage"; 111 case NEARBY: return "http://hl7.org/fhir/search-xpath-usage"; 112 case DISTANCE: return "http://hl7.org/fhir/search-xpath-usage"; 113 case OTHER: return "http://hl7.org/fhir/search-xpath-usage"; 114 default: return "?"; 115 } 116 } 117 public String getDefinition() { 118 switch (this) { 119 case NORMAL: return "The search parameter is derived directly from the selected nodes based on the type definitions."; 120 case PHONETIC: return "The search parameter is derived by a phonetic transform from the selected nodes."; 121 case NEARBY: return "The search parameter is based on a spatial transform of the selected nodes."; 122 case DISTANCE: return "The search parameter is based on a spatial transform of the selected nodes, using physical distance from the middle."; 123 case OTHER: return "The interpretation of the xpath statement is unknown (and can't be automated)."; 124 default: return "?"; 125 } 126 } 127 public String getDisplay() { 128 switch (this) { 129 case NORMAL: return "Normal"; 130 case PHONETIC: return "Phonetic"; 131 case NEARBY: return "Nearby"; 132 case DISTANCE: return "Distance"; 133 case OTHER: return "Other"; 134 default: return "?"; 135 } 136 } 137 } 138 139 public static class XPathUsageTypeEnumFactory implements EnumFactory<XPathUsageType> { 140 public XPathUsageType fromCode(String codeString) throws IllegalArgumentException { 141 if (codeString == null || "".equals(codeString)) 142 if (codeString == null || "".equals(codeString)) 143 return null; 144 if ("normal".equals(codeString)) 145 return XPathUsageType.NORMAL; 146 if ("phonetic".equals(codeString)) 147 return XPathUsageType.PHONETIC; 148 if ("nearby".equals(codeString)) 149 return XPathUsageType.NEARBY; 150 if ("distance".equals(codeString)) 151 return XPathUsageType.DISTANCE; 152 if ("other".equals(codeString)) 153 return XPathUsageType.OTHER; 154 throw new IllegalArgumentException("Unknown XPathUsageType code '"+codeString+"'"); 155 } 156 public Enumeration<XPathUsageType> fromType(Base code) throws FHIRException { 157 if (code == null) 158 return null; 159 if (code.isEmpty()) 160 return new Enumeration<XPathUsageType>(this); 161 String codeString = ((PrimitiveType) code).asStringValue(); 162 if (codeString == null || "".equals(codeString)) 163 return null; 164 if ("normal".equals(codeString)) 165 return new Enumeration<XPathUsageType>(this, XPathUsageType.NORMAL); 166 if ("phonetic".equals(codeString)) 167 return new Enumeration<XPathUsageType>(this, XPathUsageType.PHONETIC); 168 if ("nearby".equals(codeString)) 169 return new Enumeration<XPathUsageType>(this, XPathUsageType.NEARBY); 170 if ("distance".equals(codeString)) 171 return new Enumeration<XPathUsageType>(this, XPathUsageType.DISTANCE); 172 if ("other".equals(codeString)) 173 return new Enumeration<XPathUsageType>(this, XPathUsageType.OTHER); 174 throw new FHIRException("Unknown XPathUsageType code '"+codeString+"'"); 175 } 176 public String toCode(XPathUsageType code) { 177 if (code == XPathUsageType.NORMAL) 178 return "normal"; 179 if (code == XPathUsageType.PHONETIC) 180 return "phonetic"; 181 if (code == XPathUsageType.NEARBY) 182 return "nearby"; 183 if (code == XPathUsageType.DISTANCE) 184 return "distance"; 185 if (code == XPathUsageType.OTHER) 186 return "other"; 187 return "?"; 188 } 189 public String toSystem(XPathUsageType code) { 190 return code.getSystem(); 191 } 192 } 193 194 public enum SearchComparator { 195 /** 196 * the value for the parameter in the resource is equal to the provided value 197 */ 198 EQ, 199 /** 200 * the value for the parameter in the resource is not equal to the provided value 201 */ 202 NE, 203 /** 204 * the value for the parameter in the resource is greater than the provided value 205 */ 206 GT, 207 /** 208 * the value for the parameter in the resource is less than the provided value 209 */ 210 LT, 211 /** 212 * the value for the parameter in the resource is greater or equal to the provided value 213 */ 214 GE, 215 /** 216 * the value for the parameter in the resource is less or equal to the provided value 217 */ 218 LE, 219 /** 220 * the value for the parameter in the resource starts after the provided value 221 */ 222 SA, 223 /** 224 * the value for the parameter in the resource ends before the provided value 225 */ 226 EB, 227 /** 228 * the value for the parameter in the resource is approximately the same to the provided value. 229 */ 230 AP, 231 /** 232 * added to help the parsers with the generic types 233 */ 234 NULL; 235 public static SearchComparator fromCode(String codeString) throws FHIRException { 236 if (codeString == null || "".equals(codeString)) 237 return null; 238 if ("eq".equals(codeString)) 239 return EQ; 240 if ("ne".equals(codeString)) 241 return NE; 242 if ("gt".equals(codeString)) 243 return GT; 244 if ("lt".equals(codeString)) 245 return LT; 246 if ("ge".equals(codeString)) 247 return GE; 248 if ("le".equals(codeString)) 249 return LE; 250 if ("sa".equals(codeString)) 251 return SA; 252 if ("eb".equals(codeString)) 253 return EB; 254 if ("ap".equals(codeString)) 255 return AP; 256 if (Configuration.isAcceptInvalidEnums()) 257 return null; 258 else 259 throw new FHIRException("Unknown SearchComparator code '"+codeString+"'"); 260 } 261 public String toCode() { 262 switch (this) { 263 case EQ: return "eq"; 264 case NE: return "ne"; 265 case GT: return "gt"; 266 case LT: return "lt"; 267 case GE: return "ge"; 268 case LE: return "le"; 269 case SA: return "sa"; 270 case EB: return "eb"; 271 case AP: return "ap"; 272 default: return "?"; 273 } 274 } 275 public String getSystem() { 276 switch (this) { 277 case EQ: return "http://hl7.org/fhir/search-comparator"; 278 case NE: return "http://hl7.org/fhir/search-comparator"; 279 case GT: return "http://hl7.org/fhir/search-comparator"; 280 case LT: return "http://hl7.org/fhir/search-comparator"; 281 case GE: return "http://hl7.org/fhir/search-comparator"; 282 case LE: return "http://hl7.org/fhir/search-comparator"; 283 case SA: return "http://hl7.org/fhir/search-comparator"; 284 case EB: return "http://hl7.org/fhir/search-comparator"; 285 case AP: return "http://hl7.org/fhir/search-comparator"; 286 default: return "?"; 287 } 288 } 289 public String getDefinition() { 290 switch (this) { 291 case EQ: return "the value for the parameter in the resource is equal to the provided value"; 292 case NE: return "the value for the parameter in the resource is not equal to the provided value"; 293 case GT: return "the value for the parameter in the resource is greater than the provided value"; 294 case LT: return "the value for the parameter in the resource is less than the provided value"; 295 case GE: return "the value for the parameter in the resource is greater or equal to the provided value"; 296 case LE: return "the value for the parameter in the resource is less or equal to the provided value"; 297 case SA: return "the value for the parameter in the resource starts after the provided value"; 298 case EB: return "the value for the parameter in the resource ends before the provided value"; 299 case AP: return "the value for the parameter in the resource is approximately the same to the provided value."; 300 default: return "?"; 301 } 302 } 303 public String getDisplay() { 304 switch (this) { 305 case EQ: return "Equals"; 306 case NE: return "Not Equals"; 307 case GT: return "Greater Than"; 308 case LT: return "Less Then"; 309 case GE: return "Greater or Equals"; 310 case LE: return "Less of Equal"; 311 case SA: return "Starts After"; 312 case EB: return "Ends Before"; 313 case AP: return "Approximately"; 314 default: return "?"; 315 } 316 } 317 } 318 319 public static class SearchComparatorEnumFactory implements EnumFactory<SearchComparator> { 320 public SearchComparator fromCode(String codeString) throws IllegalArgumentException { 321 if (codeString == null || "".equals(codeString)) 322 if (codeString == null || "".equals(codeString)) 323 return null; 324 if ("eq".equals(codeString)) 325 return SearchComparator.EQ; 326 if ("ne".equals(codeString)) 327 return SearchComparator.NE; 328 if ("gt".equals(codeString)) 329 return SearchComparator.GT; 330 if ("lt".equals(codeString)) 331 return SearchComparator.LT; 332 if ("ge".equals(codeString)) 333 return SearchComparator.GE; 334 if ("le".equals(codeString)) 335 return SearchComparator.LE; 336 if ("sa".equals(codeString)) 337 return SearchComparator.SA; 338 if ("eb".equals(codeString)) 339 return SearchComparator.EB; 340 if ("ap".equals(codeString)) 341 return SearchComparator.AP; 342 throw new IllegalArgumentException("Unknown SearchComparator code '"+codeString+"'"); 343 } 344 public Enumeration<SearchComparator> fromType(Base code) throws FHIRException { 345 if (code == null) 346 return null; 347 if (code.isEmpty()) 348 return new Enumeration<SearchComparator>(this); 349 String codeString = ((PrimitiveType) code).asStringValue(); 350 if (codeString == null || "".equals(codeString)) 351 return null; 352 if ("eq".equals(codeString)) 353 return new Enumeration<SearchComparator>(this, SearchComparator.EQ); 354 if ("ne".equals(codeString)) 355 return new Enumeration<SearchComparator>(this, SearchComparator.NE); 356 if ("gt".equals(codeString)) 357 return new Enumeration<SearchComparator>(this, SearchComparator.GT); 358 if ("lt".equals(codeString)) 359 return new Enumeration<SearchComparator>(this, SearchComparator.LT); 360 if ("ge".equals(codeString)) 361 return new Enumeration<SearchComparator>(this, SearchComparator.GE); 362 if ("le".equals(codeString)) 363 return new Enumeration<SearchComparator>(this, SearchComparator.LE); 364 if ("sa".equals(codeString)) 365 return new Enumeration<SearchComparator>(this, SearchComparator.SA); 366 if ("eb".equals(codeString)) 367 return new Enumeration<SearchComparator>(this, SearchComparator.EB); 368 if ("ap".equals(codeString)) 369 return new Enumeration<SearchComparator>(this, SearchComparator.AP); 370 throw new FHIRException("Unknown SearchComparator code '"+codeString+"'"); 371 } 372 public String toCode(SearchComparator code) { 373 if (code == SearchComparator.EQ) 374 return "eq"; 375 if (code == SearchComparator.NE) 376 return "ne"; 377 if (code == SearchComparator.GT) 378 return "gt"; 379 if (code == SearchComparator.LT) 380 return "lt"; 381 if (code == SearchComparator.GE) 382 return "ge"; 383 if (code == SearchComparator.LE) 384 return "le"; 385 if (code == SearchComparator.SA) 386 return "sa"; 387 if (code == SearchComparator.EB) 388 return "eb"; 389 if (code == SearchComparator.AP) 390 return "ap"; 391 return "?"; 392 } 393 public String toSystem(SearchComparator code) { 394 return code.getSystem(); 395 } 396 } 397 398 public enum SearchModifierCode { 399 /** 400 * The search parameter returns resources that have a value or not. 401 */ 402 MISSING, 403 /** 404 * The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents). 405 */ 406 EXACT, 407 /** 408 * The search parameter returns resources that include the supplied parameter value anywhere within the field being searched. 409 */ 410 CONTAINS, 411 /** 412 * The search parameter returns resources that do not contain a match. 413 */ 414 NOT, 415 /** 416 * The search parameter is processed as a string that searches text associated with the code/value - either CodeableConcept.text, Coding.display, or Identifier.type.text. 417 */ 418 TEXT, 419 /** 420 * The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is in the specified value set. 421 */ 422 IN, 423 /** 424 * The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is not in the specified value set. 425 */ 426 NOTIN, 427 /** 428 * The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships). 429 */ 430 BELOW, 431 /** 432 * The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships). 433 */ 434 ABOVE, 435 /** 436 * The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.). 437 */ 438 TYPE, 439 /** 440 * added to help the parsers with the generic types 441 */ 442 NULL; 443 public static SearchModifierCode fromCode(String codeString) throws FHIRException { 444 if (codeString == null || "".equals(codeString)) 445 return null; 446 if ("missing".equals(codeString)) 447 return MISSING; 448 if ("exact".equals(codeString)) 449 return EXACT; 450 if ("contains".equals(codeString)) 451 return CONTAINS; 452 if ("not".equals(codeString)) 453 return NOT; 454 if ("text".equals(codeString)) 455 return TEXT; 456 if ("in".equals(codeString)) 457 return IN; 458 if ("not-in".equals(codeString)) 459 return NOTIN; 460 if ("below".equals(codeString)) 461 return BELOW; 462 if ("above".equals(codeString)) 463 return ABOVE; 464 if ("type".equals(codeString)) 465 return TYPE; 466 if (Configuration.isAcceptInvalidEnums()) 467 return null; 468 else 469 throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'"); 470 } 471 public String toCode() { 472 switch (this) { 473 case MISSING: return "missing"; 474 case EXACT: return "exact"; 475 case CONTAINS: return "contains"; 476 case NOT: return "not"; 477 case TEXT: return "text"; 478 case IN: return "in"; 479 case NOTIN: return "not-in"; 480 case BELOW: return "below"; 481 case ABOVE: return "above"; 482 case TYPE: return "type"; 483 default: return "?"; 484 } 485 } 486 public String getSystem() { 487 switch (this) { 488 case MISSING: return "http://hl7.org/fhir/search-modifier-code"; 489 case EXACT: return "http://hl7.org/fhir/search-modifier-code"; 490 case CONTAINS: return "http://hl7.org/fhir/search-modifier-code"; 491 case NOT: return "http://hl7.org/fhir/search-modifier-code"; 492 case TEXT: return "http://hl7.org/fhir/search-modifier-code"; 493 case IN: return "http://hl7.org/fhir/search-modifier-code"; 494 case NOTIN: return "http://hl7.org/fhir/search-modifier-code"; 495 case BELOW: return "http://hl7.org/fhir/search-modifier-code"; 496 case ABOVE: return "http://hl7.org/fhir/search-modifier-code"; 497 case TYPE: return "http://hl7.org/fhir/search-modifier-code"; 498 default: return "?"; 499 } 500 } 501 public String getDefinition() { 502 switch (this) { 503 case MISSING: return "The search parameter returns resources that have a value or not."; 504 case EXACT: return "The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents)."; 505 case CONTAINS: return "The search parameter returns resources that include the supplied parameter value anywhere within the field being searched."; 506 case NOT: return "The search parameter returns resources that do not contain a match."; 507 case TEXT: return "The search parameter is processed as a string that searches text associated with the code/value - either CodeableConcept.text, Coding.display, or Identifier.type.text."; 508 case IN: return "The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is in the specified value set."; 509 case NOTIN: return "The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is not in the specified value set."; 510 case BELOW: return "The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships)."; 511 case ABOVE: return "The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships)."; 512 case TYPE: return "The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.)."; 513 default: return "?"; 514 } 515 } 516 public String getDisplay() { 517 switch (this) { 518 case MISSING: return "Missing"; 519 case EXACT: return "Exact"; 520 case CONTAINS: return "Contains"; 521 case NOT: return "Not"; 522 case TEXT: return "Text"; 523 case IN: return "In"; 524 case NOTIN: return "Not In"; 525 case BELOW: return "Below"; 526 case ABOVE: return "Above"; 527 case TYPE: return "Type"; 528 default: return "?"; 529 } 530 } 531 } 532 533 public static class SearchModifierCodeEnumFactory implements EnumFactory<SearchModifierCode> { 534 public SearchModifierCode fromCode(String codeString) throws IllegalArgumentException { 535 if (codeString == null || "".equals(codeString)) 536 if (codeString == null || "".equals(codeString)) 537 return null; 538 if ("missing".equals(codeString)) 539 return SearchModifierCode.MISSING; 540 if ("exact".equals(codeString)) 541 return SearchModifierCode.EXACT; 542 if ("contains".equals(codeString)) 543 return SearchModifierCode.CONTAINS; 544 if ("not".equals(codeString)) 545 return SearchModifierCode.NOT; 546 if ("text".equals(codeString)) 547 return SearchModifierCode.TEXT; 548 if ("in".equals(codeString)) 549 return SearchModifierCode.IN; 550 if ("not-in".equals(codeString)) 551 return SearchModifierCode.NOTIN; 552 if ("below".equals(codeString)) 553 return SearchModifierCode.BELOW; 554 if ("above".equals(codeString)) 555 return SearchModifierCode.ABOVE; 556 if ("type".equals(codeString)) 557 return SearchModifierCode.TYPE; 558 throw new IllegalArgumentException("Unknown SearchModifierCode code '"+codeString+"'"); 559 } 560 public Enumeration<SearchModifierCode> fromType(Base code) throws FHIRException { 561 if (code == null) 562 return null; 563 if (code.isEmpty()) 564 return new Enumeration<SearchModifierCode>(this); 565 String codeString = ((PrimitiveType) code).asStringValue(); 566 if (codeString == null || "".equals(codeString)) 567 return null; 568 if ("missing".equals(codeString)) 569 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.MISSING); 570 if ("exact".equals(codeString)) 571 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.EXACT); 572 if ("contains".equals(codeString)) 573 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CONTAINS); 574 if ("not".equals(codeString)) 575 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOT); 576 if ("text".equals(codeString)) 577 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXT); 578 if ("in".equals(codeString)) 579 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IN); 580 if ("not-in".equals(codeString)) 581 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOTIN); 582 if ("below".equals(codeString)) 583 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.BELOW); 584 if ("above".equals(codeString)) 585 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ABOVE); 586 if ("type".equals(codeString)) 587 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TYPE); 588 throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'"); 589 } 590 public String toCode(SearchModifierCode code) { 591 if (code == SearchModifierCode.MISSING) 592 return "missing"; 593 if (code == SearchModifierCode.EXACT) 594 return "exact"; 595 if (code == SearchModifierCode.CONTAINS) 596 return "contains"; 597 if (code == SearchModifierCode.NOT) 598 return "not"; 599 if (code == SearchModifierCode.TEXT) 600 return "text"; 601 if (code == SearchModifierCode.IN) 602 return "in"; 603 if (code == SearchModifierCode.NOTIN) 604 return "not-in"; 605 if (code == SearchModifierCode.BELOW) 606 return "below"; 607 if (code == SearchModifierCode.ABOVE) 608 return "above"; 609 if (code == SearchModifierCode.TYPE) 610 return "type"; 611 return "?"; 612 } 613 public String toSystem(SearchModifierCode code) { 614 return code.getSystem(); 615 } 616 } 617 618 @Block() 619 public static class SearchParameterComponentComponent extends BackboneElement implements IBaseBackboneElement { 620 /** 621 * The definition of the search parameter that describes this part. 622 */ 623 @Child(name = "definition", type = {SearchParameter.class}, order=1, min=1, max=1, modifier=false, summary=false) 624 @Description(shortDefinition="Defines how the part works", formalDefinition="The definition of the search parameter that describes this part." ) 625 protected Reference definition; 626 627 /** 628 * The actual object that is the target of the reference (The definition of the search parameter that describes this part.) 629 */ 630 protected SearchParameter definitionTarget; 631 632 /** 633 * A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression. 634 */ 635 @Child(name = "expression", type = {StringType.class}, order=2, min=1, max=1, modifier=false, summary=false) 636 @Description(shortDefinition="Subexpression relative to main expression", formalDefinition="A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression." ) 637 protected StringType expression; 638 639 private static final long serialVersionUID = -1105563614L; 640 641 /** 642 * Constructor 643 */ 644 public SearchParameterComponentComponent() { 645 super(); 646 } 647 648 /** 649 * Constructor 650 */ 651 public SearchParameterComponentComponent(Reference definition, StringType expression) { 652 super(); 653 this.definition = definition; 654 this.expression = expression; 655 } 656 657 /** 658 * @return {@link #definition} (The definition of the search parameter that describes this part.) 659 */ 660 public Reference getDefinition() { 661 if (this.definition == null) 662 if (Configuration.errorOnAutoCreate()) 663 throw new Error("Attempt to auto-create SearchParameterComponentComponent.definition"); 664 else if (Configuration.doAutoCreate()) 665 this.definition = new Reference(); // cc 666 return this.definition; 667 } 668 669 public boolean hasDefinition() { 670 return this.definition != null && !this.definition.isEmpty(); 671 } 672 673 /** 674 * @param value {@link #definition} (The definition of the search parameter that describes this part.) 675 */ 676 public SearchParameterComponentComponent setDefinition(Reference value) { 677 this.definition = value; 678 return this; 679 } 680 681 /** 682 * @return {@link #definition} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The definition of the search parameter that describes this part.) 683 */ 684 public SearchParameter getDefinitionTarget() { 685 if (this.definitionTarget == null) 686 if (Configuration.errorOnAutoCreate()) 687 throw new Error("Attempt to auto-create SearchParameterComponentComponent.definition"); 688 else if (Configuration.doAutoCreate()) 689 this.definitionTarget = new SearchParameter(); // aa 690 return this.definitionTarget; 691 } 692 693 /** 694 * @param value {@link #definition} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The definition of the search parameter that describes this part.) 695 */ 696 public SearchParameterComponentComponent setDefinitionTarget(SearchParameter value) { 697 this.definitionTarget = value; 698 return this; 699 } 700 701 /** 702 * @return {@link #expression} (A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value 703 */ 704 public StringType getExpressionElement() { 705 if (this.expression == null) 706 if (Configuration.errorOnAutoCreate()) 707 throw new Error("Attempt to auto-create SearchParameterComponentComponent.expression"); 708 else if (Configuration.doAutoCreate()) 709 this.expression = new StringType(); // bb 710 return this.expression; 711 } 712 713 public boolean hasExpressionElement() { 714 return this.expression != null && !this.expression.isEmpty(); 715 } 716 717 public boolean hasExpression() { 718 return this.expression != null && !this.expression.isEmpty(); 719 } 720 721 /** 722 * @param value {@link #expression} (A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value 723 */ 724 public SearchParameterComponentComponent setExpressionElement(StringType value) { 725 this.expression = value; 726 return this; 727 } 728 729 /** 730 * @return A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression. 731 */ 732 public String getExpression() { 733 return this.expression == null ? null : this.expression.getValue(); 734 } 735 736 /** 737 * @param value A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression. 738 */ 739 public SearchParameterComponentComponent setExpression(String value) { 740 if (this.expression == null) 741 this.expression = new StringType(); 742 this.expression.setValue(value); 743 return this; 744 } 745 746 protected void listChildren(List<Property> children) { 747 super.listChildren(children); 748 children.add(new Property("definition", "Reference(SearchParameter)", "The definition of the search parameter that describes this part.", 0, 1, definition)); 749 children.add(new Property("expression", "string", "A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.", 0, 1, expression)); 750 } 751 752 @Override 753 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 754 switch (_hash) { 755 case -1014418093: /*definition*/ return new Property("definition", "Reference(SearchParameter)", "The definition of the search parameter that describes this part.", 0, 1, definition); 756 case -1795452264: /*expression*/ return new Property("expression", "string", "A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.", 0, 1, expression); 757 default: return super.getNamedProperty(_hash, _name, _checkValid); 758 } 759 760 } 761 762 @Override 763 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 764 switch (hash) { 765 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // Reference 766 case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType 767 default: return super.getProperty(hash, name, checkValid); 768 } 769 770 } 771 772 @Override 773 public Base setProperty(int hash, String name, Base value) throws FHIRException { 774 switch (hash) { 775 case -1014418093: // definition 776 this.definition = castToReference(value); // Reference 777 return value; 778 case -1795452264: // expression 779 this.expression = castToString(value); // StringType 780 return value; 781 default: return super.setProperty(hash, name, value); 782 } 783 784 } 785 786 @Override 787 public Base setProperty(String name, Base value) throws FHIRException { 788 if (name.equals("definition")) { 789 this.definition = castToReference(value); // Reference 790 } else if (name.equals("expression")) { 791 this.expression = castToString(value); // StringType 792 } else 793 return super.setProperty(name, value); 794 return value; 795 } 796 797 @Override 798 public Base makeProperty(int hash, String name) throws FHIRException { 799 switch (hash) { 800 case -1014418093: return getDefinition(); 801 case -1795452264: return getExpressionElement(); 802 default: return super.makeProperty(hash, name); 803 } 804 805 } 806 807 @Override 808 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 809 switch (hash) { 810 case -1014418093: /*definition*/ return new String[] {"Reference"}; 811 case -1795452264: /*expression*/ return new String[] {"string"}; 812 default: return super.getTypesForProperty(hash, name); 813 } 814 815 } 816 817 @Override 818 public Base addChild(String name) throws FHIRException { 819 if (name.equals("definition")) { 820 this.definition = new Reference(); 821 return this.definition; 822 } 823 else if (name.equals("expression")) { 824 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.expression"); 825 } 826 else 827 return super.addChild(name); 828 } 829 830 public SearchParameterComponentComponent copy() { 831 SearchParameterComponentComponent dst = new SearchParameterComponentComponent(); 832 copyValues(dst); 833 dst.definition = definition == null ? null : definition.copy(); 834 dst.expression = expression == null ? null : expression.copy(); 835 return dst; 836 } 837 838 @Override 839 public boolean equalsDeep(Base other_) { 840 if (!super.equalsDeep(other_)) 841 return false; 842 if (!(other_ instanceof SearchParameterComponentComponent)) 843 return false; 844 SearchParameterComponentComponent o = (SearchParameterComponentComponent) other_; 845 return compareDeep(definition, o.definition, true) && compareDeep(expression, o.expression, true) 846 ; 847 } 848 849 @Override 850 public boolean equalsShallow(Base other_) { 851 if (!super.equalsShallow(other_)) 852 return false; 853 if (!(other_ instanceof SearchParameterComponentComponent)) 854 return false; 855 SearchParameterComponentComponent o = (SearchParameterComponentComponent) other_; 856 return compareValues(expression, o.expression, true); 857 } 858 859 public boolean isEmpty() { 860 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(definition, expression); 861 } 862 863 public String fhirType() { 864 return "SearchParameter.component"; 865 866 } 867 868 } 869 870 /** 871 * Explaination of why this search parameter is needed and why it has been designed as it has. 872 */ 873 @Child(name = "purpose", type = {MarkdownType.class}, order=0, min=0, max=1, modifier=false, summary=false) 874 @Description(shortDefinition="Why this search parameter is defined", formalDefinition="Explaination of why this search parameter is needed and why it has been designed as it has." ) 875 protected MarkdownType purpose; 876 877 /** 878 * The code used in the URL or the parameter name in a parameters resource for this search parameter. 879 */ 880 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 881 @Description(shortDefinition="Code used in URL", formalDefinition="The code used in the URL or the parameter name in a parameters resource for this search parameter." ) 882 protected CodeType code; 883 884 /** 885 * The base resource type(s) that this search parameter can be used against. 886 */ 887 @Child(name = "base", type = {CodeType.class}, order=2, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 888 @Description(shortDefinition="The resource type(s) this search parameter applies to", formalDefinition="The base resource type(s) that this search parameter can be used against." ) 889 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types") 890 protected List<CodeType> base; 891 892 /** 893 * The type of value a search parameter refers to, and how the content is interpreted. 894 */ 895 @Child(name = "type", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true) 896 @Description(shortDefinition="number | date | string | token | reference | composite | quantity | uri", formalDefinition="The type of value a search parameter refers to, and how the content is interpreted." ) 897 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-param-type") 898 protected Enumeration<SearchParamType> type; 899 900 /** 901 * Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter. 902 */ 903 @Child(name = "derivedFrom", type = {UriType.class}, order=4, min=0, max=1, modifier=false, summary=false) 904 @Description(shortDefinition="Original Definition for the search parameter", formalDefinition="Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter." ) 905 protected UriType derivedFrom; 906 907 /** 908 * A FHIRPath expression that returns a set of elements for the search parameter. 909 */ 910 @Child(name = "expression", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=false) 911 @Description(shortDefinition="FHIRPath expression that extracts the values", formalDefinition="A FHIRPath expression that returns a set of elements for the search parameter." ) 912 protected StringType expression; 913 914 /** 915 * An XPath expression that returns a set of elements for the search parameter. 916 */ 917 @Child(name = "xpath", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=false) 918 @Description(shortDefinition="XPath that extracts the values", formalDefinition="An XPath expression that returns a set of elements for the search parameter." ) 919 protected StringType xpath; 920 921 /** 922 * How the search parameter relates to the set of elements returned by evaluating the xpath query. 923 */ 924 @Child(name = "xpathUsage", type = {CodeType.class}, order=7, min=0, max=1, modifier=false, summary=false) 925 @Description(shortDefinition="normal | phonetic | nearby | distance | other", formalDefinition="How the search parameter relates to the set of elements returned by evaluating the xpath query." ) 926 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-xpath-usage") 927 protected Enumeration<XPathUsageType> xpathUsage; 928 929 /** 930 * Types of resource (if a resource is referenced). 931 */ 932 @Child(name = "target", type = {CodeType.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 933 @Description(shortDefinition="Types of resource (if a resource reference)", formalDefinition="Types of resource (if a resource is referenced)." ) 934 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types") 935 protected List<CodeType> target; 936 937 /** 938 * Comparators supported for the search parameter. 939 */ 940 @Child(name = "comparator", type = {CodeType.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 941 @Description(shortDefinition="eq | ne | gt | lt | ge | le | sa | eb | ap", formalDefinition="Comparators supported for the search parameter." ) 942 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-comparator") 943 protected List<Enumeration<SearchComparator>> comparator; 944 945 /** 946 * A modifier supported for the search parameter. 947 */ 948 @Child(name = "modifier", type = {CodeType.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 949 @Description(shortDefinition="missing | exact | contains | not | text | in | not-in | below | above | type", formalDefinition="A modifier supported for the search parameter." ) 950 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-modifier-code") 951 protected List<Enumeration<SearchModifierCode>> modifier; 952 953 /** 954 * Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type. 955 */ 956 @Child(name = "chain", type = {StringType.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 957 @Description(shortDefinition="Chained names supported", formalDefinition="Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type." ) 958 protected List<StringType> chain; 959 960 /** 961 * Used to define the parts of a composite search parameter. 962 */ 963 @Child(name = "component", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 964 @Description(shortDefinition="For Composite resources to define the parts", formalDefinition="Used to define the parts of a composite search parameter." ) 965 protected List<SearchParameterComponentComponent> component; 966 967 private static final long serialVersionUID = -769368159L; 968 969 /** 970 * Constructor 971 */ 972 public SearchParameter() { 973 super(); 974 } 975 976 /** 977 * Constructor 978 */ 979 public SearchParameter(UriType url, StringType name, Enumeration<PublicationStatus> status, CodeType code, Enumeration<SearchParamType> type, MarkdownType description) { 980 super(); 981 this.url = url; 982 this.name = name; 983 this.status = status; 984 this.code = code; 985 this.type = type; 986 this.description = description; 987 } 988 989 /** 990 * @return {@link #url} (An absolute URI that is used to identify this search parameter 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 search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 991 */ 992 public UriType getUrlElement() { 993 if (this.url == null) 994 if (Configuration.errorOnAutoCreate()) 995 throw new Error("Attempt to auto-create SearchParameter.url"); 996 else if (Configuration.doAutoCreate()) 997 this.url = new UriType(); // bb 998 return this.url; 999 } 1000 1001 public boolean hasUrlElement() { 1002 return this.url != null && !this.url.isEmpty(); 1003 } 1004 1005 public boolean hasUrl() { 1006 return this.url != null && !this.url.isEmpty(); 1007 } 1008 1009 /** 1010 * @param value {@link #url} (An absolute URI that is used to identify this search parameter 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 search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 1011 */ 1012 public SearchParameter setUrlElement(UriType value) { 1013 this.url = value; 1014 return this; 1015 } 1016 1017 /** 1018 * @return An absolute URI that is used to identify this search parameter 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 search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions). 1019 */ 1020 public String getUrl() { 1021 return this.url == null ? null : this.url.getValue(); 1022 } 1023 1024 /** 1025 * @param value An absolute URI that is used to identify this search parameter 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 search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions). 1026 */ 1027 public SearchParameter setUrl(String value) { 1028 if (this.url == null) 1029 this.url = new UriType(); 1030 this.url.setValue(value); 1031 return this; 1032 } 1033 1034 /** 1035 * @return {@link #version} (The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 1036 */ 1037 public StringType getVersionElement() { 1038 if (this.version == null) 1039 if (Configuration.errorOnAutoCreate()) 1040 throw new Error("Attempt to auto-create SearchParameter.version"); 1041 else if (Configuration.doAutoCreate()) 1042 this.version = new StringType(); // bb 1043 return this.version; 1044 } 1045 1046 public boolean hasVersionElement() { 1047 return this.version != null && !this.version.isEmpty(); 1048 } 1049 1050 public boolean hasVersion() { 1051 return this.version != null && !this.version.isEmpty(); 1052 } 1053 1054 /** 1055 * @param value {@link #version} (The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 1056 */ 1057 public SearchParameter setVersionElement(StringType value) { 1058 this.version = value; 1059 return this; 1060 } 1061 1062 /** 1063 * @return The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. 1064 */ 1065 public String getVersion() { 1066 return this.version == null ? null : this.version.getValue(); 1067 } 1068 1069 /** 1070 * @param value The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. 1071 */ 1072 public SearchParameter setVersion(String value) { 1073 if (Utilities.noString(value)) 1074 this.version = null; 1075 else { 1076 if (this.version == null) 1077 this.version = new StringType(); 1078 this.version.setValue(value); 1079 } 1080 return this; 1081 } 1082 1083 /** 1084 * @return {@link #name} (A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 1085 */ 1086 public StringType getNameElement() { 1087 if (this.name == null) 1088 if (Configuration.errorOnAutoCreate()) 1089 throw new Error("Attempt to auto-create SearchParameter.name"); 1090 else if (Configuration.doAutoCreate()) 1091 this.name = new StringType(); // bb 1092 return this.name; 1093 } 1094 1095 public boolean hasNameElement() { 1096 return this.name != null && !this.name.isEmpty(); 1097 } 1098 1099 public boolean hasName() { 1100 return this.name != null && !this.name.isEmpty(); 1101 } 1102 1103 /** 1104 * @param value {@link #name} (A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 1105 */ 1106 public SearchParameter setNameElement(StringType value) { 1107 this.name = value; 1108 return this; 1109 } 1110 1111 /** 1112 * @return A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation. 1113 */ 1114 public String getName() { 1115 return this.name == null ? null : this.name.getValue(); 1116 } 1117 1118 /** 1119 * @param value A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation. 1120 */ 1121 public SearchParameter setName(String value) { 1122 if (this.name == null) 1123 this.name = new StringType(); 1124 this.name.setValue(value); 1125 return this; 1126 } 1127 1128 /** 1129 * @return {@link #status} (The status of this search parameter. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 1130 */ 1131 public Enumeration<PublicationStatus> getStatusElement() { 1132 if (this.status == null) 1133 if (Configuration.errorOnAutoCreate()) 1134 throw new Error("Attempt to auto-create SearchParameter.status"); 1135 else if (Configuration.doAutoCreate()) 1136 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 1137 return this.status; 1138 } 1139 1140 public boolean hasStatusElement() { 1141 return this.status != null && !this.status.isEmpty(); 1142 } 1143 1144 public boolean hasStatus() { 1145 return this.status != null && !this.status.isEmpty(); 1146 } 1147 1148 /** 1149 * @param value {@link #status} (The status of this search parameter. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 1150 */ 1151 public SearchParameter setStatusElement(Enumeration<PublicationStatus> value) { 1152 this.status = value; 1153 return this; 1154 } 1155 1156 /** 1157 * @return The status of this search parameter. Enables tracking the life-cycle of the content. 1158 */ 1159 public PublicationStatus getStatus() { 1160 return this.status == null ? null : this.status.getValue(); 1161 } 1162 1163 /** 1164 * @param value The status of this search parameter. Enables tracking the life-cycle of the content. 1165 */ 1166 public SearchParameter setStatus(PublicationStatus value) { 1167 if (this.status == null) 1168 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 1169 this.status.setValue(value); 1170 return this; 1171 } 1172 1173 /** 1174 * @return {@link #experimental} (A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value 1175 */ 1176 public BooleanType getExperimentalElement() { 1177 if (this.experimental == null) 1178 if (Configuration.errorOnAutoCreate()) 1179 throw new Error("Attempt to auto-create SearchParameter.experimental"); 1180 else if (Configuration.doAutoCreate()) 1181 this.experimental = new BooleanType(); // bb 1182 return this.experimental; 1183 } 1184 1185 public boolean hasExperimentalElement() { 1186 return this.experimental != null && !this.experimental.isEmpty(); 1187 } 1188 1189 public boolean hasExperimental() { 1190 return this.experimental != null && !this.experimental.isEmpty(); 1191 } 1192 1193 /** 1194 * @param value {@link #experimental} (A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value 1195 */ 1196 public SearchParameter setExperimentalElement(BooleanType value) { 1197 this.experimental = value; 1198 return this; 1199 } 1200 1201 /** 1202 * @return A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage. 1203 */ 1204 public boolean getExperimental() { 1205 return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue(); 1206 } 1207 1208 /** 1209 * @param value A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage. 1210 */ 1211 public SearchParameter setExperimental(boolean value) { 1212 if (this.experimental == null) 1213 this.experimental = new BooleanType(); 1214 this.experimental.setValue(value); 1215 return this; 1216 } 1217 1218 /** 1219 * @return {@link #date} (The date (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 1220 */ 1221 public DateTimeType getDateElement() { 1222 if (this.date == null) 1223 if (Configuration.errorOnAutoCreate()) 1224 throw new Error("Attempt to auto-create SearchParameter.date"); 1225 else if (Configuration.doAutoCreate()) 1226 this.date = new DateTimeType(); // bb 1227 return this.date; 1228 } 1229 1230 public boolean hasDateElement() { 1231 return this.date != null && !this.date.isEmpty(); 1232 } 1233 1234 public boolean hasDate() { 1235 return this.date != null && !this.date.isEmpty(); 1236 } 1237 1238 /** 1239 * @param value {@link #date} (The date (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 1240 */ 1241 public SearchParameter setDateElement(DateTimeType value) { 1242 this.date = value; 1243 return this; 1244 } 1245 1246 /** 1247 * @return The date (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes. 1248 */ 1249 public Date getDate() { 1250 return this.date == null ? null : this.date.getValue(); 1251 } 1252 1253 /** 1254 * @param value The date (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes. 1255 */ 1256 public SearchParameter setDate(Date value) { 1257 if (value == null) 1258 this.date = null; 1259 else { 1260 if (this.date == null) 1261 this.date = new DateTimeType(); 1262 this.date.setValue(value); 1263 } 1264 return this; 1265 } 1266 1267 /** 1268 * @return {@link #publisher} (The name of the individual or organization that published the search parameter.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 1269 */ 1270 public StringType getPublisherElement() { 1271 if (this.publisher == null) 1272 if (Configuration.errorOnAutoCreate()) 1273 throw new Error("Attempt to auto-create SearchParameter.publisher"); 1274 else if (Configuration.doAutoCreate()) 1275 this.publisher = new StringType(); // bb 1276 return this.publisher; 1277 } 1278 1279 public boolean hasPublisherElement() { 1280 return this.publisher != null && !this.publisher.isEmpty(); 1281 } 1282 1283 public boolean hasPublisher() { 1284 return this.publisher != null && !this.publisher.isEmpty(); 1285 } 1286 1287 /** 1288 * @param value {@link #publisher} (The name of the individual or organization that published the search parameter.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 1289 */ 1290 public SearchParameter setPublisherElement(StringType value) { 1291 this.publisher = value; 1292 return this; 1293 } 1294 1295 /** 1296 * @return The name of the individual or organization that published the search parameter. 1297 */ 1298 public String getPublisher() { 1299 return this.publisher == null ? null : this.publisher.getValue(); 1300 } 1301 1302 /** 1303 * @param value The name of the individual or organization that published the search parameter. 1304 */ 1305 public SearchParameter setPublisher(String value) { 1306 if (Utilities.noString(value)) 1307 this.publisher = null; 1308 else { 1309 if (this.publisher == null) 1310 this.publisher = new StringType(); 1311 this.publisher.setValue(value); 1312 } 1313 return this; 1314 } 1315 1316 /** 1317 * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.) 1318 */ 1319 public List<ContactDetail> getContact() { 1320 if (this.contact == null) 1321 this.contact = new ArrayList<ContactDetail>(); 1322 return this.contact; 1323 } 1324 1325 /** 1326 * @return Returns a reference to <code>this</code> for easy method chaining 1327 */ 1328 public SearchParameter setContact(List<ContactDetail> theContact) { 1329 this.contact = theContact; 1330 return this; 1331 } 1332 1333 public boolean hasContact() { 1334 if (this.contact == null) 1335 return false; 1336 for (ContactDetail item : this.contact) 1337 if (!item.isEmpty()) 1338 return true; 1339 return false; 1340 } 1341 1342 public ContactDetail addContact() { //3 1343 ContactDetail t = new ContactDetail(); 1344 if (this.contact == null) 1345 this.contact = new ArrayList<ContactDetail>(); 1346 this.contact.add(t); 1347 return t; 1348 } 1349 1350 public SearchParameter addContact(ContactDetail t) { //3 1351 if (t == null) 1352 return this; 1353 if (this.contact == null) 1354 this.contact = new ArrayList<ContactDetail>(); 1355 this.contact.add(t); 1356 return this; 1357 } 1358 1359 /** 1360 * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist 1361 */ 1362 public ContactDetail getContactFirstRep() { 1363 if (getContact().isEmpty()) { 1364 addContact(); 1365 } 1366 return getContact().get(0); 1367 } 1368 1369 /** 1370 * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.) 1371 */ 1372 public List<UsageContext> getUseContext() { 1373 if (this.useContext == null) 1374 this.useContext = new ArrayList<UsageContext>(); 1375 return this.useContext; 1376 } 1377 1378 /** 1379 * @return Returns a reference to <code>this</code> for easy method chaining 1380 */ 1381 public SearchParameter setUseContext(List<UsageContext> theUseContext) { 1382 this.useContext = theUseContext; 1383 return this; 1384 } 1385 1386 public boolean hasUseContext() { 1387 if (this.useContext == null) 1388 return false; 1389 for (UsageContext item : this.useContext) 1390 if (!item.isEmpty()) 1391 return true; 1392 return false; 1393 } 1394 1395 public UsageContext addUseContext() { //3 1396 UsageContext t = new UsageContext(); 1397 if (this.useContext == null) 1398 this.useContext = new ArrayList<UsageContext>(); 1399 this.useContext.add(t); 1400 return t; 1401 } 1402 1403 public SearchParameter addUseContext(UsageContext t) { //3 1404 if (t == null) 1405 return this; 1406 if (this.useContext == null) 1407 this.useContext = new ArrayList<UsageContext>(); 1408 this.useContext.add(t); 1409 return this; 1410 } 1411 1412 /** 1413 * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist 1414 */ 1415 public UsageContext getUseContextFirstRep() { 1416 if (getUseContext().isEmpty()) { 1417 addUseContext(); 1418 } 1419 return getUseContext().get(0); 1420 } 1421 1422 /** 1423 * @return {@link #jurisdiction} (A legal or geographic region in which the search parameter is intended to be used.) 1424 */ 1425 public List<CodeableConcept> getJurisdiction() { 1426 if (this.jurisdiction == null) 1427 this.jurisdiction = new ArrayList<CodeableConcept>(); 1428 return this.jurisdiction; 1429 } 1430 1431 /** 1432 * @return Returns a reference to <code>this</code> for easy method chaining 1433 */ 1434 public SearchParameter setJurisdiction(List<CodeableConcept> theJurisdiction) { 1435 this.jurisdiction = theJurisdiction; 1436 return this; 1437 } 1438 1439 public boolean hasJurisdiction() { 1440 if (this.jurisdiction == null) 1441 return false; 1442 for (CodeableConcept item : this.jurisdiction) 1443 if (!item.isEmpty()) 1444 return true; 1445 return false; 1446 } 1447 1448 public CodeableConcept addJurisdiction() { //3 1449 CodeableConcept t = new CodeableConcept(); 1450 if (this.jurisdiction == null) 1451 this.jurisdiction = new ArrayList<CodeableConcept>(); 1452 this.jurisdiction.add(t); 1453 return t; 1454 } 1455 1456 public SearchParameter addJurisdiction(CodeableConcept t) { //3 1457 if (t == null) 1458 return this; 1459 if (this.jurisdiction == null) 1460 this.jurisdiction = new ArrayList<CodeableConcept>(); 1461 this.jurisdiction.add(t); 1462 return this; 1463 } 1464 1465 /** 1466 * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist 1467 */ 1468 public CodeableConcept getJurisdictionFirstRep() { 1469 if (getJurisdiction().isEmpty()) { 1470 addJurisdiction(); 1471 } 1472 return getJurisdiction().get(0); 1473 } 1474 1475 /** 1476 * @return {@link #purpose} (Explaination of why this search parameter is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 1477 */ 1478 public MarkdownType getPurposeElement() { 1479 if (this.purpose == null) 1480 if (Configuration.errorOnAutoCreate()) 1481 throw new Error("Attempt to auto-create SearchParameter.purpose"); 1482 else if (Configuration.doAutoCreate()) 1483 this.purpose = new MarkdownType(); // bb 1484 return this.purpose; 1485 } 1486 1487 public boolean hasPurposeElement() { 1488 return this.purpose != null && !this.purpose.isEmpty(); 1489 } 1490 1491 public boolean hasPurpose() { 1492 return this.purpose != null && !this.purpose.isEmpty(); 1493 } 1494 1495 /** 1496 * @param value {@link #purpose} (Explaination of why this search parameter is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 1497 */ 1498 public SearchParameter setPurposeElement(MarkdownType value) { 1499 this.purpose = value; 1500 return this; 1501 } 1502 1503 /** 1504 * @return Explaination of why this search parameter is needed and why it has been designed as it has. 1505 */ 1506 public String getPurpose() { 1507 return this.purpose == null ? null : this.purpose.getValue(); 1508 } 1509 1510 /** 1511 * @param value Explaination of why this search parameter is needed and why it has been designed as it has. 1512 */ 1513 public SearchParameter setPurpose(String value) { 1514 if (value == null) 1515 this.purpose = null; 1516 else { 1517 if (this.purpose == null) 1518 this.purpose = new MarkdownType(); 1519 this.purpose.setValue(value); 1520 } 1521 return this; 1522 } 1523 1524 /** 1525 * @return {@link #code} (The code used in the URL or the parameter name in a parameters resource for this search parameter.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 1526 */ 1527 public CodeType getCodeElement() { 1528 if (this.code == null) 1529 if (Configuration.errorOnAutoCreate()) 1530 throw new Error("Attempt to auto-create SearchParameter.code"); 1531 else if (Configuration.doAutoCreate()) 1532 this.code = new CodeType(); // bb 1533 return this.code; 1534 } 1535 1536 public boolean hasCodeElement() { 1537 return this.code != null && !this.code.isEmpty(); 1538 } 1539 1540 public boolean hasCode() { 1541 return this.code != null && !this.code.isEmpty(); 1542 } 1543 1544 /** 1545 * @param value {@link #code} (The code used in the URL or the parameter name in a parameters resource for this search parameter.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 1546 */ 1547 public SearchParameter setCodeElement(CodeType value) { 1548 this.code = value; 1549 return this; 1550 } 1551 1552 /** 1553 * @return The code used in the URL or the parameter name in a parameters resource for this search parameter. 1554 */ 1555 public String getCode() { 1556 return this.code == null ? null : this.code.getValue(); 1557 } 1558 1559 /** 1560 * @param value The code used in the URL or the parameter name in a parameters resource for this search parameter. 1561 */ 1562 public SearchParameter setCode(String value) { 1563 if (this.code == null) 1564 this.code = new CodeType(); 1565 this.code.setValue(value); 1566 return this; 1567 } 1568 1569 /** 1570 * @return {@link #base} (The base resource type(s) that this search parameter can be used against.) 1571 */ 1572 public List<CodeType> getBase() { 1573 if (this.base == null) 1574 this.base = new ArrayList<CodeType>(); 1575 return this.base; 1576 } 1577 1578 /** 1579 * @return Returns a reference to <code>this</code> for easy method chaining 1580 */ 1581 public SearchParameter setBase(List<CodeType> theBase) { 1582 this.base = theBase; 1583 return this; 1584 } 1585 1586 public boolean hasBase() { 1587 if (this.base == null) 1588 return false; 1589 for (CodeType item : this.base) 1590 if (!item.isEmpty()) 1591 return true; 1592 return false; 1593 } 1594 1595 /** 1596 * @return {@link #base} (The base resource type(s) that this search parameter can be used against.) 1597 */ 1598 public CodeType addBaseElement() {//2 1599 CodeType t = new CodeType(); 1600 if (this.base == null) 1601 this.base = new ArrayList<CodeType>(); 1602 this.base.add(t); 1603 return t; 1604 } 1605 1606 /** 1607 * @param value {@link #base} (The base resource type(s) that this search parameter can be used against.) 1608 */ 1609 public SearchParameter addBase(String value) { //1 1610 CodeType t = new CodeType(); 1611 t.setValue(value); 1612 if (this.base == null) 1613 this.base = new ArrayList<CodeType>(); 1614 this.base.add(t); 1615 return this; 1616 } 1617 1618 /** 1619 * @param value {@link #base} (The base resource type(s) that this search parameter can be used against.) 1620 */ 1621 public boolean hasBase(String value) { 1622 if (this.base == null) 1623 return false; 1624 for (CodeType v : this.base) 1625 if (v.getValue().equals(value)) // code 1626 return true; 1627 return false; 1628 } 1629 1630 /** 1631 * @return {@link #type} (The type of value a search parameter refers to, and how the content is interpreted.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1632 */ 1633 public Enumeration<SearchParamType> getTypeElement() { 1634 if (this.type == null) 1635 if (Configuration.errorOnAutoCreate()) 1636 throw new Error("Attempt to auto-create SearchParameter.type"); 1637 else if (Configuration.doAutoCreate()) 1638 this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); // bb 1639 return this.type; 1640 } 1641 1642 public boolean hasTypeElement() { 1643 return this.type != null && !this.type.isEmpty(); 1644 } 1645 1646 public boolean hasType() { 1647 return this.type != null && !this.type.isEmpty(); 1648 } 1649 1650 /** 1651 * @param value {@link #type} (The type of value a search parameter refers to, and how the content is interpreted.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1652 */ 1653 public SearchParameter setTypeElement(Enumeration<SearchParamType> value) { 1654 this.type = value; 1655 return this; 1656 } 1657 1658 /** 1659 * @return The type of value a search parameter refers to, and how the content is interpreted. 1660 */ 1661 public SearchParamType getType() { 1662 return this.type == null ? null : this.type.getValue(); 1663 } 1664 1665 /** 1666 * @param value The type of value a search parameter refers to, and how the content is interpreted. 1667 */ 1668 public SearchParameter setType(SearchParamType value) { 1669 if (this.type == null) 1670 this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); 1671 this.type.setValue(value); 1672 return this; 1673 } 1674 1675 /** 1676 * @return {@link #derivedFrom} (Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.). This is the underlying object with id, value and extensions. The accessor "getDerivedFrom" gives direct access to the value 1677 */ 1678 public UriType getDerivedFromElement() { 1679 if (this.derivedFrom == null) 1680 if (Configuration.errorOnAutoCreate()) 1681 throw new Error("Attempt to auto-create SearchParameter.derivedFrom"); 1682 else if (Configuration.doAutoCreate()) 1683 this.derivedFrom = new UriType(); // bb 1684 return this.derivedFrom; 1685 } 1686 1687 public boolean hasDerivedFromElement() { 1688 return this.derivedFrom != null && !this.derivedFrom.isEmpty(); 1689 } 1690 1691 public boolean hasDerivedFrom() { 1692 return this.derivedFrom != null && !this.derivedFrom.isEmpty(); 1693 } 1694 1695 /** 1696 * @param value {@link #derivedFrom} (Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.). This is the underlying object with id, value and extensions. The accessor "getDerivedFrom" gives direct access to the value 1697 */ 1698 public SearchParameter setDerivedFromElement(UriType value) { 1699 this.derivedFrom = value; 1700 return this; 1701 } 1702 1703 /** 1704 * @return Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter. 1705 */ 1706 public String getDerivedFrom() { 1707 return this.derivedFrom == null ? null : this.derivedFrom.getValue(); 1708 } 1709 1710 /** 1711 * @param value Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter. 1712 */ 1713 public SearchParameter setDerivedFrom(String value) { 1714 if (Utilities.noString(value)) 1715 this.derivedFrom = null; 1716 else { 1717 if (this.derivedFrom == null) 1718 this.derivedFrom = new UriType(); 1719 this.derivedFrom.setValue(value); 1720 } 1721 return this; 1722 } 1723 1724 /** 1725 * @return {@link #description} (A free text natural language description of the search parameter from a consumer's perspective. and how it used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1726 */ 1727 public MarkdownType getDescriptionElement() { 1728 if (this.description == null) 1729 if (Configuration.errorOnAutoCreate()) 1730 throw new Error("Attempt to auto-create SearchParameter.description"); 1731 else if (Configuration.doAutoCreate()) 1732 this.description = new MarkdownType(); // bb 1733 return this.description; 1734 } 1735 1736 public boolean hasDescriptionElement() { 1737 return this.description != null && !this.description.isEmpty(); 1738 } 1739 1740 public boolean hasDescription() { 1741 return this.description != null && !this.description.isEmpty(); 1742 } 1743 1744 /** 1745 * @param value {@link #description} (A free text natural language description of the search parameter from a consumer's perspective. and how it used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1746 */ 1747 public SearchParameter setDescriptionElement(MarkdownType value) { 1748 this.description = value; 1749 return this; 1750 } 1751 1752 /** 1753 * @return A free text natural language description of the search parameter from a consumer's perspective. and how it used. 1754 */ 1755 public String getDescription() { 1756 return this.description == null ? null : this.description.getValue(); 1757 } 1758 1759 /** 1760 * @param value A free text natural language description of the search parameter from a consumer's perspective. and how it used. 1761 */ 1762 public SearchParameter setDescription(String value) { 1763 if (this.description == null) 1764 this.description = new MarkdownType(); 1765 this.description.setValue(value); 1766 return this; 1767 } 1768 1769 /** 1770 * @return {@link #expression} (A FHIRPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value 1771 */ 1772 public StringType getExpressionElement() { 1773 if (this.expression == null) 1774 if (Configuration.errorOnAutoCreate()) 1775 throw new Error("Attempt to auto-create SearchParameter.expression"); 1776 else if (Configuration.doAutoCreate()) 1777 this.expression = new StringType(); // bb 1778 return this.expression; 1779 } 1780 1781 public boolean hasExpressionElement() { 1782 return this.expression != null && !this.expression.isEmpty(); 1783 } 1784 1785 public boolean hasExpression() { 1786 return this.expression != null && !this.expression.isEmpty(); 1787 } 1788 1789 /** 1790 * @param value {@link #expression} (A FHIRPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value 1791 */ 1792 public SearchParameter setExpressionElement(StringType value) { 1793 this.expression = value; 1794 return this; 1795 } 1796 1797 /** 1798 * @return A FHIRPath expression that returns a set of elements for the search parameter. 1799 */ 1800 public String getExpression() { 1801 return this.expression == null ? null : this.expression.getValue(); 1802 } 1803 1804 /** 1805 * @param value A FHIRPath expression that returns a set of elements for the search parameter. 1806 */ 1807 public SearchParameter setExpression(String value) { 1808 if (Utilities.noString(value)) 1809 this.expression = null; 1810 else { 1811 if (this.expression == null) 1812 this.expression = new StringType(); 1813 this.expression.setValue(value); 1814 } 1815 return this; 1816 } 1817 1818 /** 1819 * @return {@link #xpath} (An XPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getXpath" gives direct access to the value 1820 */ 1821 public StringType getXpathElement() { 1822 if (this.xpath == null) 1823 if (Configuration.errorOnAutoCreate()) 1824 throw new Error("Attempt to auto-create SearchParameter.xpath"); 1825 else if (Configuration.doAutoCreate()) 1826 this.xpath = new StringType(); // bb 1827 return this.xpath; 1828 } 1829 1830 public boolean hasXpathElement() { 1831 return this.xpath != null && !this.xpath.isEmpty(); 1832 } 1833 1834 public boolean hasXpath() { 1835 return this.xpath != null && !this.xpath.isEmpty(); 1836 } 1837 1838 /** 1839 * @param value {@link #xpath} (An XPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getXpath" gives direct access to the value 1840 */ 1841 public SearchParameter setXpathElement(StringType value) { 1842 this.xpath = value; 1843 return this; 1844 } 1845 1846 /** 1847 * @return An XPath expression that returns a set of elements for the search parameter. 1848 */ 1849 public String getXpath() { 1850 return this.xpath == null ? null : this.xpath.getValue(); 1851 } 1852 1853 /** 1854 * @param value An XPath expression that returns a set of elements for the search parameter. 1855 */ 1856 public SearchParameter setXpath(String value) { 1857 if (Utilities.noString(value)) 1858 this.xpath = null; 1859 else { 1860 if (this.xpath == null) 1861 this.xpath = new StringType(); 1862 this.xpath.setValue(value); 1863 } 1864 return this; 1865 } 1866 1867 /** 1868 * @return {@link #xpathUsage} (How the search parameter relates to the set of elements returned by evaluating the xpath query.). This is the underlying object with id, value and extensions. The accessor "getXpathUsage" gives direct access to the value 1869 */ 1870 public Enumeration<XPathUsageType> getXpathUsageElement() { 1871 if (this.xpathUsage == null) 1872 if (Configuration.errorOnAutoCreate()) 1873 throw new Error("Attempt to auto-create SearchParameter.xpathUsage"); 1874 else if (Configuration.doAutoCreate()) 1875 this.xpathUsage = new Enumeration<XPathUsageType>(new XPathUsageTypeEnumFactory()); // bb 1876 return this.xpathUsage; 1877 } 1878 1879 public boolean hasXpathUsageElement() { 1880 return this.xpathUsage != null && !this.xpathUsage.isEmpty(); 1881 } 1882 1883 public boolean hasXpathUsage() { 1884 return this.xpathUsage != null && !this.xpathUsage.isEmpty(); 1885 } 1886 1887 /** 1888 * @param value {@link #xpathUsage} (How the search parameter relates to the set of elements returned by evaluating the xpath query.). This is the underlying object with id, value and extensions. The accessor "getXpathUsage" gives direct access to the value 1889 */ 1890 public SearchParameter setXpathUsageElement(Enumeration<XPathUsageType> value) { 1891 this.xpathUsage = value; 1892 return this; 1893 } 1894 1895 /** 1896 * @return How the search parameter relates to the set of elements returned by evaluating the xpath query. 1897 */ 1898 public XPathUsageType getXpathUsage() { 1899 return this.xpathUsage == null ? null : this.xpathUsage.getValue(); 1900 } 1901 1902 /** 1903 * @param value How the search parameter relates to the set of elements returned by evaluating the xpath query. 1904 */ 1905 public SearchParameter setXpathUsage(XPathUsageType value) { 1906 if (value == null) 1907 this.xpathUsage = null; 1908 else { 1909 if (this.xpathUsage == null) 1910 this.xpathUsage = new Enumeration<XPathUsageType>(new XPathUsageTypeEnumFactory()); 1911 this.xpathUsage.setValue(value); 1912 } 1913 return this; 1914 } 1915 1916 /** 1917 * @return {@link #target} (Types of resource (if a resource is referenced).) 1918 */ 1919 public List<CodeType> getTarget() { 1920 if (this.target == null) 1921 this.target = new ArrayList<CodeType>(); 1922 return this.target; 1923 } 1924 1925 /** 1926 * @return Returns a reference to <code>this</code> for easy method chaining 1927 */ 1928 public SearchParameter setTarget(List<CodeType> theTarget) { 1929 this.target = theTarget; 1930 return this; 1931 } 1932 1933 public boolean hasTarget() { 1934 if (this.target == null) 1935 return false; 1936 for (CodeType item : this.target) 1937 if (!item.isEmpty()) 1938 return true; 1939 return false; 1940 } 1941 1942 /** 1943 * @return {@link #target} (Types of resource (if a resource is referenced).) 1944 */ 1945 public CodeType addTargetElement() {//2 1946 CodeType t = new CodeType(); 1947 if (this.target == null) 1948 this.target = new ArrayList<CodeType>(); 1949 this.target.add(t); 1950 return t; 1951 } 1952 1953 /** 1954 * @param value {@link #target} (Types of resource (if a resource is referenced).) 1955 */ 1956 public SearchParameter addTarget(String value) { //1 1957 CodeType t = new CodeType(); 1958 t.setValue(value); 1959 if (this.target == null) 1960 this.target = new ArrayList<CodeType>(); 1961 this.target.add(t); 1962 return this; 1963 } 1964 1965 /** 1966 * @param value {@link #target} (Types of resource (if a resource is referenced).) 1967 */ 1968 public boolean hasTarget(String value) { 1969 if (this.target == null) 1970 return false; 1971 for (CodeType v : this.target) 1972 if (v.getValue().equals(value)) // code 1973 return true; 1974 return false; 1975 } 1976 1977 /** 1978 * @return {@link #comparator} (Comparators supported for the search parameter.) 1979 */ 1980 public List<Enumeration<SearchComparator>> getComparator() { 1981 if (this.comparator == null) 1982 this.comparator = new ArrayList<Enumeration<SearchComparator>>(); 1983 return this.comparator; 1984 } 1985 1986 /** 1987 * @return Returns a reference to <code>this</code> for easy method chaining 1988 */ 1989 public SearchParameter setComparator(List<Enumeration<SearchComparator>> theComparator) { 1990 this.comparator = theComparator; 1991 return this; 1992 } 1993 1994 public boolean hasComparator() { 1995 if (this.comparator == null) 1996 return false; 1997 for (Enumeration<SearchComparator> item : this.comparator) 1998 if (!item.isEmpty()) 1999 return true; 2000 return false; 2001 } 2002 2003 /** 2004 * @return {@link #comparator} (Comparators supported for the search parameter.) 2005 */ 2006 public Enumeration<SearchComparator> addComparatorElement() {//2 2007 Enumeration<SearchComparator> t = new Enumeration<SearchComparator>(new SearchComparatorEnumFactory()); 2008 if (this.comparator == null) 2009 this.comparator = new ArrayList<Enumeration<SearchComparator>>(); 2010 this.comparator.add(t); 2011 return t; 2012 } 2013 2014 /** 2015 * @param value {@link #comparator} (Comparators supported for the search parameter.) 2016 */ 2017 public SearchParameter addComparator(SearchComparator value) { //1 2018 Enumeration<SearchComparator> t = new Enumeration<SearchComparator>(new SearchComparatorEnumFactory()); 2019 t.setValue(value); 2020 if (this.comparator == null) 2021 this.comparator = new ArrayList<Enumeration<SearchComparator>>(); 2022 this.comparator.add(t); 2023 return this; 2024 } 2025 2026 /** 2027 * @param value {@link #comparator} (Comparators supported for the search parameter.) 2028 */ 2029 public boolean hasComparator(SearchComparator value) { 2030 if (this.comparator == null) 2031 return false; 2032 for (Enumeration<SearchComparator> v : this.comparator) 2033 if (v.getValue().equals(value)) // code 2034 return true; 2035 return false; 2036 } 2037 2038 /** 2039 * @return {@link #modifier} (A modifier supported for the search parameter.) 2040 */ 2041 public List<Enumeration<SearchModifierCode>> getModifier() { 2042 if (this.modifier == null) 2043 this.modifier = new ArrayList<Enumeration<SearchModifierCode>>(); 2044 return this.modifier; 2045 } 2046 2047 /** 2048 * @return Returns a reference to <code>this</code> for easy method chaining 2049 */ 2050 public SearchParameter setModifier(List<Enumeration<SearchModifierCode>> theModifier) { 2051 this.modifier = theModifier; 2052 return this; 2053 } 2054 2055 public boolean hasModifier() { 2056 if (this.modifier == null) 2057 return false; 2058 for (Enumeration<SearchModifierCode> item : this.modifier) 2059 if (!item.isEmpty()) 2060 return true; 2061 return false; 2062 } 2063 2064 /** 2065 * @return {@link #modifier} (A modifier supported for the search parameter.) 2066 */ 2067 public Enumeration<SearchModifierCode> addModifierElement() {//2 2068 Enumeration<SearchModifierCode> t = new Enumeration<SearchModifierCode>(new SearchModifierCodeEnumFactory()); 2069 if (this.modifier == null) 2070 this.modifier = new ArrayList<Enumeration<SearchModifierCode>>(); 2071 this.modifier.add(t); 2072 return t; 2073 } 2074 2075 /** 2076 * @param value {@link #modifier} (A modifier supported for the search parameter.) 2077 */ 2078 public SearchParameter addModifier(SearchModifierCode value) { //1 2079 Enumeration<SearchModifierCode> t = new Enumeration<SearchModifierCode>(new SearchModifierCodeEnumFactory()); 2080 t.setValue(value); 2081 if (this.modifier == null) 2082 this.modifier = new ArrayList<Enumeration<SearchModifierCode>>(); 2083 this.modifier.add(t); 2084 return this; 2085 } 2086 2087 /** 2088 * @param value {@link #modifier} (A modifier supported for the search parameter.) 2089 */ 2090 public boolean hasModifier(SearchModifierCode value) { 2091 if (this.modifier == null) 2092 return false; 2093 for (Enumeration<SearchModifierCode> v : this.modifier) 2094 if (v.getValue().equals(value)) // code 2095 return true; 2096 return false; 2097 } 2098 2099 /** 2100 * @return {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.) 2101 */ 2102 public List<StringType> getChain() { 2103 if (this.chain == null) 2104 this.chain = new ArrayList<StringType>(); 2105 return this.chain; 2106 } 2107 2108 /** 2109 * @return Returns a reference to <code>this</code> for easy method chaining 2110 */ 2111 public SearchParameter setChain(List<StringType> theChain) { 2112 this.chain = theChain; 2113 return this; 2114 } 2115 2116 public boolean hasChain() { 2117 if (this.chain == null) 2118 return false; 2119 for (StringType item : this.chain) 2120 if (!item.isEmpty()) 2121 return true; 2122 return false; 2123 } 2124 2125 /** 2126 * @return {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.) 2127 */ 2128 public StringType addChainElement() {//2 2129 StringType t = new StringType(); 2130 if (this.chain == null) 2131 this.chain = new ArrayList<StringType>(); 2132 this.chain.add(t); 2133 return t; 2134 } 2135 2136 /** 2137 * @param value {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.) 2138 */ 2139 public SearchParameter addChain(String value) { //1 2140 StringType t = new StringType(); 2141 t.setValue(value); 2142 if (this.chain == null) 2143 this.chain = new ArrayList<StringType>(); 2144 this.chain.add(t); 2145 return this; 2146 } 2147 2148 /** 2149 * @param value {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.) 2150 */ 2151 public boolean hasChain(String value) { 2152 if (this.chain == null) 2153 return false; 2154 for (StringType v : this.chain) 2155 if (v.getValue().equals(value)) // string 2156 return true; 2157 return false; 2158 } 2159 2160 /** 2161 * @return {@link #component} (Used to define the parts of a composite search parameter.) 2162 */ 2163 public List<SearchParameterComponentComponent> getComponent() { 2164 if (this.component == null) 2165 this.component = new ArrayList<SearchParameterComponentComponent>(); 2166 return this.component; 2167 } 2168 2169 /** 2170 * @return Returns a reference to <code>this</code> for easy method chaining 2171 */ 2172 public SearchParameter setComponent(List<SearchParameterComponentComponent> theComponent) { 2173 this.component = theComponent; 2174 return this; 2175 } 2176 2177 public boolean hasComponent() { 2178 if (this.component == null) 2179 return false; 2180 for (SearchParameterComponentComponent item : this.component) 2181 if (!item.isEmpty()) 2182 return true; 2183 return false; 2184 } 2185 2186 public SearchParameterComponentComponent addComponent() { //3 2187 SearchParameterComponentComponent t = new SearchParameterComponentComponent(); 2188 if (this.component == null) 2189 this.component = new ArrayList<SearchParameterComponentComponent>(); 2190 this.component.add(t); 2191 return t; 2192 } 2193 2194 public SearchParameter addComponent(SearchParameterComponentComponent t) { //3 2195 if (t == null) 2196 return this; 2197 if (this.component == null) 2198 this.component = new ArrayList<SearchParameterComponentComponent>(); 2199 this.component.add(t); 2200 return this; 2201 } 2202 2203 /** 2204 * @return The first repetition of repeating field {@link #component}, creating it if it does not already exist 2205 */ 2206 public SearchParameterComponentComponent getComponentFirstRep() { 2207 if (getComponent().isEmpty()) { 2208 addComponent(); 2209 } 2210 return getComponent().get(0); 2211 } 2212 2213 protected void listChildren(List<Property> children) { 2214 super.listChildren(children); 2215 children.add(new Property("url", "uri", "An absolute URI that is used to identify this search parameter 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 search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url)); 2216 children.add(new Property("version", "string", "The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version)); 2217 children.add(new Property("name", "string", "A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name)); 2218 children.add(new Property("status", "code", "The status of this search parameter. Enables tracking the life-cycle of the content.", 0, 1, status)); 2219 children.add(new Property("experimental", "boolean", "A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental)); 2220 children.add(new Property("date", "dateTime", "The date (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.", 0, 1, date)); 2221 children.add(new Property("publisher", "string", "The name of the individual or organization that published the search parameter.", 0, 1, publisher)); 2222 children.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact)); 2223 children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.", 0, java.lang.Integer.MAX_VALUE, useContext)); 2224 children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the search parameter is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction)); 2225 children.add(new Property("purpose", "markdown", "Explaination of why this search parameter is needed and why it has been designed as it has.", 0, 1, purpose)); 2226 children.add(new Property("code", "code", "The code used in the URL or the parameter name in a parameters resource for this search parameter.", 0, 1, code)); 2227 children.add(new Property("base", "code", "The base resource type(s) that this search parameter can be used against.", 0, java.lang.Integer.MAX_VALUE, base)); 2228 children.add(new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type)); 2229 children.add(new Property("derivedFrom", "uri", "Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.", 0, 1, derivedFrom)); 2230 children.add(new Property("description", "markdown", "A free text natural language description of the search parameter from a consumer's perspective. and how it used.", 0, 1, description)); 2231 children.add(new Property("expression", "string", "A FHIRPath expression that returns a set of elements for the search parameter.", 0, 1, expression)); 2232 children.add(new Property("xpath", "string", "An XPath expression that returns a set of elements for the search parameter.", 0, 1, xpath)); 2233 children.add(new Property("xpathUsage", "code", "How the search parameter relates to the set of elements returned by evaluating the xpath query.", 0, 1, xpathUsage)); 2234 children.add(new Property("target", "code", "Types of resource (if a resource is referenced).", 0, java.lang.Integer.MAX_VALUE, target)); 2235 children.add(new Property("comparator", "code", "Comparators supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, comparator)); 2236 children.add(new Property("modifier", "code", "A modifier supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, modifier)); 2237 children.add(new Property("chain", "string", "Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.", 0, java.lang.Integer.MAX_VALUE, chain)); 2238 children.add(new Property("component", "", "Used to define the parts of a composite search parameter.", 0, java.lang.Integer.MAX_VALUE, component)); 2239 } 2240 2241 @Override 2242 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2243 switch (_hash) { 2244 case 116079: /*url*/ return new Property("url", "uri", "An absolute URI that is used to identify this search parameter 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 search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url); 2245 case 351608024: /*version*/ return new Property("version", "string", "The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version); 2246 case 3373707: /*name*/ return new Property("name", "string", "A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name); 2247 case -892481550: /*status*/ return new Property("status", "code", "The status of this search parameter. Enables tracking the life-cycle of the content.", 0, 1, status); 2248 case -404562712: /*experimental*/ return new Property("experimental", "boolean", "A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental); 2249 case 3076014: /*date*/ return new Property("date", "dateTime", "The date (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.", 0, 1, date); 2250 case 1447404028: /*publisher*/ return new Property("publisher", "string", "The name of the individual or organization that published the search parameter.", 0, 1, publisher); 2251 case 951526432: /*contact*/ return new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact); 2252 case -669707736: /*useContext*/ return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.", 0, java.lang.Integer.MAX_VALUE, useContext); 2253 case -507075711: /*jurisdiction*/ return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the search parameter is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction); 2254 case -220463842: /*purpose*/ return new Property("purpose", "markdown", "Explaination of why this search parameter is needed and why it has been designed as it has.", 0, 1, purpose); 2255 case 3059181: /*code*/ return new Property("code", "code", "The code used in the URL or the parameter name in a parameters resource for this search parameter.", 0, 1, code); 2256 case 3016401: /*base*/ return new Property("base", "code", "The base resource type(s) that this search parameter can be used against.", 0, java.lang.Integer.MAX_VALUE, base); 2257 case 3575610: /*type*/ return new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type); 2258 case 1077922663: /*derivedFrom*/ return new Property("derivedFrom", "uri", "Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.", 0, 1, derivedFrom); 2259 case -1724546052: /*description*/ return new Property("description", "markdown", "A free text natural language description of the search parameter from a consumer's perspective. and how it used.", 0, 1, description); 2260 case -1795452264: /*expression*/ return new Property("expression", "string", "A FHIRPath expression that returns a set of elements for the search parameter.", 0, 1, expression); 2261 case 114256029: /*xpath*/ return new Property("xpath", "string", "An XPath expression that returns a set of elements for the search parameter.", 0, 1, xpath); 2262 case 1801322244: /*xpathUsage*/ return new Property("xpathUsage", "code", "How the search parameter relates to the set of elements returned by evaluating the xpath query.", 0, 1, xpathUsage); 2263 case -880905839: /*target*/ return new Property("target", "code", "Types of resource (if a resource is referenced).", 0, java.lang.Integer.MAX_VALUE, target); 2264 case -844673834: /*comparator*/ return new Property("comparator", "code", "Comparators supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, comparator); 2265 case -615513385: /*modifier*/ return new Property("modifier", "code", "A modifier supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, modifier); 2266 case 94623425: /*chain*/ return new Property("chain", "string", "Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.", 0, java.lang.Integer.MAX_VALUE, chain); 2267 case -1399907075: /*component*/ return new Property("component", "", "Used to define the parts of a composite search parameter.", 0, java.lang.Integer.MAX_VALUE, component); 2268 default: return super.getNamedProperty(_hash, _name, _checkValid); 2269 } 2270 2271 } 2272 2273 @Override 2274 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2275 switch (hash) { 2276 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType 2277 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 2278 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 2279 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus> 2280 case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType 2281 case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType 2282 case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType 2283 case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 2284 case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 2285 case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 2286 case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType 2287 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType 2288 case 3016401: /*base*/ return this.base == null ? new Base[0] : this.base.toArray(new Base[this.base.size()]); // CodeType 2289 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SearchParamType> 2290 case 1077922663: /*derivedFrom*/ return this.derivedFrom == null ? new Base[0] : new Base[] {this.derivedFrom}; // UriType 2291 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 2292 case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType 2293 case 114256029: /*xpath*/ return this.xpath == null ? new Base[0] : new Base[] {this.xpath}; // StringType 2294 case 1801322244: /*xpathUsage*/ return this.xpathUsage == null ? new Base[0] : new Base[] {this.xpathUsage}; // Enumeration<XPathUsageType> 2295 case -880905839: /*target*/ return this.target == null ? new Base[0] : this.target.toArray(new Base[this.target.size()]); // CodeType 2296 case -844673834: /*comparator*/ return this.comparator == null ? new Base[0] : this.comparator.toArray(new Base[this.comparator.size()]); // Enumeration<SearchComparator> 2297 case -615513385: /*modifier*/ return this.modifier == null ? new Base[0] : this.modifier.toArray(new Base[this.modifier.size()]); // Enumeration<SearchModifierCode> 2298 case 94623425: /*chain*/ return this.chain == null ? new Base[0] : this.chain.toArray(new Base[this.chain.size()]); // StringType 2299 case -1399907075: /*component*/ return this.component == null ? new Base[0] : this.component.toArray(new Base[this.component.size()]); // SearchParameterComponentComponent 2300 default: return super.getProperty(hash, name, checkValid); 2301 } 2302 2303 } 2304 2305 @Override 2306 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2307 switch (hash) { 2308 case 116079: // url 2309 this.url = castToUri(value); // UriType 2310 return value; 2311 case 351608024: // version 2312 this.version = castToString(value); // StringType 2313 return value; 2314 case 3373707: // name 2315 this.name = castToString(value); // StringType 2316 return value; 2317 case -892481550: // status 2318 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 2319 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 2320 return value; 2321 case -404562712: // experimental 2322 this.experimental = castToBoolean(value); // BooleanType 2323 return value; 2324 case 3076014: // date 2325 this.date = castToDateTime(value); // DateTimeType 2326 return value; 2327 case 1447404028: // publisher 2328 this.publisher = castToString(value); // StringType 2329 return value; 2330 case 951526432: // contact 2331 this.getContact().add(castToContactDetail(value)); // ContactDetail 2332 return value; 2333 case -669707736: // useContext 2334 this.getUseContext().add(castToUsageContext(value)); // UsageContext 2335 return value; 2336 case -507075711: // jurisdiction 2337 this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept 2338 return value; 2339 case -220463842: // purpose 2340 this.purpose = castToMarkdown(value); // MarkdownType 2341 return value; 2342 case 3059181: // code 2343 this.code = castToCode(value); // CodeType 2344 return value; 2345 case 3016401: // base 2346 this.getBase().add(castToCode(value)); // CodeType 2347 return value; 2348 case 3575610: // type 2349 value = new SearchParamTypeEnumFactory().fromType(castToCode(value)); 2350 this.type = (Enumeration) value; // Enumeration<SearchParamType> 2351 return value; 2352 case 1077922663: // derivedFrom 2353 this.derivedFrom = castToUri(value); // UriType 2354 return value; 2355 case -1724546052: // description 2356 this.description = castToMarkdown(value); // MarkdownType 2357 return value; 2358 case -1795452264: // expression 2359 this.expression = castToString(value); // StringType 2360 return value; 2361 case 114256029: // xpath 2362 this.xpath = castToString(value); // StringType 2363 return value; 2364 case 1801322244: // xpathUsage 2365 value = new XPathUsageTypeEnumFactory().fromType(castToCode(value)); 2366 this.xpathUsage = (Enumeration) value; // Enumeration<XPathUsageType> 2367 return value; 2368 case -880905839: // target 2369 this.getTarget().add(castToCode(value)); // CodeType 2370 return value; 2371 case -844673834: // comparator 2372 value = new SearchComparatorEnumFactory().fromType(castToCode(value)); 2373 this.getComparator().add((Enumeration) value); // Enumeration<SearchComparator> 2374 return value; 2375 case -615513385: // modifier 2376 value = new SearchModifierCodeEnumFactory().fromType(castToCode(value)); 2377 this.getModifier().add((Enumeration) value); // Enumeration<SearchModifierCode> 2378 return value; 2379 case 94623425: // chain 2380 this.getChain().add(castToString(value)); // StringType 2381 return value; 2382 case -1399907075: // component 2383 this.getComponent().add((SearchParameterComponentComponent) value); // SearchParameterComponentComponent 2384 return value; 2385 default: return super.setProperty(hash, name, value); 2386 } 2387 2388 } 2389 2390 @Override 2391 public Base setProperty(String name, Base value) throws FHIRException { 2392 if (name.equals("url")) { 2393 this.url = castToUri(value); // UriType 2394 } else if (name.equals("version")) { 2395 this.version = castToString(value); // StringType 2396 } else if (name.equals("name")) { 2397 this.name = castToString(value); // StringType 2398 } else if (name.equals("status")) { 2399 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 2400 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 2401 } else if (name.equals("experimental")) { 2402 this.experimental = castToBoolean(value); // BooleanType 2403 } else if (name.equals("date")) { 2404 this.date = castToDateTime(value); // DateTimeType 2405 } else if (name.equals("publisher")) { 2406 this.publisher = castToString(value); // StringType 2407 } else if (name.equals("contact")) { 2408 this.getContact().add(castToContactDetail(value)); 2409 } else if (name.equals("useContext")) { 2410 this.getUseContext().add(castToUsageContext(value)); 2411 } else if (name.equals("jurisdiction")) { 2412 this.getJurisdiction().add(castToCodeableConcept(value)); 2413 } else if (name.equals("purpose")) { 2414 this.purpose = castToMarkdown(value); // MarkdownType 2415 } else if (name.equals("code")) { 2416 this.code = castToCode(value); // CodeType 2417 } else if (name.equals("base")) { 2418 this.getBase().add(castToCode(value)); 2419 } else if (name.equals("type")) { 2420 value = new SearchParamTypeEnumFactory().fromType(castToCode(value)); 2421 this.type = (Enumeration) value; // Enumeration<SearchParamType> 2422 } else if (name.equals("derivedFrom")) { 2423 this.derivedFrom = castToUri(value); // UriType 2424 } else if (name.equals("description")) { 2425 this.description = castToMarkdown(value); // MarkdownType 2426 } else if (name.equals("expression")) { 2427 this.expression = castToString(value); // StringType 2428 } else if (name.equals("xpath")) { 2429 this.xpath = castToString(value); // StringType 2430 } else if (name.equals("xpathUsage")) { 2431 value = new XPathUsageTypeEnumFactory().fromType(castToCode(value)); 2432 this.xpathUsage = (Enumeration) value; // Enumeration<XPathUsageType> 2433 } else if (name.equals("target")) { 2434 this.getTarget().add(castToCode(value)); 2435 } else if (name.equals("comparator")) { 2436 value = new SearchComparatorEnumFactory().fromType(castToCode(value)); 2437 this.getComparator().add((Enumeration) value); 2438 } else if (name.equals("modifier")) { 2439 value = new SearchModifierCodeEnumFactory().fromType(castToCode(value)); 2440 this.getModifier().add((Enumeration) value); 2441 } else if (name.equals("chain")) { 2442 this.getChain().add(castToString(value)); 2443 } else if (name.equals("component")) { 2444 this.getComponent().add((SearchParameterComponentComponent) value); 2445 } else 2446 return super.setProperty(name, value); 2447 return value; 2448 } 2449 2450 @Override 2451 public Base makeProperty(int hash, String name) throws FHIRException { 2452 switch (hash) { 2453 case 116079: return getUrlElement(); 2454 case 351608024: return getVersionElement(); 2455 case 3373707: return getNameElement(); 2456 case -892481550: return getStatusElement(); 2457 case -404562712: return getExperimentalElement(); 2458 case 3076014: return getDateElement(); 2459 case 1447404028: return getPublisherElement(); 2460 case 951526432: return addContact(); 2461 case -669707736: return addUseContext(); 2462 case -507075711: return addJurisdiction(); 2463 case -220463842: return getPurposeElement(); 2464 case 3059181: return getCodeElement(); 2465 case 3016401: return addBaseElement(); 2466 case 3575610: return getTypeElement(); 2467 case 1077922663: return getDerivedFromElement(); 2468 case -1724546052: return getDescriptionElement(); 2469 case -1795452264: return getExpressionElement(); 2470 case 114256029: return getXpathElement(); 2471 case 1801322244: return getXpathUsageElement(); 2472 case -880905839: return addTargetElement(); 2473 case -844673834: return addComparatorElement(); 2474 case -615513385: return addModifierElement(); 2475 case 94623425: return addChainElement(); 2476 case -1399907075: return addComponent(); 2477 default: return super.makeProperty(hash, name); 2478 } 2479 2480 } 2481 2482 @Override 2483 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2484 switch (hash) { 2485 case 116079: /*url*/ return new String[] {"uri"}; 2486 case 351608024: /*version*/ return new String[] {"string"}; 2487 case 3373707: /*name*/ return new String[] {"string"}; 2488 case -892481550: /*status*/ return new String[] {"code"}; 2489 case -404562712: /*experimental*/ return new String[] {"boolean"}; 2490 case 3076014: /*date*/ return new String[] {"dateTime"}; 2491 case 1447404028: /*publisher*/ return new String[] {"string"}; 2492 case 951526432: /*contact*/ return new String[] {"ContactDetail"}; 2493 case -669707736: /*useContext*/ return new String[] {"UsageContext"}; 2494 case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"}; 2495 case -220463842: /*purpose*/ return new String[] {"markdown"}; 2496 case 3059181: /*code*/ return new String[] {"code"}; 2497 case 3016401: /*base*/ return new String[] {"code"}; 2498 case 3575610: /*type*/ return new String[] {"code"}; 2499 case 1077922663: /*derivedFrom*/ return new String[] {"uri"}; 2500 case -1724546052: /*description*/ return new String[] {"markdown"}; 2501 case -1795452264: /*expression*/ return new String[] {"string"}; 2502 case 114256029: /*xpath*/ return new String[] {"string"}; 2503 case 1801322244: /*xpathUsage*/ return new String[] {"code"}; 2504 case -880905839: /*target*/ return new String[] {"code"}; 2505 case -844673834: /*comparator*/ return new String[] {"code"}; 2506 case -615513385: /*modifier*/ return new String[] {"code"}; 2507 case 94623425: /*chain*/ return new String[] {"string"}; 2508 case -1399907075: /*component*/ return new String[] {}; 2509 default: return super.getTypesForProperty(hash, name); 2510 } 2511 2512 } 2513 2514 @Override 2515 public Base addChild(String name) throws FHIRException { 2516 if (name.equals("url")) { 2517 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.url"); 2518 } 2519 else if (name.equals("version")) { 2520 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.version"); 2521 } 2522 else if (name.equals("name")) { 2523 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.name"); 2524 } 2525 else if (name.equals("status")) { 2526 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.status"); 2527 } 2528 else if (name.equals("experimental")) { 2529 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.experimental"); 2530 } 2531 else if (name.equals("date")) { 2532 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.date"); 2533 } 2534 else if (name.equals("publisher")) { 2535 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.publisher"); 2536 } 2537 else if (name.equals("contact")) { 2538 return addContact(); 2539 } 2540 else if (name.equals("useContext")) { 2541 return addUseContext(); 2542 } 2543 else if (name.equals("jurisdiction")) { 2544 return addJurisdiction(); 2545 } 2546 else if (name.equals("purpose")) { 2547 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.purpose"); 2548 } 2549 else if (name.equals("code")) { 2550 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.code"); 2551 } 2552 else if (name.equals("base")) { 2553 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.base"); 2554 } 2555 else if (name.equals("type")) { 2556 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.type"); 2557 } 2558 else if (name.equals("derivedFrom")) { 2559 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.derivedFrom"); 2560 } 2561 else if (name.equals("description")) { 2562 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.description"); 2563 } 2564 else if (name.equals("expression")) { 2565 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.expression"); 2566 } 2567 else if (name.equals("xpath")) { 2568 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.xpath"); 2569 } 2570 else if (name.equals("xpathUsage")) { 2571 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.xpathUsage"); 2572 } 2573 else if (name.equals("target")) { 2574 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.target"); 2575 } 2576 else if (name.equals("comparator")) { 2577 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.comparator"); 2578 } 2579 else if (name.equals("modifier")) { 2580 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.modifier"); 2581 } 2582 else if (name.equals("chain")) { 2583 throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.chain"); 2584 } 2585 else if (name.equals("component")) { 2586 return addComponent(); 2587 } 2588 else 2589 return super.addChild(name); 2590 } 2591 2592 public String fhirType() { 2593 return "SearchParameter"; 2594 2595 } 2596 2597 public SearchParameter copy() { 2598 SearchParameter dst = new SearchParameter(); 2599 copyValues(dst); 2600 dst.url = url == null ? null : url.copy(); 2601 dst.version = version == null ? null : version.copy(); 2602 dst.name = name == null ? null : name.copy(); 2603 dst.status = status == null ? null : status.copy(); 2604 dst.experimental = experimental == null ? null : experimental.copy(); 2605 dst.date = date == null ? null : date.copy(); 2606 dst.publisher = publisher == null ? null : publisher.copy(); 2607 if (contact != null) { 2608 dst.contact = new ArrayList<ContactDetail>(); 2609 for (ContactDetail i : contact) 2610 dst.contact.add(i.copy()); 2611 }; 2612 if (useContext != null) { 2613 dst.useContext = new ArrayList<UsageContext>(); 2614 for (UsageContext i : useContext) 2615 dst.useContext.add(i.copy()); 2616 }; 2617 if (jurisdiction != null) { 2618 dst.jurisdiction = new ArrayList<CodeableConcept>(); 2619 for (CodeableConcept i : jurisdiction) 2620 dst.jurisdiction.add(i.copy()); 2621 }; 2622 dst.purpose = purpose == null ? null : purpose.copy(); 2623 dst.code = code == null ? null : code.copy(); 2624 if (base != null) { 2625 dst.base = new ArrayList<CodeType>(); 2626 for (CodeType i : base) 2627 dst.base.add(i.copy()); 2628 }; 2629 dst.type = type == null ? null : type.copy(); 2630 dst.derivedFrom = derivedFrom == null ? null : derivedFrom.copy(); 2631 dst.description = description == null ? null : description.copy(); 2632 dst.expression = expression == null ? null : expression.copy(); 2633 dst.xpath = xpath == null ? null : xpath.copy(); 2634 dst.xpathUsage = xpathUsage == null ? null : xpathUsage.copy(); 2635 if (target != null) { 2636 dst.target = new ArrayList<CodeType>(); 2637 for (CodeType i : target) 2638 dst.target.add(i.copy()); 2639 }; 2640 if (comparator != null) { 2641 dst.comparator = new ArrayList<Enumeration<SearchComparator>>(); 2642 for (Enumeration<SearchComparator> i : comparator) 2643 dst.comparator.add(i.copy()); 2644 }; 2645 if (modifier != null) { 2646 dst.modifier = new ArrayList<Enumeration<SearchModifierCode>>(); 2647 for (Enumeration<SearchModifierCode> i : modifier) 2648 dst.modifier.add(i.copy()); 2649 }; 2650 if (chain != null) { 2651 dst.chain = new ArrayList<StringType>(); 2652 for (StringType i : chain) 2653 dst.chain.add(i.copy()); 2654 }; 2655 if (component != null) { 2656 dst.component = new ArrayList<SearchParameterComponentComponent>(); 2657 for (SearchParameterComponentComponent i : component) 2658 dst.component.add(i.copy()); 2659 }; 2660 return dst; 2661 } 2662 2663 protected SearchParameter typedCopy() { 2664 return copy(); 2665 } 2666 2667 @Override 2668 public boolean equalsDeep(Base other_) { 2669 if (!super.equalsDeep(other_)) 2670 return false; 2671 if (!(other_ instanceof SearchParameter)) 2672 return false; 2673 SearchParameter o = (SearchParameter) other_; 2674 return compareDeep(purpose, o.purpose, true) && compareDeep(code, o.code, true) && compareDeep(base, o.base, true) 2675 && compareDeep(type, o.type, true) && compareDeep(derivedFrom, o.derivedFrom, true) && compareDeep(expression, o.expression, true) 2676 && compareDeep(xpath, o.xpath, true) && compareDeep(xpathUsage, o.xpathUsage, true) && compareDeep(target, o.target, true) 2677 && compareDeep(comparator, o.comparator, true) && compareDeep(modifier, o.modifier, true) && compareDeep(chain, o.chain, true) 2678 && compareDeep(component, o.component, true); 2679 } 2680 2681 @Override 2682 public boolean equalsShallow(Base other_) { 2683 if (!super.equalsShallow(other_)) 2684 return false; 2685 if (!(other_ instanceof SearchParameter)) 2686 return false; 2687 SearchParameter o = (SearchParameter) other_; 2688 return compareValues(purpose, o.purpose, true) && compareValues(code, o.code, true) && compareValues(base, o.base, true) 2689 && compareValues(type, o.type, true) && compareValues(derivedFrom, o.derivedFrom, true) && compareValues(expression, o.expression, true) 2690 && compareValues(xpath, o.xpath, true) && compareValues(xpathUsage, o.xpathUsage, true) && compareValues(target, o.target, true) 2691 && compareValues(comparator, o.comparator, true) && compareValues(modifier, o.modifier, true) && compareValues(chain, o.chain, true) 2692 ; 2693 } 2694 2695 public boolean isEmpty() { 2696 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(purpose, code, base, type 2697 , derivedFrom, expression, xpath, xpathUsage, target, comparator, modifier, chain 2698 , component); 2699 } 2700 2701 @Override 2702 public ResourceType getResourceType() { 2703 return ResourceType.SearchParameter; 2704 } 2705 2706 /** 2707 * Search parameter: <b>date</b> 2708 * <p> 2709 * Description: <b>The search parameter publication date</b><br> 2710 * Type: <b>date</b><br> 2711 * Path: <b>SearchParameter.date</b><br> 2712 * </p> 2713 */ 2714 @SearchParamDefinition(name="date", path="SearchParameter.date", description="The search parameter publication date", type="date" ) 2715 public static final String SP_DATE = "date"; 2716 /** 2717 * <b>Fluent Client</b> search parameter constant for <b>date</b> 2718 * <p> 2719 * Description: <b>The search parameter publication date</b><br> 2720 * Type: <b>date</b><br> 2721 * Path: <b>SearchParameter.date</b><br> 2722 * </p> 2723 */ 2724 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE); 2725 2726 /** 2727 * Search parameter: <b>code</b> 2728 * <p> 2729 * Description: <b>Code used in URL</b><br> 2730 * Type: <b>token</b><br> 2731 * Path: <b>SearchParameter.code</b><br> 2732 * </p> 2733 */ 2734 @SearchParamDefinition(name="code", path="SearchParameter.code", description="Code used in URL", type="token" ) 2735 public static final String SP_CODE = "code"; 2736 /** 2737 * <b>Fluent Client</b> search parameter constant for <b>code</b> 2738 * <p> 2739 * Description: <b>Code used in URL</b><br> 2740 * Type: <b>token</b><br> 2741 * Path: <b>SearchParameter.code</b><br> 2742 * </p> 2743 */ 2744 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CODE); 2745 2746 /** 2747 * Search parameter: <b>jurisdiction</b> 2748 * <p> 2749 * Description: <b>Intended jurisdiction for the search parameter</b><br> 2750 * Type: <b>token</b><br> 2751 * Path: <b>SearchParameter.jurisdiction</b><br> 2752 * </p> 2753 */ 2754 @SearchParamDefinition(name="jurisdiction", path="SearchParameter.jurisdiction", description="Intended jurisdiction for the search parameter", type="token" ) 2755 public static final String SP_JURISDICTION = "jurisdiction"; 2756 /** 2757 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 2758 * <p> 2759 * Description: <b>Intended jurisdiction for the search parameter</b><br> 2760 * Type: <b>token</b><br> 2761 * Path: <b>SearchParameter.jurisdiction</b><br> 2762 * </p> 2763 */ 2764 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION); 2765 2766 /** 2767 * Search parameter: <b>description</b> 2768 * <p> 2769 * Description: <b>The description of the search parameter</b><br> 2770 * Type: <b>string</b><br> 2771 * Path: <b>SearchParameter.description</b><br> 2772 * </p> 2773 */ 2774 @SearchParamDefinition(name="description", path="SearchParameter.description", description="The description of the search parameter", type="string" ) 2775 public static final String SP_DESCRIPTION = "description"; 2776 /** 2777 * <b>Fluent Client</b> search parameter constant for <b>description</b> 2778 * <p> 2779 * Description: <b>The description of the search parameter</b><br> 2780 * Type: <b>string</b><br> 2781 * Path: <b>SearchParameter.description</b><br> 2782 * </p> 2783 */ 2784 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION); 2785 2786 /** 2787 * Search parameter: <b>derived-from</b> 2788 * <p> 2789 * Description: <b>Original Definition for the search parameter</b><br> 2790 * Type: <b>uri</b><br> 2791 * Path: <b>SearchParameter.derivedFrom</b><br> 2792 * </p> 2793 */ 2794 @SearchParamDefinition(name="derived-from", path="SearchParameter.derivedFrom", description="Original Definition for the search parameter", type="uri" ) 2795 public static final String SP_DERIVED_FROM = "derived-from"; 2796 /** 2797 * <b>Fluent Client</b> search parameter constant for <b>derived-from</b> 2798 * <p> 2799 * Description: <b>Original Definition for the search parameter</b><br> 2800 * Type: <b>uri</b><br> 2801 * Path: <b>SearchParameter.derivedFrom</b><br> 2802 * </p> 2803 */ 2804 public static final ca.uhn.fhir.rest.gclient.UriClientParam DERIVED_FROM = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_DERIVED_FROM); 2805 2806 /** 2807 * Search parameter: <b>type</b> 2808 * <p> 2809 * Description: <b>number | date | string | token | reference | composite | quantity | uri</b><br> 2810 * Type: <b>token</b><br> 2811 * Path: <b>SearchParameter.type</b><br> 2812 * </p> 2813 */ 2814 @SearchParamDefinition(name="type", path="SearchParameter.type", description="number | date | string | token | reference | composite | quantity | uri", type="token" ) 2815 public static final String SP_TYPE = "type"; 2816 /** 2817 * <b>Fluent Client</b> search parameter constant for <b>type</b> 2818 * <p> 2819 * Description: <b>number | date | string | token | reference | composite | quantity | uri</b><br> 2820 * Type: <b>token</b><br> 2821 * Path: <b>SearchParameter.type</b><br> 2822 * </p> 2823 */ 2824 public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE); 2825 2826 /** 2827 * Search parameter: <b>version</b> 2828 * <p> 2829 * Description: <b>The business version of the search parameter</b><br> 2830 * Type: <b>token</b><br> 2831 * Path: <b>SearchParameter.version</b><br> 2832 * </p> 2833 */ 2834 @SearchParamDefinition(name="version", path="SearchParameter.version", description="The business version of the search parameter", type="token" ) 2835 public static final String SP_VERSION = "version"; 2836 /** 2837 * <b>Fluent Client</b> search parameter constant for <b>version</b> 2838 * <p> 2839 * Description: <b>The business version of the search parameter</b><br> 2840 * Type: <b>token</b><br> 2841 * Path: <b>SearchParameter.version</b><br> 2842 * </p> 2843 */ 2844 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION); 2845 2846 /** 2847 * Search parameter: <b>url</b> 2848 * <p> 2849 * Description: <b>The uri that identifies the search parameter</b><br> 2850 * Type: <b>uri</b><br> 2851 * Path: <b>SearchParameter.url</b><br> 2852 * </p> 2853 */ 2854 @SearchParamDefinition(name="url", path="SearchParameter.url", description="The uri that identifies the search parameter", type="uri" ) 2855 public static final String SP_URL = "url"; 2856 /** 2857 * <b>Fluent Client</b> search parameter constant for <b>url</b> 2858 * <p> 2859 * Description: <b>The uri that identifies the search parameter</b><br> 2860 * Type: <b>uri</b><br> 2861 * Path: <b>SearchParameter.url</b><br> 2862 * </p> 2863 */ 2864 public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL); 2865 2866 /** 2867 * Search parameter: <b>target</b> 2868 * <p> 2869 * Description: <b>Types of resource (if a resource reference)</b><br> 2870 * Type: <b>token</b><br> 2871 * Path: <b>SearchParameter.target</b><br> 2872 * </p> 2873 */ 2874 @SearchParamDefinition(name="target", path="SearchParameter.target", description="Types of resource (if a resource reference)", type="token" ) 2875 public static final String SP_TARGET = "target"; 2876 /** 2877 * <b>Fluent Client</b> search parameter constant for <b>target</b> 2878 * <p> 2879 * Description: <b>Types of resource (if a resource reference)</b><br> 2880 * Type: <b>token</b><br> 2881 * Path: <b>SearchParameter.target</b><br> 2882 * </p> 2883 */ 2884 public static final ca.uhn.fhir.rest.gclient.TokenClientParam TARGET = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TARGET); 2885 2886 /** 2887 * Search parameter: <b>component</b> 2888 * <p> 2889 * Description: <b>Defines how the part works</b><br> 2890 * Type: <b>reference</b><br> 2891 * Path: <b>SearchParameter.component.definition</b><br> 2892 * </p> 2893 */ 2894 @SearchParamDefinition(name="component", path="SearchParameter.component.definition", description="Defines how the part works", type="reference", target={SearchParameter.class } ) 2895 public static final String SP_COMPONENT = "component"; 2896 /** 2897 * <b>Fluent Client</b> search parameter constant for <b>component</b> 2898 * <p> 2899 * Description: <b>Defines how the part works</b><br> 2900 * Type: <b>reference</b><br> 2901 * Path: <b>SearchParameter.component.definition</b><br> 2902 * </p> 2903 */ 2904 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam COMPONENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_COMPONENT); 2905 2906/** 2907 * Constant for fluent queries to be used to add include statements. Specifies 2908 * the path value of "<b>SearchParameter:component</b>". 2909 */ 2910 public static final ca.uhn.fhir.model.api.Include INCLUDE_COMPONENT = new ca.uhn.fhir.model.api.Include("SearchParameter:component").toLocked(); 2911 2912 /** 2913 * Search parameter: <b>name</b> 2914 * <p> 2915 * Description: <b>Computationally friendly name of the search parameter</b><br> 2916 * Type: <b>string</b><br> 2917 * Path: <b>SearchParameter.name</b><br> 2918 * </p> 2919 */ 2920 @SearchParamDefinition(name="name", path="SearchParameter.name", description="Computationally friendly name of the search parameter", type="string" ) 2921 public static final String SP_NAME = "name"; 2922 /** 2923 * <b>Fluent Client</b> search parameter constant for <b>name</b> 2924 * <p> 2925 * Description: <b>Computationally friendly name of the search parameter</b><br> 2926 * Type: <b>string</b><br> 2927 * Path: <b>SearchParameter.name</b><br> 2928 * </p> 2929 */ 2930 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME); 2931 2932 /** 2933 * Search parameter: <b>publisher</b> 2934 * <p> 2935 * Description: <b>Name of the publisher of the search parameter</b><br> 2936 * Type: <b>string</b><br> 2937 * Path: <b>SearchParameter.publisher</b><br> 2938 * </p> 2939 */ 2940 @SearchParamDefinition(name="publisher", path="SearchParameter.publisher", description="Name of the publisher of the search parameter", type="string" ) 2941 public static final String SP_PUBLISHER = "publisher"; 2942 /** 2943 * <b>Fluent Client</b> search parameter constant for <b>publisher</b> 2944 * <p> 2945 * Description: <b>Name of the publisher of the search parameter</b><br> 2946 * Type: <b>string</b><br> 2947 * Path: <b>SearchParameter.publisher</b><br> 2948 * </p> 2949 */ 2950 public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER); 2951 2952 /** 2953 * Search parameter: <b>status</b> 2954 * <p> 2955 * Description: <b>The current status of the search parameter</b><br> 2956 * Type: <b>token</b><br> 2957 * Path: <b>SearchParameter.status</b><br> 2958 * </p> 2959 */ 2960 @SearchParamDefinition(name="status", path="SearchParameter.status", description="The current status of the search parameter", type="token" ) 2961 public static final String SP_STATUS = "status"; 2962 /** 2963 * <b>Fluent Client</b> search parameter constant for <b>status</b> 2964 * <p> 2965 * Description: <b>The current status of the search parameter</b><br> 2966 * Type: <b>token</b><br> 2967 * Path: <b>SearchParameter.status</b><br> 2968 * </p> 2969 */ 2970 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 2971 2972 /** 2973 * Search parameter: <b>base</b> 2974 * <p> 2975 * Description: <b>The resource type(s) this search parameter applies to</b><br> 2976 * Type: <b>token</b><br> 2977 * Path: <b>SearchParameter.base</b><br> 2978 * </p> 2979 */ 2980 @SearchParamDefinition(name="base", path="SearchParameter.base", description="The resource type(s) this search parameter applies to", type="token" ) 2981 public static final String SP_BASE = "base"; 2982 /** 2983 * <b>Fluent Client</b> search parameter constant for <b>base</b> 2984 * <p> 2985 * Description: <b>The resource type(s) this search parameter applies to</b><br> 2986 * Type: <b>token</b><br> 2987 * Path: <b>SearchParameter.base</b><br> 2988 * </p> 2989 */ 2990 public static final ca.uhn.fhir.rest.gclient.TokenClientParam BASE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_BASE); 2991 2992 2993} 2994