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