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