001package org.hl7.fhir.r5.model; 002 003 004/* 005 Copyright (c) 2011+, HL7, Inc. 006 All rights reserved. 007 008 Redistribution and use in source and binary forms, with or without modification, \ 009 are permitted provided that the following conditions are met: 010 011 * Redistributions of source code must retain the above copyright notice, this \ 012 list of conditions and the following disclaimer. 013 * Redistributions in binary form must reproduce the above copyright notice, \ 014 this list of conditions and the following disclaimer in the documentation \ 015 and/or other materials provided with the distribution. 016 * Neither the name of HL7 nor the names of its contributors may be used to 017 endorse or promote products derived from this software without specific 018 prior written permission. 019 020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 021 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 022 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 023 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 024 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 025 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 026 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 027 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 028 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 029 POSSIBILITY OF SUCH DAMAGE. 030 */ 031 032// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0 033 034import java.util.ArrayList; 035import java.util.Date; 036import java.util.List; 037import org.hl7.fhir.utilities.Utilities; 038import org.hl7.fhir.r5.model.Enumerations.*; 039import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 040import org.hl7.fhir.exceptions.FHIRException; 041import org.hl7.fhir.instance.model.api.ICompositeType; 042import ca.uhn.fhir.model.api.annotation.ResourceDef; 043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 044import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 045import ca.uhn.fhir.model.api.annotation.Child; 046import ca.uhn.fhir.model.api.annotation.ChildOrder; 047import ca.uhn.fhir.model.api.annotation.Description; 048import ca.uhn.fhir.model.api.annotation.Block; 049 050/** 051 * Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization. 052 */ 053@ResourceDef(name="Group", profile="http://hl7.org/fhir/StructureDefinition/Group") 054public class Group extends DomainResource { 055 056 public enum GroupMembershipBasis { 057 /** 058 * The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete. 059 */ 060 DEFINITIONAL, 061 /** 062 * The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member. 063 */ 064 ENUMERATED, 065 /** 066 * added to help the parsers with the generic types 067 */ 068 NULL; 069 public static GroupMembershipBasis fromCode(String codeString) throws FHIRException { 070 if (codeString == null || "".equals(codeString)) 071 return null; 072 if ("definitional".equals(codeString)) 073 return DEFINITIONAL; 074 if ("enumerated".equals(codeString)) 075 return ENUMERATED; 076 if (Configuration.isAcceptInvalidEnums()) 077 return null; 078 else 079 throw new FHIRException("Unknown GroupMembershipBasis code '"+codeString+"'"); 080 } 081 public String toCode() { 082 switch (this) { 083 case DEFINITIONAL: return "definitional"; 084 case ENUMERATED: return "enumerated"; 085 case NULL: return null; 086 default: return "?"; 087 } 088 } 089 public String getSystem() { 090 switch (this) { 091 case DEFINITIONAL: return "http://hl7.org/fhir/group-membership-basis"; 092 case ENUMERATED: return "http://hl7.org/fhir/group-membership-basis"; 093 case NULL: return null; 094 default: return "?"; 095 } 096 } 097 public String getDefinition() { 098 switch (this) { 099 case DEFINITIONAL: return "The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete."; 100 case ENUMERATED: return "The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member."; 101 case NULL: return null; 102 default: return "?"; 103 } 104 } 105 public String getDisplay() { 106 switch (this) { 107 case DEFINITIONAL: return "Definitional"; 108 case ENUMERATED: return "Enumerated"; 109 case NULL: return null; 110 default: return "?"; 111 } 112 } 113 } 114 115 public static class GroupMembershipBasisEnumFactory implements EnumFactory<GroupMembershipBasis> { 116 public GroupMembershipBasis fromCode(String codeString) throws IllegalArgumentException { 117 if (codeString == null || "".equals(codeString)) 118 if (codeString == null || "".equals(codeString)) 119 return null; 120 if ("definitional".equals(codeString)) 121 return GroupMembershipBasis.DEFINITIONAL; 122 if ("enumerated".equals(codeString)) 123 return GroupMembershipBasis.ENUMERATED; 124 throw new IllegalArgumentException("Unknown GroupMembershipBasis code '"+codeString+"'"); 125 } 126 public Enumeration<GroupMembershipBasis> fromType(PrimitiveType<?> code) throws FHIRException { 127 if (code == null) 128 return null; 129 if (code.isEmpty()) 130 return new Enumeration<GroupMembershipBasis>(this, GroupMembershipBasis.NULL, code); 131 String codeString = ((PrimitiveType) code).asStringValue(); 132 if (codeString == null || "".equals(codeString)) 133 return new Enumeration<GroupMembershipBasis>(this, GroupMembershipBasis.NULL, code); 134 if ("definitional".equals(codeString)) 135 return new Enumeration<GroupMembershipBasis>(this, GroupMembershipBasis.DEFINITIONAL, code); 136 if ("enumerated".equals(codeString)) 137 return new Enumeration<GroupMembershipBasis>(this, GroupMembershipBasis.ENUMERATED, code); 138 throw new FHIRException("Unknown GroupMembershipBasis code '"+codeString+"'"); 139 } 140 public String toCode(GroupMembershipBasis code) { 141 if (code == GroupMembershipBasis.DEFINITIONAL) 142 return "definitional"; 143 if (code == GroupMembershipBasis.ENUMERATED) 144 return "enumerated"; 145 return "?"; 146 } 147 public String toSystem(GroupMembershipBasis code) { 148 return code.getSystem(); 149 } 150 } 151 152 public enum GroupType { 153 /** 154 * Group contains \"person\" Patient resources. 155 */ 156 PERSON, 157 /** 158 * Group contains \"animal\" Patient resources. 159 */ 160 ANIMAL, 161 /** 162 * Group contains healthcare practitioner resources (Practitioner or PractitionerRole). 163 */ 164 PRACTITIONER, 165 /** 166 * Group contains Device resources. 167 */ 168 DEVICE, 169 /** 170 * Group contains CareTeam resources. 171 */ 172 CARETEAM, 173 /** 174 * Group contains HealthcareService resources. 175 */ 176 HEALTHCARESERVICE, 177 /** 178 * Group contains Location resources. 179 */ 180 LOCATION, 181 /** 182 * Group contains Organization resources. 183 */ 184 ORGANIZATION, 185 /** 186 * Group contains RelatedPerson resources. 187 */ 188 RELATEDPERSON, 189 /** 190 * Group contains Specimen resources. 191 */ 192 SPECIMEN, 193 /** 194 * added to help the parsers with the generic types 195 */ 196 NULL; 197 public static GroupType fromCode(String codeString) throws FHIRException { 198 if (codeString == null || "".equals(codeString)) 199 return null; 200 if ("person".equals(codeString)) 201 return PERSON; 202 if ("animal".equals(codeString)) 203 return ANIMAL; 204 if ("practitioner".equals(codeString)) 205 return PRACTITIONER; 206 if ("device".equals(codeString)) 207 return DEVICE; 208 if ("careteam".equals(codeString)) 209 return CARETEAM; 210 if ("healthcareservice".equals(codeString)) 211 return HEALTHCARESERVICE; 212 if ("location".equals(codeString)) 213 return LOCATION; 214 if ("organization".equals(codeString)) 215 return ORGANIZATION; 216 if ("relatedperson".equals(codeString)) 217 return RELATEDPERSON; 218 if ("specimen".equals(codeString)) 219 return SPECIMEN; 220 if (Configuration.isAcceptInvalidEnums()) 221 return null; 222 else 223 throw new FHIRException("Unknown GroupType code '"+codeString+"'"); 224 } 225 public String toCode() { 226 switch (this) { 227 case PERSON: return "person"; 228 case ANIMAL: return "animal"; 229 case PRACTITIONER: return "practitioner"; 230 case DEVICE: return "device"; 231 case CARETEAM: return "careteam"; 232 case HEALTHCARESERVICE: return "healthcareservice"; 233 case LOCATION: return "location"; 234 case ORGANIZATION: return "organization"; 235 case RELATEDPERSON: return "relatedperson"; 236 case SPECIMEN: return "specimen"; 237 case NULL: return null; 238 default: return "?"; 239 } 240 } 241 public String getSystem() { 242 switch (this) { 243 case PERSON: return "http://hl7.org/fhir/group-type"; 244 case ANIMAL: return "http://hl7.org/fhir/group-type"; 245 case PRACTITIONER: return "http://hl7.org/fhir/group-type"; 246 case DEVICE: return "http://hl7.org/fhir/group-type"; 247 case CARETEAM: return "http://hl7.org/fhir/group-type"; 248 case HEALTHCARESERVICE: return "http://hl7.org/fhir/group-type"; 249 case LOCATION: return "http://hl7.org/fhir/group-type"; 250 case ORGANIZATION: return "http://hl7.org/fhir/group-type"; 251 case RELATEDPERSON: return "http://hl7.org/fhir/group-type"; 252 case SPECIMEN: return "http://hl7.org/fhir/group-type"; 253 case NULL: return null; 254 default: return "?"; 255 } 256 } 257 public String getDefinition() { 258 switch (this) { 259 case PERSON: return "Group contains \"person\" Patient resources."; 260 case ANIMAL: return "Group contains \"animal\" Patient resources."; 261 case PRACTITIONER: return "Group contains healthcare practitioner resources (Practitioner or PractitionerRole)."; 262 case DEVICE: return "Group contains Device resources."; 263 case CARETEAM: return "Group contains CareTeam resources."; 264 case HEALTHCARESERVICE: return "Group contains HealthcareService resources."; 265 case LOCATION: return "Group contains Location resources."; 266 case ORGANIZATION: return "Group contains Organization resources."; 267 case RELATEDPERSON: return "Group contains RelatedPerson resources."; 268 case SPECIMEN: return "Group contains Specimen resources."; 269 case NULL: return null; 270 default: return "?"; 271 } 272 } 273 public String getDisplay() { 274 switch (this) { 275 case PERSON: return "Person"; 276 case ANIMAL: return "Animal"; 277 case PRACTITIONER: return "Practitioner"; 278 case DEVICE: return "Device"; 279 case CARETEAM: return "CareTeam"; 280 case HEALTHCARESERVICE: return "HealthcareService"; 281 case LOCATION: return "Location"; 282 case ORGANIZATION: return "Organization"; 283 case RELATEDPERSON: return "RelatedPerson"; 284 case SPECIMEN: return "Specimen"; 285 case NULL: return null; 286 default: return "?"; 287 } 288 } 289 } 290 291 public static class GroupTypeEnumFactory implements EnumFactory<GroupType> { 292 public GroupType fromCode(String codeString) throws IllegalArgumentException { 293 if (codeString == null || "".equals(codeString)) 294 if (codeString == null || "".equals(codeString)) 295 return null; 296 if ("person".equals(codeString)) 297 return GroupType.PERSON; 298 if ("animal".equals(codeString)) 299 return GroupType.ANIMAL; 300 if ("practitioner".equals(codeString)) 301 return GroupType.PRACTITIONER; 302 if ("device".equals(codeString)) 303 return GroupType.DEVICE; 304 if ("careteam".equals(codeString)) 305 return GroupType.CARETEAM; 306 if ("healthcareservice".equals(codeString)) 307 return GroupType.HEALTHCARESERVICE; 308 if ("location".equals(codeString)) 309 return GroupType.LOCATION; 310 if ("organization".equals(codeString)) 311 return GroupType.ORGANIZATION; 312 if ("relatedperson".equals(codeString)) 313 return GroupType.RELATEDPERSON; 314 if ("specimen".equals(codeString)) 315 return GroupType.SPECIMEN; 316 throw new IllegalArgumentException("Unknown GroupType code '"+codeString+"'"); 317 } 318 public Enumeration<GroupType> fromType(PrimitiveType<?> code) throws FHIRException { 319 if (code == null) 320 return null; 321 if (code.isEmpty()) 322 return new Enumeration<GroupType>(this, GroupType.NULL, code); 323 String codeString = ((PrimitiveType) code).asStringValue(); 324 if (codeString == null || "".equals(codeString)) 325 return new Enumeration<GroupType>(this, GroupType.NULL, code); 326 if ("person".equals(codeString)) 327 return new Enumeration<GroupType>(this, GroupType.PERSON, code); 328 if ("animal".equals(codeString)) 329 return new Enumeration<GroupType>(this, GroupType.ANIMAL, code); 330 if ("practitioner".equals(codeString)) 331 return new Enumeration<GroupType>(this, GroupType.PRACTITIONER, code); 332 if ("device".equals(codeString)) 333 return new Enumeration<GroupType>(this, GroupType.DEVICE, code); 334 if ("careteam".equals(codeString)) 335 return new Enumeration<GroupType>(this, GroupType.CARETEAM, code); 336 if ("healthcareservice".equals(codeString)) 337 return new Enumeration<GroupType>(this, GroupType.HEALTHCARESERVICE, code); 338 if ("location".equals(codeString)) 339 return new Enumeration<GroupType>(this, GroupType.LOCATION, code); 340 if ("organization".equals(codeString)) 341 return new Enumeration<GroupType>(this, GroupType.ORGANIZATION, code); 342 if ("relatedperson".equals(codeString)) 343 return new Enumeration<GroupType>(this, GroupType.RELATEDPERSON, code); 344 if ("specimen".equals(codeString)) 345 return new Enumeration<GroupType>(this, GroupType.SPECIMEN, code); 346 throw new FHIRException("Unknown GroupType code '"+codeString+"'"); 347 } 348 public String toCode(GroupType code) { 349 if (code == GroupType.PERSON) 350 return "person"; 351 if (code == GroupType.ANIMAL) 352 return "animal"; 353 if (code == GroupType.PRACTITIONER) 354 return "practitioner"; 355 if (code == GroupType.DEVICE) 356 return "device"; 357 if (code == GroupType.CARETEAM) 358 return "careteam"; 359 if (code == GroupType.HEALTHCARESERVICE) 360 return "healthcareservice"; 361 if (code == GroupType.LOCATION) 362 return "location"; 363 if (code == GroupType.ORGANIZATION) 364 return "organization"; 365 if (code == GroupType.RELATEDPERSON) 366 return "relatedperson"; 367 if (code == GroupType.SPECIMEN) 368 return "specimen"; 369 return "?"; 370 } 371 public String toSystem(GroupType code) { 372 return code.getSystem(); 373 } 374 } 375 376 @Block() 377 public static class GroupCharacteristicComponent extends BackboneElement implements IBaseBackboneElement { 378 /** 379 * A code that identifies the kind of trait being asserted. 380 */ 381 @Child(name = "code", type = {CodeableConcept.class}, order=1, min=1, max=1, modifier=false, summary=true) 382 @Description(shortDefinition="Kind of characteristic", formalDefinition="A code that identifies the kind of trait being asserted." ) 383 protected CodeableConcept code; 384 385 /** 386 * The value of the trait that holds (or does not hold - see 'exclude') for members of the group. 387 */ 388 @Child(name = "value", type = {CodeableConcept.class, BooleanType.class, Quantity.class, Range.class, Reference.class}, order=2, min=1, max=1, modifier=false, summary=true) 389 @Description(shortDefinition="Value held by characteristic", formalDefinition="The value of the trait that holds (or does not hold - see 'exclude') for members of the group." ) 390 protected DataType value; 391 392 /** 393 * If true, indicates the characteristic is one that is NOT held by members of the group. 394 */ 395 @Child(name = "exclude", type = {BooleanType.class}, order=3, min=1, max=1, modifier=false, summary=true) 396 @Description(shortDefinition="Group includes or excludes", formalDefinition="If true, indicates the characteristic is one that is NOT held by members of the group." ) 397 protected BooleanType exclude; 398 399 /** 400 * The period over which the characteristic is tested; e.g. the patient had an operation during the month of June. 401 */ 402 @Child(name = "period", type = {Period.class}, order=4, min=0, max=1, modifier=false, summary=false) 403 @Description(shortDefinition="Period over which characteristic is tested", formalDefinition="The period over which the characteristic is tested; e.g. the patient had an operation during the month of June." ) 404 protected Period period; 405 406 private static final long serialVersionUID = 279867823L; 407 408 /** 409 * Constructor 410 */ 411 public GroupCharacteristicComponent() { 412 super(); 413 } 414 415 /** 416 * Constructor 417 */ 418 public GroupCharacteristicComponent(CodeableConcept code, DataType value, boolean exclude) { 419 super(); 420 this.setCode(code); 421 this.setValue(value); 422 this.setExclude(exclude); 423 } 424 425 /** 426 * @return {@link #code} (A code that identifies the kind of trait being asserted.) 427 */ 428 public CodeableConcept getCode() { 429 if (this.code == null) 430 if (Configuration.errorOnAutoCreate()) 431 throw new Error("Attempt to auto-create GroupCharacteristicComponent.code"); 432 else if (Configuration.doAutoCreate()) 433 this.code = new CodeableConcept(); // cc 434 return this.code; 435 } 436 437 public boolean hasCode() { 438 return this.code != null && !this.code.isEmpty(); 439 } 440 441 /** 442 * @param value {@link #code} (A code that identifies the kind of trait being asserted.) 443 */ 444 public GroupCharacteristicComponent setCode(CodeableConcept value) { 445 this.code = value; 446 return this; 447 } 448 449 /** 450 * @return {@link #value} (The value of the trait that holds (or does not hold - see 'exclude') for members of the group.) 451 */ 452 public DataType getValue() { 453 return this.value; 454 } 455 456 /** 457 * @return {@link #value} (The value of the trait that holds (or does not hold - see 'exclude') for members of the group.) 458 */ 459 public CodeableConcept getValueCodeableConcept() throws FHIRException { 460 if (this.value == null) 461 this.value = new CodeableConcept(); 462 if (!(this.value instanceof CodeableConcept)) 463 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.value.getClass().getName()+" was encountered"); 464 return (CodeableConcept) this.value; 465 } 466 467 public boolean hasValueCodeableConcept() { 468 return this != null && this.value instanceof CodeableConcept; 469 } 470 471 /** 472 * @return {@link #value} (The value of the trait that holds (or does not hold - see 'exclude') for members of the group.) 473 */ 474 public BooleanType getValueBooleanType() throws FHIRException { 475 if (this.value == null) 476 this.value = new BooleanType(); 477 if (!(this.value instanceof BooleanType)) 478 throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.value.getClass().getName()+" was encountered"); 479 return (BooleanType) this.value; 480 } 481 482 public boolean hasValueBooleanType() { 483 return this != null && this.value instanceof BooleanType; 484 } 485 486 /** 487 * @return {@link #value} (The value of the trait that holds (or does not hold - see 'exclude') for members of the group.) 488 */ 489 public Quantity getValueQuantity() throws FHIRException { 490 if (this.value == null) 491 this.value = new Quantity(); 492 if (!(this.value instanceof Quantity)) 493 throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.value.getClass().getName()+" was encountered"); 494 return (Quantity) this.value; 495 } 496 497 public boolean hasValueQuantity() { 498 return this != null && this.value instanceof Quantity; 499 } 500 501 /** 502 * @return {@link #value} (The value of the trait that holds (or does not hold - see 'exclude') for members of the group.) 503 */ 504 public Range getValueRange() throws FHIRException { 505 if (this.value == null) 506 this.value = new Range(); 507 if (!(this.value instanceof Range)) 508 throw new FHIRException("Type mismatch: the type Range was expected, but "+this.value.getClass().getName()+" was encountered"); 509 return (Range) this.value; 510 } 511 512 public boolean hasValueRange() { 513 return this != null && this.value instanceof Range; 514 } 515 516 /** 517 * @return {@link #value} (The value of the trait that holds (or does not hold - see 'exclude') for members of the group.) 518 */ 519 public Reference getValueReference() throws FHIRException { 520 if (this.value == null) 521 this.value = new Reference(); 522 if (!(this.value instanceof Reference)) 523 throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.value.getClass().getName()+" was encountered"); 524 return (Reference) this.value; 525 } 526 527 public boolean hasValueReference() { 528 return this != null && this.value instanceof Reference; 529 } 530 531 public boolean hasValue() { 532 return this.value != null && !this.value.isEmpty(); 533 } 534 535 /** 536 * @param value {@link #value} (The value of the trait that holds (or does not hold - see 'exclude') for members of the group.) 537 */ 538 public GroupCharacteristicComponent setValue(DataType value) { 539 if (value != null && !(value instanceof CodeableConcept || value instanceof BooleanType || value instanceof Quantity || value instanceof Range || value instanceof Reference)) 540 throw new FHIRException("Not the right type for Group.characteristic.value[x]: "+value.fhirType()); 541 this.value = value; 542 return this; 543 } 544 545 /** 546 * @return {@link #exclude} (If true, indicates the characteristic is one that is NOT held by members of the group.). This is the underlying object with id, value and extensions. The accessor "getExclude" gives direct access to the value 547 */ 548 public BooleanType getExcludeElement() { 549 if (this.exclude == null) 550 if (Configuration.errorOnAutoCreate()) 551 throw new Error("Attempt to auto-create GroupCharacteristicComponent.exclude"); 552 else if (Configuration.doAutoCreate()) 553 this.exclude = new BooleanType(); // bb 554 return this.exclude; 555 } 556 557 public boolean hasExcludeElement() { 558 return this.exclude != null && !this.exclude.isEmpty(); 559 } 560 561 public boolean hasExclude() { 562 return this.exclude != null && !this.exclude.isEmpty(); 563 } 564 565 /** 566 * @param value {@link #exclude} (If true, indicates the characteristic is one that is NOT held by members of the group.). This is the underlying object with id, value and extensions. The accessor "getExclude" gives direct access to the value 567 */ 568 public GroupCharacteristicComponent setExcludeElement(BooleanType value) { 569 this.exclude = value; 570 return this; 571 } 572 573 /** 574 * @return If true, indicates the characteristic is one that is NOT held by members of the group. 575 */ 576 public boolean getExclude() { 577 return this.exclude == null || this.exclude.isEmpty() ? false : this.exclude.getValue(); 578 } 579 580 /** 581 * @param value If true, indicates the characteristic is one that is NOT held by members of the group. 582 */ 583 public GroupCharacteristicComponent setExclude(boolean value) { 584 if (this.exclude == null) 585 this.exclude = new BooleanType(); 586 this.exclude.setValue(value); 587 return this; 588 } 589 590 /** 591 * @return {@link #period} (The period over which the characteristic is tested; e.g. the patient had an operation during the month of June.) 592 */ 593 public Period getPeriod() { 594 if (this.period == null) 595 if (Configuration.errorOnAutoCreate()) 596 throw new Error("Attempt to auto-create GroupCharacteristicComponent.period"); 597 else if (Configuration.doAutoCreate()) 598 this.period = new Period(); // cc 599 return this.period; 600 } 601 602 public boolean hasPeriod() { 603 return this.period != null && !this.period.isEmpty(); 604 } 605 606 /** 607 * @param value {@link #period} (The period over which the characteristic is tested; e.g. the patient had an operation during the month of June.) 608 */ 609 public GroupCharacteristicComponent setPeriod(Period value) { 610 this.period = value; 611 return this; 612 } 613 614 protected void listChildren(List<Property> children) { 615 super.listChildren(children); 616 children.add(new Property("code", "CodeableConcept", "A code that identifies the kind of trait being asserted.", 0, 1, code)); 617 children.add(new Property("value[x]", "CodeableConcept|boolean|Quantity|Range|Reference", "The value of the trait that holds (or does not hold - see 'exclude') for members of the group.", 0, 1, value)); 618 children.add(new Property("exclude", "boolean", "If true, indicates the characteristic is one that is NOT held by members of the group.", 0, 1, exclude)); 619 children.add(new Property("period", "Period", "The period over which the characteristic is tested; e.g. the patient had an operation during the month of June.", 0, 1, period)); 620 } 621 622 @Override 623 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 624 switch (_hash) { 625 case 3059181: /*code*/ return new Property("code", "CodeableConcept", "A code that identifies the kind of trait being asserted.", 0, 1, code); 626 case -1410166417: /*value[x]*/ return new Property("value[x]", "CodeableConcept|boolean|Quantity|Range|Reference", "The value of the trait that holds (or does not hold - see 'exclude') for members of the group.", 0, 1, value); 627 case 111972721: /*value*/ return new Property("value[x]", "CodeableConcept|boolean|Quantity|Range|Reference", "The value of the trait that holds (or does not hold - see 'exclude') for members of the group.", 0, 1, value); 628 case 924902896: /*valueCodeableConcept*/ return new Property("value[x]", "CodeableConcept", "The value of the trait that holds (or does not hold - see 'exclude') for members of the group.", 0, 1, value); 629 case 733421943: /*valueBoolean*/ return new Property("value[x]", "boolean", "The value of the trait that holds (or does not hold - see 'exclude') for members of the group.", 0, 1, value); 630 case -2029823716: /*valueQuantity*/ return new Property("value[x]", "Quantity", "The value of the trait that holds (or does not hold - see 'exclude') for members of the group.", 0, 1, value); 631 case 2030761548: /*valueRange*/ return new Property("value[x]", "Range", "The value of the trait that holds (or does not hold - see 'exclude') for members of the group.", 0, 1, value); 632 case 1755241690: /*valueReference*/ return new Property("value[x]", "Reference", "The value of the trait that holds (or does not hold - see 'exclude') for members of the group.", 0, 1, value); 633 case -1321148966: /*exclude*/ return new Property("exclude", "boolean", "If true, indicates the characteristic is one that is NOT held by members of the group.", 0, 1, exclude); 634 case -991726143: /*period*/ return new Property("period", "Period", "The period over which the characteristic is tested; e.g. the patient had an operation during the month of June.", 0, 1, period); 635 default: return super.getNamedProperty(_hash, _name, _checkValid); 636 } 637 638 } 639 640 @Override 641 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 642 switch (hash) { 643 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept 644 case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // DataType 645 case -1321148966: /*exclude*/ return this.exclude == null ? new Base[0] : new Base[] {this.exclude}; // BooleanType 646 case -991726143: /*period*/ return this.period == null ? new Base[0] : new Base[] {this.period}; // Period 647 default: return super.getProperty(hash, name, checkValid); 648 } 649 650 } 651 652 @Override 653 public Base setProperty(int hash, String name, Base value) throws FHIRException { 654 switch (hash) { 655 case 3059181: // code 656 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 657 return value; 658 case 111972721: // value 659 this.value = TypeConvertor.castToType(value); // DataType 660 return value; 661 case -1321148966: // exclude 662 this.exclude = TypeConvertor.castToBoolean(value); // BooleanType 663 return value; 664 case -991726143: // period 665 this.period = TypeConvertor.castToPeriod(value); // Period 666 return value; 667 default: return super.setProperty(hash, name, value); 668 } 669 670 } 671 672 @Override 673 public Base setProperty(String name, Base value) throws FHIRException { 674 if (name.equals("code")) { 675 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 676 } else if (name.equals("value[x]")) { 677 this.value = TypeConvertor.castToType(value); // DataType 678 } else if (name.equals("exclude")) { 679 this.exclude = TypeConvertor.castToBoolean(value); // BooleanType 680 } else if (name.equals("period")) { 681 this.period = TypeConvertor.castToPeriod(value); // Period 682 } else 683 return super.setProperty(name, value); 684 return value; 685 } 686 687 @Override 688 public Base makeProperty(int hash, String name) throws FHIRException { 689 switch (hash) { 690 case 3059181: return getCode(); 691 case -1410166417: return getValue(); 692 case 111972721: return getValue(); 693 case -1321148966: return getExcludeElement(); 694 case -991726143: return getPeriod(); 695 default: return super.makeProperty(hash, name); 696 } 697 698 } 699 700 @Override 701 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 702 switch (hash) { 703 case 3059181: /*code*/ return new String[] {"CodeableConcept"}; 704 case 111972721: /*value*/ return new String[] {"CodeableConcept", "boolean", "Quantity", "Range", "Reference"}; 705 case -1321148966: /*exclude*/ return new String[] {"boolean"}; 706 case -991726143: /*period*/ return new String[] {"Period"}; 707 default: return super.getTypesForProperty(hash, name); 708 } 709 710 } 711 712 @Override 713 public Base addChild(String name) throws FHIRException { 714 if (name.equals("code")) { 715 this.code = new CodeableConcept(); 716 return this.code; 717 } 718 else if (name.equals("valueCodeableConcept")) { 719 this.value = new CodeableConcept(); 720 return this.value; 721 } 722 else if (name.equals("valueBoolean")) { 723 this.value = new BooleanType(); 724 return this.value; 725 } 726 else if (name.equals("valueQuantity")) { 727 this.value = new Quantity(); 728 return this.value; 729 } 730 else if (name.equals("valueRange")) { 731 this.value = new Range(); 732 return this.value; 733 } 734 else if (name.equals("valueReference")) { 735 this.value = new Reference(); 736 return this.value; 737 } 738 else if (name.equals("exclude")) { 739 throw new FHIRException("Cannot call addChild on a singleton property Group.characteristic.exclude"); 740 } 741 else if (name.equals("period")) { 742 this.period = new Period(); 743 return this.period; 744 } 745 else 746 return super.addChild(name); 747 } 748 749 public GroupCharacteristicComponent copy() { 750 GroupCharacteristicComponent dst = new GroupCharacteristicComponent(); 751 copyValues(dst); 752 return dst; 753 } 754 755 public void copyValues(GroupCharacteristicComponent dst) { 756 super.copyValues(dst); 757 dst.code = code == null ? null : code.copy(); 758 dst.value = value == null ? null : value.copy(); 759 dst.exclude = exclude == null ? null : exclude.copy(); 760 dst.period = period == null ? null : period.copy(); 761 } 762 763 @Override 764 public boolean equalsDeep(Base other_) { 765 if (!super.equalsDeep(other_)) 766 return false; 767 if (!(other_ instanceof GroupCharacteristicComponent)) 768 return false; 769 GroupCharacteristicComponent o = (GroupCharacteristicComponent) other_; 770 return compareDeep(code, o.code, true) && compareDeep(value, o.value, true) && compareDeep(exclude, o.exclude, true) 771 && compareDeep(period, o.period, true); 772 } 773 774 @Override 775 public boolean equalsShallow(Base other_) { 776 if (!super.equalsShallow(other_)) 777 return false; 778 if (!(other_ instanceof GroupCharacteristicComponent)) 779 return false; 780 GroupCharacteristicComponent o = (GroupCharacteristicComponent) other_; 781 return compareValues(exclude, o.exclude, true); 782 } 783 784 public boolean isEmpty() { 785 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, value, exclude, period 786 ); 787 } 788 789 public String fhirType() { 790 return "Group.characteristic"; 791 792 } 793 794 } 795 796 @Block() 797 public static class GroupMemberComponent extends BackboneElement implements IBaseBackboneElement { 798 /** 799 * A reference to the entity that is a member of the group. Must be consistent with Group.type. If the entity is another group, then the type must be the same. 800 */ 801 @Child(name = "entity", type = {CareTeam.class, Device.class, Group.class, HealthcareService.class, Location.class, Organization.class, Patient.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class, Specimen.class}, order=1, min=1, max=1, modifier=false, summary=false) 802 @Description(shortDefinition="Reference to the group member", formalDefinition="A reference to the entity that is a member of the group. Must be consistent with Group.type. If the entity is another group, then the type must be the same." ) 803 protected Reference entity; 804 805 /** 806 * The period that the member was in the group, if known. 807 */ 808 @Child(name = "period", type = {Period.class}, order=2, min=0, max=1, modifier=false, summary=false) 809 @Description(shortDefinition="Period member belonged to the group", formalDefinition="The period that the member was in the group, if known." ) 810 protected Period period; 811 812 /** 813 * A flag to indicate that the member is no longer in the group, but previously may have been a member. 814 */ 815 @Child(name = "inactive", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=false) 816 @Description(shortDefinition="If member is no longer in group", formalDefinition="A flag to indicate that the member is no longer in the group, but previously may have been a member." ) 817 protected BooleanType inactive; 818 819 private static final long serialVersionUID = -1206153083L; 820 821 /** 822 * Constructor 823 */ 824 public GroupMemberComponent() { 825 super(); 826 } 827 828 /** 829 * Constructor 830 */ 831 public GroupMemberComponent(Reference entity) { 832 super(); 833 this.setEntity(entity); 834 } 835 836 /** 837 * @return {@link #entity} (A reference to the entity that is a member of the group. Must be consistent with Group.type. If the entity is another group, then the type must be the same.) 838 */ 839 public Reference getEntity() { 840 if (this.entity == null) 841 if (Configuration.errorOnAutoCreate()) 842 throw new Error("Attempt to auto-create GroupMemberComponent.entity"); 843 else if (Configuration.doAutoCreate()) 844 this.entity = new Reference(); // cc 845 return this.entity; 846 } 847 848 public boolean hasEntity() { 849 return this.entity != null && !this.entity.isEmpty(); 850 } 851 852 /** 853 * @param value {@link #entity} (A reference to the entity that is a member of the group. Must be consistent with Group.type. If the entity is another group, then the type must be the same.) 854 */ 855 public GroupMemberComponent setEntity(Reference value) { 856 this.entity = value; 857 return this; 858 } 859 860 /** 861 * @return {@link #period} (The period that the member was in the group, if known.) 862 */ 863 public Period getPeriod() { 864 if (this.period == null) 865 if (Configuration.errorOnAutoCreate()) 866 throw new Error("Attempt to auto-create GroupMemberComponent.period"); 867 else if (Configuration.doAutoCreate()) 868 this.period = new Period(); // cc 869 return this.period; 870 } 871 872 public boolean hasPeriod() { 873 return this.period != null && !this.period.isEmpty(); 874 } 875 876 /** 877 * @param value {@link #period} (The period that the member was in the group, if known.) 878 */ 879 public GroupMemberComponent setPeriod(Period value) { 880 this.period = value; 881 return this; 882 } 883 884 /** 885 * @return {@link #inactive} (A flag to indicate that the member is no longer in the group, but previously may have been a member.). This is the underlying object with id, value and extensions. The accessor "getInactive" gives direct access to the value 886 */ 887 public BooleanType getInactiveElement() { 888 if (this.inactive == null) 889 if (Configuration.errorOnAutoCreate()) 890 throw new Error("Attempt to auto-create GroupMemberComponent.inactive"); 891 else if (Configuration.doAutoCreate()) 892 this.inactive = new BooleanType(); // bb 893 return this.inactive; 894 } 895 896 public boolean hasInactiveElement() { 897 return this.inactive != null && !this.inactive.isEmpty(); 898 } 899 900 public boolean hasInactive() { 901 return this.inactive != null && !this.inactive.isEmpty(); 902 } 903 904 /** 905 * @param value {@link #inactive} (A flag to indicate that the member is no longer in the group, but previously may have been a member.). This is the underlying object with id, value and extensions. The accessor "getInactive" gives direct access to the value 906 */ 907 public GroupMemberComponent setInactiveElement(BooleanType value) { 908 this.inactive = value; 909 return this; 910 } 911 912 /** 913 * @return A flag to indicate that the member is no longer in the group, but previously may have been a member. 914 */ 915 public boolean getInactive() { 916 return this.inactive == null || this.inactive.isEmpty() ? false : this.inactive.getValue(); 917 } 918 919 /** 920 * @param value A flag to indicate that the member is no longer in the group, but previously may have been a member. 921 */ 922 public GroupMemberComponent setInactive(boolean value) { 923 if (this.inactive == null) 924 this.inactive = new BooleanType(); 925 this.inactive.setValue(value); 926 return this; 927 } 928 929 protected void listChildren(List<Property> children) { 930 super.listChildren(children); 931 children.add(new Property("entity", "Reference(CareTeam|Device|Group|HealthcareService|Location|Organization|Patient|Practitioner|PractitionerRole|RelatedPerson|Specimen)", "A reference to the entity that is a member of the group. Must be consistent with Group.type. If the entity is another group, then the type must be the same.", 0, 1, entity)); 932 children.add(new Property("period", "Period", "The period that the member was in the group, if known.", 0, 1, period)); 933 children.add(new Property("inactive", "boolean", "A flag to indicate that the member is no longer in the group, but previously may have been a member.", 0, 1, inactive)); 934 } 935 936 @Override 937 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 938 switch (_hash) { 939 case -1298275357: /*entity*/ return new Property("entity", "Reference(CareTeam|Device|Group|HealthcareService|Location|Organization|Patient|Practitioner|PractitionerRole|RelatedPerson|Specimen)", "A reference to the entity that is a member of the group. Must be consistent with Group.type. If the entity is another group, then the type must be the same.", 0, 1, entity); 940 case -991726143: /*period*/ return new Property("period", "Period", "The period that the member was in the group, if known.", 0, 1, period); 941 case 24665195: /*inactive*/ return new Property("inactive", "boolean", "A flag to indicate that the member is no longer in the group, but previously may have been a member.", 0, 1, inactive); 942 default: return super.getNamedProperty(_hash, _name, _checkValid); 943 } 944 945 } 946 947 @Override 948 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 949 switch (hash) { 950 case -1298275357: /*entity*/ return this.entity == null ? new Base[0] : new Base[] {this.entity}; // Reference 951 case -991726143: /*period*/ return this.period == null ? new Base[0] : new Base[] {this.period}; // Period 952 case 24665195: /*inactive*/ return this.inactive == null ? new Base[0] : new Base[] {this.inactive}; // BooleanType 953 default: return super.getProperty(hash, name, checkValid); 954 } 955 956 } 957 958 @Override 959 public Base setProperty(int hash, String name, Base value) throws FHIRException { 960 switch (hash) { 961 case -1298275357: // entity 962 this.entity = TypeConvertor.castToReference(value); // Reference 963 return value; 964 case -991726143: // period 965 this.period = TypeConvertor.castToPeriod(value); // Period 966 return value; 967 case 24665195: // inactive 968 this.inactive = TypeConvertor.castToBoolean(value); // BooleanType 969 return value; 970 default: return super.setProperty(hash, name, value); 971 } 972 973 } 974 975 @Override 976 public Base setProperty(String name, Base value) throws FHIRException { 977 if (name.equals("entity")) { 978 this.entity = TypeConvertor.castToReference(value); // Reference 979 } else if (name.equals("period")) { 980 this.period = TypeConvertor.castToPeriod(value); // Period 981 } else if (name.equals("inactive")) { 982 this.inactive = TypeConvertor.castToBoolean(value); // BooleanType 983 } else 984 return super.setProperty(name, value); 985 return value; 986 } 987 988 @Override 989 public Base makeProperty(int hash, String name) throws FHIRException { 990 switch (hash) { 991 case -1298275357: return getEntity(); 992 case -991726143: return getPeriod(); 993 case 24665195: return getInactiveElement(); 994 default: return super.makeProperty(hash, name); 995 } 996 997 } 998 999 @Override 1000 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1001 switch (hash) { 1002 case -1298275357: /*entity*/ return new String[] {"Reference"}; 1003 case -991726143: /*period*/ return new String[] {"Period"}; 1004 case 24665195: /*inactive*/ return new String[] {"boolean"}; 1005 default: return super.getTypesForProperty(hash, name); 1006 } 1007 1008 } 1009 1010 @Override 1011 public Base addChild(String name) throws FHIRException { 1012 if (name.equals("entity")) { 1013 this.entity = new Reference(); 1014 return this.entity; 1015 } 1016 else if (name.equals("period")) { 1017 this.period = new Period(); 1018 return this.period; 1019 } 1020 else if (name.equals("inactive")) { 1021 throw new FHIRException("Cannot call addChild on a singleton property Group.member.inactive"); 1022 } 1023 else 1024 return super.addChild(name); 1025 } 1026 1027 public GroupMemberComponent copy() { 1028 GroupMemberComponent dst = new GroupMemberComponent(); 1029 copyValues(dst); 1030 return dst; 1031 } 1032 1033 public void copyValues(GroupMemberComponent dst) { 1034 super.copyValues(dst); 1035 dst.entity = entity == null ? null : entity.copy(); 1036 dst.period = period == null ? null : period.copy(); 1037 dst.inactive = inactive == null ? null : inactive.copy(); 1038 } 1039 1040 @Override 1041 public boolean equalsDeep(Base other_) { 1042 if (!super.equalsDeep(other_)) 1043 return false; 1044 if (!(other_ instanceof GroupMemberComponent)) 1045 return false; 1046 GroupMemberComponent o = (GroupMemberComponent) other_; 1047 return compareDeep(entity, o.entity, true) && compareDeep(period, o.period, true) && compareDeep(inactive, o.inactive, true) 1048 ; 1049 } 1050 1051 @Override 1052 public boolean equalsShallow(Base other_) { 1053 if (!super.equalsShallow(other_)) 1054 return false; 1055 if (!(other_ instanceof GroupMemberComponent)) 1056 return false; 1057 GroupMemberComponent o = (GroupMemberComponent) other_; 1058 return compareValues(inactive, o.inactive, true); 1059 } 1060 1061 public boolean isEmpty() { 1062 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(entity, period, inactive 1063 ); 1064 } 1065 1066 public String fhirType() { 1067 return "Group.member"; 1068 1069 } 1070 1071 } 1072 1073 /** 1074 * Business identifiers assigned to this participant by one of the applications involved. These identifiers remain constant as the resource is updated and propagates from server to server. 1075 */ 1076 @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1077 @Description(shortDefinition="Business Identifier for this Group", formalDefinition="Business identifiers assigned to this participant by one of the applications involved. These identifiers remain constant as the resource is updated and propagates from server to server." ) 1078 protected List<Identifier> identifier; 1079 1080 /** 1081 * Indicates whether the record for the group is available for use or is merely being retained for historical purposes. 1082 */ 1083 @Child(name = "active", type = {BooleanType.class}, order=1, min=0, max=1, modifier=true, summary=true) 1084 @Description(shortDefinition="Whether this group's record is in active use", formalDefinition="Indicates whether the record for the group is available for use or is merely being retained for historical purposes." ) 1085 protected BooleanType active; 1086 1087 /** 1088 * Identifies the broad classification of the kind of resources the group includes. 1089 */ 1090 @Child(name = "type", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=true) 1091 @Description(shortDefinition="person | animal | practitioner | device | careteam | healthcareservice | location | organization | relatedperson | specimen", formalDefinition="Identifies the broad classification of the kind of resources the group includes." ) 1092 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/group-type") 1093 protected Enumeration<GroupType> type; 1094 1095 /** 1096 * Basis for membership in the Group: 1097 1098* 'definitional': The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete. 1099* 'enumerated': The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member. 1100 */ 1101 @Child(name = "membership", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true) 1102 @Description(shortDefinition="definitional | enumerated", formalDefinition="Basis for membership in the Group:\n\n* 'definitional': The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete.\n* 'enumerated': The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member." ) 1103 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/group-membership-basis") 1104 protected Enumeration<GroupMembershipBasis> membership; 1105 1106 /** 1107 * Provides a specific type of resource the group includes; e.g. "cow", "syringe", etc. 1108 */ 1109 @Child(name = "code", type = {CodeableConcept.class}, order=4, min=0, max=1, modifier=false, summary=true) 1110 @Description(shortDefinition="Kind of Group members", formalDefinition="Provides a specific type of resource the group includes; e.g. \"cow\", \"syringe\", etc." ) 1111 protected CodeableConcept code; 1112 1113 /** 1114 * A label assigned to the group for human identification and communication. 1115 */ 1116 @Child(name = "name", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true) 1117 @Description(shortDefinition="Label for Group", formalDefinition="A label assigned to the group for human identification and communication." ) 1118 protected StringType name; 1119 1120 /** 1121 * Explanation of what the group represents and how it is intended to be used. 1122 */ 1123 @Child(name = "description", type = {MarkdownType.class}, order=6, min=0, max=1, modifier=false, summary=false) 1124 @Description(shortDefinition="Natural language description of the group", formalDefinition="Explanation of what the group represents and how it is intended to be used." ) 1125 protected MarkdownType description; 1126 1127 /** 1128 * A count of the number of resource instances that are part of the group. 1129 */ 1130 @Child(name = "quantity", type = {UnsignedIntType.class}, order=7, min=0, max=1, modifier=false, summary=true) 1131 @Description(shortDefinition="Number of members", formalDefinition="A count of the number of resource instances that are part of the group." ) 1132 protected UnsignedIntType quantity; 1133 1134 /** 1135 * Entity responsible for defining and maintaining Group characteristics and/or registered members. 1136 */ 1137 @Child(name = "managingEntity", type = {Organization.class, RelatedPerson.class, Practitioner.class, PractitionerRole.class}, order=8, min=0, max=1, modifier=false, summary=true) 1138 @Description(shortDefinition="Entity that is the custodian of the Group's definition", formalDefinition="Entity responsible for defining and maintaining Group characteristics and/or registered members." ) 1139 protected Reference managingEntity; 1140 1141 /** 1142 * Identifies traits whose presence r absence is shared by members of the group. 1143 */ 1144 @Child(name = "characteristic", type = {}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1145 @Description(shortDefinition="Include / Exclude group members by Trait", formalDefinition="Identifies traits whose presence r absence is shared by members of the group." ) 1146 protected List<GroupCharacteristicComponent> characteristic; 1147 1148 /** 1149 * Identifies the resource instances that are members of the group. 1150 */ 1151 @Child(name = "member", type = {}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1152 @Description(shortDefinition="Who or what is in group", formalDefinition="Identifies the resource instances that are members of the group." ) 1153 protected List<GroupMemberComponent> member; 1154 1155 private static final long serialVersionUID = -39542514L; 1156 1157 /** 1158 * Constructor 1159 */ 1160 public Group() { 1161 super(); 1162 } 1163 1164 /** 1165 * Constructor 1166 */ 1167 public Group(GroupType type, GroupMembershipBasis membership) { 1168 super(); 1169 this.setType(type); 1170 this.setMembership(membership); 1171 } 1172 1173 /** 1174 * @return {@link #identifier} (Business identifiers assigned to this participant by one of the applications involved. These identifiers remain constant as the resource is updated and propagates from server to server.) 1175 */ 1176 public List<Identifier> getIdentifier() { 1177 if (this.identifier == null) 1178 this.identifier = new ArrayList<Identifier>(); 1179 return this.identifier; 1180 } 1181 1182 /** 1183 * @return Returns a reference to <code>this</code> for easy method chaining 1184 */ 1185 public Group setIdentifier(List<Identifier> theIdentifier) { 1186 this.identifier = theIdentifier; 1187 return this; 1188 } 1189 1190 public boolean hasIdentifier() { 1191 if (this.identifier == null) 1192 return false; 1193 for (Identifier item : this.identifier) 1194 if (!item.isEmpty()) 1195 return true; 1196 return false; 1197 } 1198 1199 public Identifier addIdentifier() { //3 1200 Identifier t = new Identifier(); 1201 if (this.identifier == null) 1202 this.identifier = new ArrayList<Identifier>(); 1203 this.identifier.add(t); 1204 return t; 1205 } 1206 1207 public Group addIdentifier(Identifier t) { //3 1208 if (t == null) 1209 return this; 1210 if (this.identifier == null) 1211 this.identifier = new ArrayList<Identifier>(); 1212 this.identifier.add(t); 1213 return this; 1214 } 1215 1216 /** 1217 * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3} 1218 */ 1219 public Identifier getIdentifierFirstRep() { 1220 if (getIdentifier().isEmpty()) { 1221 addIdentifier(); 1222 } 1223 return getIdentifier().get(0); 1224 } 1225 1226 /** 1227 * @return {@link #active} (Indicates whether the record for the group is available for use or is merely being retained for historical purposes.). This is the underlying object with id, value and extensions. The accessor "getActive" gives direct access to the value 1228 */ 1229 public BooleanType getActiveElement() { 1230 if (this.active == null) 1231 if (Configuration.errorOnAutoCreate()) 1232 throw new Error("Attempt to auto-create Group.active"); 1233 else if (Configuration.doAutoCreate()) 1234 this.active = new BooleanType(); // bb 1235 return this.active; 1236 } 1237 1238 public boolean hasActiveElement() { 1239 return this.active != null && !this.active.isEmpty(); 1240 } 1241 1242 public boolean hasActive() { 1243 return this.active != null && !this.active.isEmpty(); 1244 } 1245 1246 /** 1247 * @param value {@link #active} (Indicates whether the record for the group is available for use or is merely being retained for historical purposes.). This is the underlying object with id, value and extensions. The accessor "getActive" gives direct access to the value 1248 */ 1249 public Group setActiveElement(BooleanType value) { 1250 this.active = value; 1251 return this; 1252 } 1253 1254 /** 1255 * @return Indicates whether the record for the group is available for use or is merely being retained for historical purposes. 1256 */ 1257 public boolean getActive() { 1258 return this.active == null || this.active.isEmpty() ? false : this.active.getValue(); 1259 } 1260 1261 /** 1262 * @param value Indicates whether the record for the group is available for use or is merely being retained for historical purposes. 1263 */ 1264 public Group setActive(boolean value) { 1265 if (this.active == null) 1266 this.active = new BooleanType(); 1267 this.active.setValue(value); 1268 return this; 1269 } 1270 1271 /** 1272 * @return {@link #type} (Identifies the broad classification of the kind of resources the group includes.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1273 */ 1274 public Enumeration<GroupType> getTypeElement() { 1275 if (this.type == null) 1276 if (Configuration.errorOnAutoCreate()) 1277 throw new Error("Attempt to auto-create Group.type"); 1278 else if (Configuration.doAutoCreate()) 1279 this.type = new Enumeration<GroupType>(new GroupTypeEnumFactory()); // bb 1280 return this.type; 1281 } 1282 1283 public boolean hasTypeElement() { 1284 return this.type != null && !this.type.isEmpty(); 1285 } 1286 1287 public boolean hasType() { 1288 return this.type != null && !this.type.isEmpty(); 1289 } 1290 1291 /** 1292 * @param value {@link #type} (Identifies the broad classification of the kind of resources the group includes.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1293 */ 1294 public Group setTypeElement(Enumeration<GroupType> value) { 1295 this.type = value; 1296 return this; 1297 } 1298 1299 /** 1300 * @return Identifies the broad classification of the kind of resources the group includes. 1301 */ 1302 public GroupType getType() { 1303 return this.type == null ? null : this.type.getValue(); 1304 } 1305 1306 /** 1307 * @param value Identifies the broad classification of the kind of resources the group includes. 1308 */ 1309 public Group setType(GroupType value) { 1310 if (this.type == null) 1311 this.type = new Enumeration<GroupType>(new GroupTypeEnumFactory()); 1312 this.type.setValue(value); 1313 return this; 1314 } 1315 1316 /** 1317 * @return {@link #membership} (Basis for membership in the Group: 1318 1319* 'definitional': The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete. 1320* 'enumerated': The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member.). This is the underlying object with id, value and extensions. The accessor "getMembership" gives direct access to the value 1321 */ 1322 public Enumeration<GroupMembershipBasis> getMembershipElement() { 1323 if (this.membership == null) 1324 if (Configuration.errorOnAutoCreate()) 1325 throw new Error("Attempt to auto-create Group.membership"); 1326 else if (Configuration.doAutoCreate()) 1327 this.membership = new Enumeration<GroupMembershipBasis>(new GroupMembershipBasisEnumFactory()); // bb 1328 return this.membership; 1329 } 1330 1331 public boolean hasMembershipElement() { 1332 return this.membership != null && !this.membership.isEmpty(); 1333 } 1334 1335 public boolean hasMembership() { 1336 return this.membership != null && !this.membership.isEmpty(); 1337 } 1338 1339 /** 1340 * @param value {@link #membership} (Basis for membership in the Group: 1341 1342* 'definitional': The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete. 1343* 'enumerated': The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member.). This is the underlying object with id, value and extensions. The accessor "getMembership" gives direct access to the value 1344 */ 1345 public Group setMembershipElement(Enumeration<GroupMembershipBasis> value) { 1346 this.membership = value; 1347 return this; 1348 } 1349 1350 /** 1351 * @return Basis for membership in the Group: 1352 1353* 'definitional': The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete. 1354* 'enumerated': The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member. 1355 */ 1356 public GroupMembershipBasis getMembership() { 1357 return this.membership == null ? null : this.membership.getValue(); 1358 } 1359 1360 /** 1361 * @param value Basis for membership in the Group: 1362 1363* 'definitional': The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete. 1364* 'enumerated': The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member. 1365 */ 1366 public Group setMembership(GroupMembershipBasis value) { 1367 if (this.membership == null) 1368 this.membership = new Enumeration<GroupMembershipBasis>(new GroupMembershipBasisEnumFactory()); 1369 this.membership.setValue(value); 1370 return this; 1371 } 1372 1373 /** 1374 * @return {@link #code} (Provides a specific type of resource the group includes; e.g. "cow", "syringe", etc.) 1375 */ 1376 public CodeableConcept getCode() { 1377 if (this.code == null) 1378 if (Configuration.errorOnAutoCreate()) 1379 throw new Error("Attempt to auto-create Group.code"); 1380 else if (Configuration.doAutoCreate()) 1381 this.code = new CodeableConcept(); // cc 1382 return this.code; 1383 } 1384 1385 public boolean hasCode() { 1386 return this.code != null && !this.code.isEmpty(); 1387 } 1388 1389 /** 1390 * @param value {@link #code} (Provides a specific type of resource the group includes; e.g. "cow", "syringe", etc.) 1391 */ 1392 public Group setCode(CodeableConcept value) { 1393 this.code = value; 1394 return this; 1395 } 1396 1397 /** 1398 * @return {@link #name} (A label assigned to the group for human identification and communication.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 1399 */ 1400 public StringType getNameElement() { 1401 if (this.name == null) 1402 if (Configuration.errorOnAutoCreate()) 1403 throw new Error("Attempt to auto-create Group.name"); 1404 else if (Configuration.doAutoCreate()) 1405 this.name = new StringType(); // bb 1406 return this.name; 1407 } 1408 1409 public boolean hasNameElement() { 1410 return this.name != null && !this.name.isEmpty(); 1411 } 1412 1413 public boolean hasName() { 1414 return this.name != null && !this.name.isEmpty(); 1415 } 1416 1417 /** 1418 * @param value {@link #name} (A label assigned to the group for human identification and communication.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 1419 */ 1420 public Group setNameElement(StringType value) { 1421 this.name = value; 1422 return this; 1423 } 1424 1425 /** 1426 * @return A label assigned to the group for human identification and communication. 1427 */ 1428 public String getName() { 1429 return this.name == null ? null : this.name.getValue(); 1430 } 1431 1432 /** 1433 * @param value A label assigned to the group for human identification and communication. 1434 */ 1435 public Group setName(String value) { 1436 if (Utilities.noString(value)) 1437 this.name = null; 1438 else { 1439 if (this.name == null) 1440 this.name = new StringType(); 1441 this.name.setValue(value); 1442 } 1443 return this; 1444 } 1445 1446 /** 1447 * @return {@link #description} (Explanation of what the group represents and how it is intended to be used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1448 */ 1449 public MarkdownType getDescriptionElement() { 1450 if (this.description == null) 1451 if (Configuration.errorOnAutoCreate()) 1452 throw new Error("Attempt to auto-create Group.description"); 1453 else if (Configuration.doAutoCreate()) 1454 this.description = new MarkdownType(); // bb 1455 return this.description; 1456 } 1457 1458 public boolean hasDescriptionElement() { 1459 return this.description != null && !this.description.isEmpty(); 1460 } 1461 1462 public boolean hasDescription() { 1463 return this.description != null && !this.description.isEmpty(); 1464 } 1465 1466 /** 1467 * @param value {@link #description} (Explanation of what the group represents and how it is intended to be used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1468 */ 1469 public Group setDescriptionElement(MarkdownType value) { 1470 this.description = value; 1471 return this; 1472 } 1473 1474 /** 1475 * @return Explanation of what the group represents and how it is intended to be used. 1476 */ 1477 public String getDescription() { 1478 return this.description == null ? null : this.description.getValue(); 1479 } 1480 1481 /** 1482 * @param value Explanation of what the group represents and how it is intended to be used. 1483 */ 1484 public Group setDescription(String value) { 1485 if (Utilities.noString(value)) 1486 this.description = null; 1487 else { 1488 if (this.description == null) 1489 this.description = new MarkdownType(); 1490 this.description.setValue(value); 1491 } 1492 return this; 1493 } 1494 1495 /** 1496 * @return {@link #quantity} (A count of the number of resource instances that are part of the group.). This is the underlying object with id, value and extensions. The accessor "getQuantity" gives direct access to the value 1497 */ 1498 public UnsignedIntType getQuantityElement() { 1499 if (this.quantity == null) 1500 if (Configuration.errorOnAutoCreate()) 1501 throw new Error("Attempt to auto-create Group.quantity"); 1502 else if (Configuration.doAutoCreate()) 1503 this.quantity = new UnsignedIntType(); // bb 1504 return this.quantity; 1505 } 1506 1507 public boolean hasQuantityElement() { 1508 return this.quantity != null && !this.quantity.isEmpty(); 1509 } 1510 1511 public boolean hasQuantity() { 1512 return this.quantity != null && !this.quantity.isEmpty(); 1513 } 1514 1515 /** 1516 * @param value {@link #quantity} (A count of the number of resource instances that are part of the group.). This is the underlying object with id, value and extensions. The accessor "getQuantity" gives direct access to the value 1517 */ 1518 public Group setQuantityElement(UnsignedIntType value) { 1519 this.quantity = value; 1520 return this; 1521 } 1522 1523 /** 1524 * @return A count of the number of resource instances that are part of the group. 1525 */ 1526 public int getQuantity() { 1527 return this.quantity == null || this.quantity.isEmpty() ? 0 : this.quantity.getValue(); 1528 } 1529 1530 /** 1531 * @param value A count of the number of resource instances that are part of the group. 1532 */ 1533 public Group setQuantity(int value) { 1534 if (this.quantity == null) 1535 this.quantity = new UnsignedIntType(); 1536 this.quantity.setValue(value); 1537 return this; 1538 } 1539 1540 /** 1541 * @return {@link #managingEntity} (Entity responsible for defining and maintaining Group characteristics and/or registered members.) 1542 */ 1543 public Reference getManagingEntity() { 1544 if (this.managingEntity == null) 1545 if (Configuration.errorOnAutoCreate()) 1546 throw new Error("Attempt to auto-create Group.managingEntity"); 1547 else if (Configuration.doAutoCreate()) 1548 this.managingEntity = new Reference(); // cc 1549 return this.managingEntity; 1550 } 1551 1552 public boolean hasManagingEntity() { 1553 return this.managingEntity != null && !this.managingEntity.isEmpty(); 1554 } 1555 1556 /** 1557 * @param value {@link #managingEntity} (Entity responsible for defining and maintaining Group characteristics and/or registered members.) 1558 */ 1559 public Group setManagingEntity(Reference value) { 1560 this.managingEntity = value; 1561 return this; 1562 } 1563 1564 /** 1565 * @return {@link #characteristic} (Identifies traits whose presence r absence is shared by members of the group.) 1566 */ 1567 public List<GroupCharacteristicComponent> getCharacteristic() { 1568 if (this.characteristic == null) 1569 this.characteristic = new ArrayList<GroupCharacteristicComponent>(); 1570 return this.characteristic; 1571 } 1572 1573 /** 1574 * @return Returns a reference to <code>this</code> for easy method chaining 1575 */ 1576 public Group setCharacteristic(List<GroupCharacteristicComponent> theCharacteristic) { 1577 this.characteristic = theCharacteristic; 1578 return this; 1579 } 1580 1581 public boolean hasCharacteristic() { 1582 if (this.characteristic == null) 1583 return false; 1584 for (GroupCharacteristicComponent item : this.characteristic) 1585 if (!item.isEmpty()) 1586 return true; 1587 return false; 1588 } 1589 1590 public GroupCharacteristicComponent addCharacteristic() { //3 1591 GroupCharacteristicComponent t = new GroupCharacteristicComponent(); 1592 if (this.characteristic == null) 1593 this.characteristic = new ArrayList<GroupCharacteristicComponent>(); 1594 this.characteristic.add(t); 1595 return t; 1596 } 1597 1598 public Group addCharacteristic(GroupCharacteristicComponent t) { //3 1599 if (t == null) 1600 return this; 1601 if (this.characteristic == null) 1602 this.characteristic = new ArrayList<GroupCharacteristicComponent>(); 1603 this.characteristic.add(t); 1604 return this; 1605 } 1606 1607 /** 1608 * @return The first repetition of repeating field {@link #characteristic}, creating it if it does not already exist {3} 1609 */ 1610 public GroupCharacteristicComponent getCharacteristicFirstRep() { 1611 if (getCharacteristic().isEmpty()) { 1612 addCharacteristic(); 1613 } 1614 return getCharacteristic().get(0); 1615 } 1616 1617 /** 1618 * @return {@link #member} (Identifies the resource instances that are members of the group.) 1619 */ 1620 public List<GroupMemberComponent> getMember() { 1621 if (this.member == null) 1622 this.member = new ArrayList<GroupMemberComponent>(); 1623 return this.member; 1624 } 1625 1626 /** 1627 * @return Returns a reference to <code>this</code> for easy method chaining 1628 */ 1629 public Group setMember(List<GroupMemberComponent> theMember) { 1630 this.member = theMember; 1631 return this; 1632 } 1633 1634 public boolean hasMember() { 1635 if (this.member == null) 1636 return false; 1637 for (GroupMemberComponent item : this.member) 1638 if (!item.isEmpty()) 1639 return true; 1640 return false; 1641 } 1642 1643 public GroupMemberComponent addMember() { //3 1644 GroupMemberComponent t = new GroupMemberComponent(); 1645 if (this.member == null) 1646 this.member = new ArrayList<GroupMemberComponent>(); 1647 this.member.add(t); 1648 return t; 1649 } 1650 1651 public Group addMember(GroupMemberComponent t) { //3 1652 if (t == null) 1653 return this; 1654 if (this.member == null) 1655 this.member = new ArrayList<GroupMemberComponent>(); 1656 this.member.add(t); 1657 return this; 1658 } 1659 1660 /** 1661 * @return The first repetition of repeating field {@link #member}, creating it if it does not already exist {3} 1662 */ 1663 public GroupMemberComponent getMemberFirstRep() { 1664 if (getMember().isEmpty()) { 1665 addMember(); 1666 } 1667 return getMember().get(0); 1668 } 1669 1670 protected void listChildren(List<Property> children) { 1671 super.listChildren(children); 1672 children.add(new Property("identifier", "Identifier", "Business identifiers assigned to this participant by one of the applications involved. These identifiers remain constant as the resource is updated and propagates from server to server.", 0, java.lang.Integer.MAX_VALUE, identifier)); 1673 children.add(new Property("active", "boolean", "Indicates whether the record for the group is available for use or is merely being retained for historical purposes.", 0, 1, active)); 1674 children.add(new Property("type", "code", "Identifies the broad classification of the kind of resources the group includes.", 0, 1, type)); 1675 children.add(new Property("membership", "code", "Basis for membership in the Group:\n\n* 'definitional': The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete.\n* 'enumerated': The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member.", 0, 1, membership)); 1676 children.add(new Property("code", "CodeableConcept", "Provides a specific type of resource the group includes; e.g. \"cow\", \"syringe\", etc.", 0, 1, code)); 1677 children.add(new Property("name", "string", "A label assigned to the group for human identification and communication.", 0, 1, name)); 1678 children.add(new Property("description", "markdown", "Explanation of what the group represents and how it is intended to be used.", 0, 1, description)); 1679 children.add(new Property("quantity", "unsignedInt", "A count of the number of resource instances that are part of the group.", 0, 1, quantity)); 1680 children.add(new Property("managingEntity", "Reference(Organization|RelatedPerson|Practitioner|PractitionerRole)", "Entity responsible for defining and maintaining Group characteristics and/or registered members.", 0, 1, managingEntity)); 1681 children.add(new Property("characteristic", "", "Identifies traits whose presence r absence is shared by members of the group.", 0, java.lang.Integer.MAX_VALUE, characteristic)); 1682 children.add(new Property("member", "", "Identifies the resource instances that are members of the group.", 0, java.lang.Integer.MAX_VALUE, member)); 1683 } 1684 1685 @Override 1686 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1687 switch (_hash) { 1688 case -1618432855: /*identifier*/ return new Property("identifier", "Identifier", "Business identifiers assigned to this participant by one of the applications involved. These identifiers remain constant as the resource is updated and propagates from server to server.", 0, java.lang.Integer.MAX_VALUE, identifier); 1689 case -1422950650: /*active*/ return new Property("active", "boolean", "Indicates whether the record for the group is available for use or is merely being retained for historical purposes.", 0, 1, active); 1690 case 3575610: /*type*/ return new Property("type", "code", "Identifies the broad classification of the kind of resources the group includes.", 0, 1, type); 1691 case -1340241962: /*membership*/ return new Property("membership", "code", "Basis for membership in the Group:\n\n* 'definitional': The Group.characteristics specified are both necessary and sufficient to determine membership. All entities that meet the criteria are considered to be members of the group, whether referenced by the group or not. If members are present, they are individuals that happen to be known as meeting the Group.characteristics. The list cannot be presumed to be complete.\n* 'enumerated': The Group.characteristics are necessary but not sufficient to determine membership. Membership is determined by being listed as one of the Group.member.", 0, 1, membership); 1692 case 3059181: /*code*/ return new Property("code", "CodeableConcept", "Provides a specific type of resource the group includes; e.g. \"cow\", \"syringe\", etc.", 0, 1, code); 1693 case 3373707: /*name*/ return new Property("name", "string", "A label assigned to the group for human identification and communication.", 0, 1, name); 1694 case -1724546052: /*description*/ return new Property("description", "markdown", "Explanation of what the group represents and how it is intended to be used.", 0, 1, description); 1695 case -1285004149: /*quantity*/ return new Property("quantity", "unsignedInt", "A count of the number of resource instances that are part of the group.", 0, 1, quantity); 1696 case -988474523: /*managingEntity*/ return new Property("managingEntity", "Reference(Organization|RelatedPerson|Practitioner|PractitionerRole)", "Entity responsible for defining and maintaining Group characteristics and/or registered members.", 0, 1, managingEntity); 1697 case 366313883: /*characteristic*/ return new Property("characteristic", "", "Identifies traits whose presence r absence is shared by members of the group.", 0, java.lang.Integer.MAX_VALUE, characteristic); 1698 case -1077769574: /*member*/ return new Property("member", "", "Identifies the resource instances that are members of the group.", 0, java.lang.Integer.MAX_VALUE, member); 1699 default: return super.getNamedProperty(_hash, _name, _checkValid); 1700 } 1701 1702 } 1703 1704 @Override 1705 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1706 switch (hash) { 1707 case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 1708 case -1422950650: /*active*/ return this.active == null ? new Base[0] : new Base[] {this.active}; // BooleanType 1709 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<GroupType> 1710 case -1340241962: /*membership*/ return this.membership == null ? new Base[0] : new Base[] {this.membership}; // Enumeration<GroupMembershipBasis> 1711 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept 1712 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 1713 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 1714 case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // UnsignedIntType 1715 case -988474523: /*managingEntity*/ return this.managingEntity == null ? new Base[0] : new Base[] {this.managingEntity}; // Reference 1716 case 366313883: /*characteristic*/ return this.characteristic == null ? new Base[0] : this.characteristic.toArray(new Base[this.characteristic.size()]); // GroupCharacteristicComponent 1717 case -1077769574: /*member*/ return this.member == null ? new Base[0] : this.member.toArray(new Base[this.member.size()]); // GroupMemberComponent 1718 default: return super.getProperty(hash, name, checkValid); 1719 } 1720 1721 } 1722 1723 @Override 1724 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1725 switch (hash) { 1726 case -1618432855: // identifier 1727 this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier 1728 return value; 1729 case -1422950650: // active 1730 this.active = TypeConvertor.castToBoolean(value); // BooleanType 1731 return value; 1732 case 3575610: // type 1733 value = new GroupTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 1734 this.type = (Enumeration) value; // Enumeration<GroupType> 1735 return value; 1736 case -1340241962: // membership 1737 value = new GroupMembershipBasisEnumFactory().fromType(TypeConvertor.castToCode(value)); 1738 this.membership = (Enumeration) value; // Enumeration<GroupMembershipBasis> 1739 return value; 1740 case 3059181: // code 1741 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 1742 return value; 1743 case 3373707: // name 1744 this.name = TypeConvertor.castToString(value); // StringType 1745 return value; 1746 case -1724546052: // description 1747 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 1748 return value; 1749 case -1285004149: // quantity 1750 this.quantity = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType 1751 return value; 1752 case -988474523: // managingEntity 1753 this.managingEntity = TypeConvertor.castToReference(value); // Reference 1754 return value; 1755 case 366313883: // characteristic 1756 this.getCharacteristic().add((GroupCharacteristicComponent) value); // GroupCharacteristicComponent 1757 return value; 1758 case -1077769574: // member 1759 this.getMember().add((GroupMemberComponent) value); // GroupMemberComponent 1760 return value; 1761 default: return super.setProperty(hash, name, value); 1762 } 1763 1764 } 1765 1766 @Override 1767 public Base setProperty(String name, Base value) throws FHIRException { 1768 if (name.equals("identifier")) { 1769 this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); 1770 } else if (name.equals("active")) { 1771 this.active = TypeConvertor.castToBoolean(value); // BooleanType 1772 } else if (name.equals("type")) { 1773 value = new GroupTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 1774 this.type = (Enumeration) value; // Enumeration<GroupType> 1775 } else if (name.equals("membership")) { 1776 value = new GroupMembershipBasisEnumFactory().fromType(TypeConvertor.castToCode(value)); 1777 this.membership = (Enumeration) value; // Enumeration<GroupMembershipBasis> 1778 } else if (name.equals("code")) { 1779 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 1780 } else if (name.equals("name")) { 1781 this.name = TypeConvertor.castToString(value); // StringType 1782 } else if (name.equals("description")) { 1783 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 1784 } else if (name.equals("quantity")) { 1785 this.quantity = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType 1786 } else if (name.equals("managingEntity")) { 1787 this.managingEntity = TypeConvertor.castToReference(value); // Reference 1788 } else if (name.equals("characteristic")) { 1789 this.getCharacteristic().add((GroupCharacteristicComponent) value); 1790 } else if (name.equals("member")) { 1791 this.getMember().add((GroupMemberComponent) value); 1792 } else 1793 return super.setProperty(name, value); 1794 return value; 1795 } 1796 1797 @Override 1798 public Base makeProperty(int hash, String name) throws FHIRException { 1799 switch (hash) { 1800 case -1618432855: return addIdentifier(); 1801 case -1422950650: return getActiveElement(); 1802 case 3575610: return getTypeElement(); 1803 case -1340241962: return getMembershipElement(); 1804 case 3059181: return getCode(); 1805 case 3373707: return getNameElement(); 1806 case -1724546052: return getDescriptionElement(); 1807 case -1285004149: return getQuantityElement(); 1808 case -988474523: return getManagingEntity(); 1809 case 366313883: return addCharacteristic(); 1810 case -1077769574: return addMember(); 1811 default: return super.makeProperty(hash, name); 1812 } 1813 1814 } 1815 1816 @Override 1817 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1818 switch (hash) { 1819 case -1618432855: /*identifier*/ return new String[] {"Identifier"}; 1820 case -1422950650: /*active*/ return new String[] {"boolean"}; 1821 case 3575610: /*type*/ return new String[] {"code"}; 1822 case -1340241962: /*membership*/ return new String[] {"code"}; 1823 case 3059181: /*code*/ return new String[] {"CodeableConcept"}; 1824 case 3373707: /*name*/ return new String[] {"string"}; 1825 case -1724546052: /*description*/ return new String[] {"markdown"}; 1826 case -1285004149: /*quantity*/ return new String[] {"unsignedInt"}; 1827 case -988474523: /*managingEntity*/ return new String[] {"Reference"}; 1828 case 366313883: /*characteristic*/ return new String[] {}; 1829 case -1077769574: /*member*/ return new String[] {}; 1830 default: return super.getTypesForProperty(hash, name); 1831 } 1832 1833 } 1834 1835 @Override 1836 public Base addChild(String name) throws FHIRException { 1837 if (name.equals("identifier")) { 1838 return addIdentifier(); 1839 } 1840 else if (name.equals("active")) { 1841 throw new FHIRException("Cannot call addChild on a singleton property Group.active"); 1842 } 1843 else if (name.equals("type")) { 1844 throw new FHIRException("Cannot call addChild on a singleton property Group.type"); 1845 } 1846 else if (name.equals("membership")) { 1847 throw new FHIRException("Cannot call addChild on a singleton property Group.membership"); 1848 } 1849 else if (name.equals("code")) { 1850 this.code = new CodeableConcept(); 1851 return this.code; 1852 } 1853 else if (name.equals("name")) { 1854 throw new FHIRException("Cannot call addChild on a singleton property Group.name"); 1855 } 1856 else if (name.equals("description")) { 1857 throw new FHIRException("Cannot call addChild on a singleton property Group.description"); 1858 } 1859 else if (name.equals("quantity")) { 1860 throw new FHIRException("Cannot call addChild on a singleton property Group.quantity"); 1861 } 1862 else if (name.equals("managingEntity")) { 1863 this.managingEntity = new Reference(); 1864 return this.managingEntity; 1865 } 1866 else if (name.equals("characteristic")) { 1867 return addCharacteristic(); 1868 } 1869 else if (name.equals("member")) { 1870 return addMember(); 1871 } 1872 else 1873 return super.addChild(name); 1874 } 1875 1876 public String fhirType() { 1877 return "Group"; 1878 1879 } 1880 1881 public Group copy() { 1882 Group dst = new Group(); 1883 copyValues(dst); 1884 return dst; 1885 } 1886 1887 public void copyValues(Group dst) { 1888 super.copyValues(dst); 1889 if (identifier != null) { 1890 dst.identifier = new ArrayList<Identifier>(); 1891 for (Identifier i : identifier) 1892 dst.identifier.add(i.copy()); 1893 }; 1894 dst.active = active == null ? null : active.copy(); 1895 dst.type = type == null ? null : type.copy(); 1896 dst.membership = membership == null ? null : membership.copy(); 1897 dst.code = code == null ? null : code.copy(); 1898 dst.name = name == null ? null : name.copy(); 1899 dst.description = description == null ? null : description.copy(); 1900 dst.quantity = quantity == null ? null : quantity.copy(); 1901 dst.managingEntity = managingEntity == null ? null : managingEntity.copy(); 1902 if (characteristic != null) { 1903 dst.characteristic = new ArrayList<GroupCharacteristicComponent>(); 1904 for (GroupCharacteristicComponent i : characteristic) 1905 dst.characteristic.add(i.copy()); 1906 }; 1907 if (member != null) { 1908 dst.member = new ArrayList<GroupMemberComponent>(); 1909 for (GroupMemberComponent i : member) 1910 dst.member.add(i.copy()); 1911 }; 1912 } 1913 1914 protected Group typedCopy() { 1915 return copy(); 1916 } 1917 1918 @Override 1919 public boolean equalsDeep(Base other_) { 1920 if (!super.equalsDeep(other_)) 1921 return false; 1922 if (!(other_ instanceof Group)) 1923 return false; 1924 Group o = (Group) other_; 1925 return compareDeep(identifier, o.identifier, true) && compareDeep(active, o.active, true) && compareDeep(type, o.type, true) 1926 && compareDeep(membership, o.membership, true) && compareDeep(code, o.code, true) && compareDeep(name, o.name, true) 1927 && compareDeep(description, o.description, true) && compareDeep(quantity, o.quantity, true) && compareDeep(managingEntity, o.managingEntity, true) 1928 && compareDeep(characteristic, o.characteristic, true) && compareDeep(member, o.member, true); 1929 } 1930 1931 @Override 1932 public boolean equalsShallow(Base other_) { 1933 if (!super.equalsShallow(other_)) 1934 return false; 1935 if (!(other_ instanceof Group)) 1936 return false; 1937 Group o = (Group) other_; 1938 return compareValues(active, o.active, true) && compareValues(type, o.type, true) && compareValues(membership, o.membership, true) 1939 && compareValues(name, o.name, true) && compareValues(description, o.description, true) && compareValues(quantity, o.quantity, true) 1940 ; 1941 } 1942 1943 public boolean isEmpty() { 1944 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, active, type 1945 , membership, code, name, description, quantity, managingEntity, characteristic 1946 , member); 1947 } 1948 1949 @Override 1950 public ResourceType getResourceType() { 1951 return ResourceType.Group; 1952 } 1953 1954 /** 1955 * Search parameter: <b>characteristic-reference</b> 1956 * <p> 1957 * Description: <b>An entity referenced in a characteristic</b><br> 1958 * Type: <b>reference</b><br> 1959 * Path: <b>(Group.characteristic.value.ofType(Reference))</b><br> 1960 * </p> 1961 */ 1962 @SearchParamDefinition(name="characteristic-reference", path="(Group.characteristic.value.ofType(Reference))", description="An entity referenced in a characteristic", type="reference", target={Account.class, ActivityDefinition.class, ActorDefinition.class, AdministrableProductDefinition.class, AdverseEvent.class, AllergyIntolerance.class, Appointment.class, AppointmentResponse.class, ArtifactAssessment.class, AuditEvent.class, Basic.class, Binary.class, BiologicallyDerivedProduct.class, BiologicallyDerivedProductDispense.class, BodyStructure.class, Bundle.class, CapabilityStatement.class, CarePlan.class, CareTeam.class, ChargeItem.class, ChargeItemDefinition.class, Citation.class, Claim.class, ClaimResponse.class, ClinicalImpression.class, ClinicalUseDefinition.class, CodeSystem.class, Communication.class, CommunicationRequest.class, CompartmentDefinition.class, Composition.class, ConceptMap.class, Condition.class, ConditionDefinition.class, Consent.class, Contract.class, Coverage.class, CoverageEligibilityRequest.class, CoverageEligibilityResponse.class, DetectedIssue.class, Device.class, DeviceAssociation.class, DeviceDefinition.class, DeviceDispense.class, DeviceMetric.class, DeviceRequest.class, DeviceUsage.class, DiagnosticReport.class, DocumentReference.class, Encounter.class, EncounterHistory.class, Endpoint.class, EnrollmentRequest.class, EnrollmentResponse.class, EpisodeOfCare.class, EventDefinition.class, Evidence.class, EvidenceReport.class, EvidenceVariable.class, ExampleScenario.class, ExplanationOfBenefit.class, FamilyMemberHistory.class, Flag.class, FormularyItem.class, GenomicStudy.class, Goal.class, GraphDefinition.class, Group.class, GuidanceResponse.class, HealthcareService.class, ImagingSelection.class, ImagingStudy.class, Immunization.class, ImmunizationEvaluation.class, ImmunizationRecommendation.class, ImplementationGuide.class, Ingredient.class, InsurancePlan.class, InventoryItem.class, InventoryReport.class, Invoice.class, Library.class, Linkage.class, ListResource.class, Location.class, ManufacturedItemDefinition.class, Measure.class, MeasureReport.class, Medication.class, MedicationAdministration.class, MedicationDispense.class, MedicationKnowledge.class, MedicationRequest.class, MedicationStatement.class, MedicinalProductDefinition.class, MessageDefinition.class, MessageHeader.class, MolecularSequence.class, NamingSystem.class, NutritionIntake.class, NutritionOrder.class, NutritionProduct.class, Observation.class, ObservationDefinition.class, OperationDefinition.class, OperationOutcome.class, Organization.class, OrganizationAffiliation.class, PackagedProductDefinition.class, Parameters.class, Patient.class, PaymentNotice.class, PaymentReconciliation.class, Permission.class, Person.class, PlanDefinition.class, Practitioner.class, PractitionerRole.class, Procedure.class, Provenance.class, Questionnaire.class, QuestionnaireResponse.class, RegulatedAuthorization.class, RelatedPerson.class, RequestOrchestration.class, Requirements.class, ResearchStudy.class, ResearchSubject.class, RiskAssessment.class, Schedule.class, SearchParameter.class, ServiceRequest.class, Slot.class, Specimen.class, SpecimenDefinition.class, StructureDefinition.class, StructureMap.class, Subscription.class, SubscriptionStatus.class, SubscriptionTopic.class, Substance.class, SubstanceDefinition.class, SubstanceNucleicAcid.class, SubstancePolymer.class, SubstanceProtein.class, SubstanceReferenceInformation.class, SubstanceSourceMaterial.class, SupplyDelivery.class, SupplyRequest.class, Task.class, TerminologyCapabilities.class, TestPlan.class, TestReport.class, TestScript.class, Transport.class, ValueSet.class, VerificationResult.class, VisionPrescription.class } ) 1963 public static final String SP_CHARACTERISTIC_REFERENCE = "characteristic-reference"; 1964 /** 1965 * <b>Fluent Client</b> search parameter constant for <b>characteristic-reference</b> 1966 * <p> 1967 * Description: <b>An entity referenced in a characteristic</b><br> 1968 * Type: <b>reference</b><br> 1969 * Path: <b>(Group.characteristic.value.ofType(Reference))</b><br> 1970 * </p> 1971 */ 1972 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam CHARACTERISTIC_REFERENCE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_CHARACTERISTIC_REFERENCE); 1973 1974/** 1975 * Constant for fluent queries to be used to add include statements. Specifies 1976 * the path value of "<b>Group:characteristic-reference</b>". 1977 */ 1978 public static final ca.uhn.fhir.model.api.Include INCLUDE_CHARACTERISTIC_REFERENCE = new ca.uhn.fhir.model.api.Include("Group:characteristic-reference").toLocked(); 1979 1980 /** 1981 * Search parameter: <b>characteristic-value</b> 1982 * <p> 1983 * Description: <b>A composite of both characteristic and value</b><br> 1984 * Type: <b>composite</b><br> 1985 * Path: <b>Group.characteristic</b><br> 1986 * </p> 1987 */ 1988 @SearchParamDefinition(name="characteristic-value", path="Group.characteristic", description="A composite of both characteristic and value", type="composite", compositeOf={"characteristic", "value"} ) 1989 public static final String SP_CHARACTERISTIC_VALUE = "characteristic-value"; 1990 /** 1991 * <b>Fluent Client</b> search parameter constant for <b>characteristic-value</b> 1992 * <p> 1993 * Description: <b>A composite of both characteristic and value</b><br> 1994 * Type: <b>composite</b><br> 1995 * Path: <b>Group.characteristic</b><br> 1996 * </p> 1997 */ 1998 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CHARACTERISTIC_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>(SP_CHARACTERISTIC_VALUE); 1999 2000 /** 2001 * Search parameter: <b>characteristic</b> 2002 * <p> 2003 * Description: <b>Kind of characteristic</b><br> 2004 * Type: <b>token</b><br> 2005 * Path: <b>Group.characteristic.code</b><br> 2006 * </p> 2007 */ 2008 @SearchParamDefinition(name="characteristic", path="Group.characteristic.code", description="Kind of characteristic", type="token" ) 2009 public static final String SP_CHARACTERISTIC = "characteristic"; 2010 /** 2011 * <b>Fluent Client</b> search parameter constant for <b>characteristic</b> 2012 * <p> 2013 * Description: <b>Kind of characteristic</b><br> 2014 * Type: <b>token</b><br> 2015 * Path: <b>Group.characteristic.code</b><br> 2016 * </p> 2017 */ 2018 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CHARACTERISTIC = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CHARACTERISTIC); 2019 2020 /** 2021 * Search parameter: <b>code</b> 2022 * <p> 2023 * Description: <b>The kind of resources contained</b><br> 2024 * Type: <b>token</b><br> 2025 * Path: <b>Group.code</b><br> 2026 * </p> 2027 */ 2028 @SearchParamDefinition(name="code", path="Group.code", description="The kind of resources contained", type="token" ) 2029 public static final String SP_CODE = "code"; 2030 /** 2031 * <b>Fluent Client</b> search parameter constant for <b>code</b> 2032 * <p> 2033 * Description: <b>The kind of resources contained</b><br> 2034 * Type: <b>token</b><br> 2035 * Path: <b>Group.code</b><br> 2036 * </p> 2037 */ 2038 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CODE); 2039 2040 /** 2041 * Search parameter: <b>exclude</b> 2042 * <p> 2043 * Description: <b>Group includes or excludes</b><br> 2044 * Type: <b>token</b><br> 2045 * Path: <b>Group.characteristic.exclude</b><br> 2046 * </p> 2047 */ 2048 @SearchParamDefinition(name="exclude", path="Group.characteristic.exclude", description="Group includes or excludes", type="token" ) 2049 public static final String SP_EXCLUDE = "exclude"; 2050 /** 2051 * <b>Fluent Client</b> search parameter constant for <b>exclude</b> 2052 * <p> 2053 * Description: <b>Group includes or excludes</b><br> 2054 * Type: <b>token</b><br> 2055 * Path: <b>Group.characteristic.exclude</b><br> 2056 * </p> 2057 */ 2058 public static final ca.uhn.fhir.rest.gclient.TokenClientParam EXCLUDE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_EXCLUDE); 2059 2060 /** 2061 * Search parameter: <b>identifier</b> 2062 * <p> 2063 * Description: <b>Unique id</b><br> 2064 * Type: <b>token</b><br> 2065 * Path: <b>Group.identifier</b><br> 2066 * </p> 2067 */ 2068 @SearchParamDefinition(name="identifier", path="Group.identifier", description="Unique id", type="token" ) 2069 public static final String SP_IDENTIFIER = "identifier"; 2070 /** 2071 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 2072 * <p> 2073 * Description: <b>Unique id</b><br> 2074 * Type: <b>token</b><br> 2075 * Path: <b>Group.identifier</b><br> 2076 * </p> 2077 */ 2078 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER); 2079 2080 /** 2081 * Search parameter: <b>managing-entity</b> 2082 * <p> 2083 * Description: <b>Entity that is the custodian of the Group's definition</b><br> 2084 * Type: <b>reference</b><br> 2085 * Path: <b>Group.managingEntity</b><br> 2086 * </p> 2087 */ 2088 @SearchParamDefinition(name="managing-entity", path="Group.managingEntity", description="Entity that is the custodian of the Group's definition", type="reference", target={Organization.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class } ) 2089 public static final String SP_MANAGING_ENTITY = "managing-entity"; 2090 /** 2091 * <b>Fluent Client</b> search parameter constant for <b>managing-entity</b> 2092 * <p> 2093 * Description: <b>Entity that is the custodian of the Group's definition</b><br> 2094 * Type: <b>reference</b><br> 2095 * Path: <b>Group.managingEntity</b><br> 2096 * </p> 2097 */ 2098 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam MANAGING_ENTITY = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_MANAGING_ENTITY); 2099 2100/** 2101 * Constant for fluent queries to be used to add include statements. Specifies 2102 * the path value of "<b>Group:managing-entity</b>". 2103 */ 2104 public static final ca.uhn.fhir.model.api.Include INCLUDE_MANAGING_ENTITY = new ca.uhn.fhir.model.api.Include("Group:managing-entity").toLocked(); 2105 2106 /** 2107 * Search parameter: <b>member</b> 2108 * <p> 2109 * Description: <b>Reference to the group member</b><br> 2110 * Type: <b>reference</b><br> 2111 * Path: <b>Group.member.entity</b><br> 2112 * </p> 2113 */ 2114 @SearchParamDefinition(name="member", path="Group.member.entity", description="Reference to the group member", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for Practitioner") }, target={CareTeam.class, Device.class, Group.class, HealthcareService.class, Location.class, Organization.class, Patient.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class, Specimen.class } ) 2115 public static final String SP_MEMBER = "member"; 2116 /** 2117 * <b>Fluent Client</b> search parameter constant for <b>member</b> 2118 * <p> 2119 * Description: <b>Reference to the group member</b><br> 2120 * Type: <b>reference</b><br> 2121 * Path: <b>Group.member.entity</b><br> 2122 * </p> 2123 */ 2124 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam MEMBER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_MEMBER); 2125 2126/** 2127 * Constant for fluent queries to be used to add include statements. Specifies 2128 * the path value of "<b>Group:member</b>". 2129 */ 2130 public static final ca.uhn.fhir.model.api.Include INCLUDE_MEMBER = new ca.uhn.fhir.model.api.Include("Group:member").toLocked(); 2131 2132 /** 2133 * Search parameter: <b>membership</b> 2134 * <p> 2135 * Description: <b>Definitional or enumerated group</b><br> 2136 * Type: <b>token</b><br> 2137 * Path: <b>Group.membership</b><br> 2138 * </p> 2139 */ 2140 @SearchParamDefinition(name="membership", path="Group.membership", description="Definitional or enumerated group", type="token" ) 2141 public static final String SP_MEMBERSHIP = "membership"; 2142 /** 2143 * <b>Fluent Client</b> search parameter constant for <b>membership</b> 2144 * <p> 2145 * Description: <b>Definitional or enumerated group</b><br> 2146 * Type: <b>token</b><br> 2147 * Path: <b>Group.membership</b><br> 2148 * </p> 2149 */ 2150 public static final ca.uhn.fhir.rest.gclient.TokenClientParam MEMBERSHIP = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_MEMBERSHIP); 2151 2152 /** 2153 * Search parameter: <b>name</b> 2154 * <p> 2155 * Description: <b>A portion of the Group's name</b><br> 2156 * Type: <b>string</b><br> 2157 * Path: <b>Group.name</b><br> 2158 * </p> 2159 */ 2160 @SearchParamDefinition(name="name", path="Group.name", description="A portion of the Group's name", type="string" ) 2161 public static final String SP_NAME = "name"; 2162 /** 2163 * <b>Fluent Client</b> search parameter constant for <b>name</b> 2164 * <p> 2165 * Description: <b>A portion of the Group's name</b><br> 2166 * Type: <b>string</b><br> 2167 * Path: <b>Group.name</b><br> 2168 * </p> 2169 */ 2170 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME); 2171 2172 /** 2173 * Search parameter: <b>type</b> 2174 * <p> 2175 * Description: <b>The type of resources the group contains</b><br> 2176 * Type: <b>token</b><br> 2177 * Path: <b>Group.type</b><br> 2178 * </p> 2179 */ 2180 @SearchParamDefinition(name="type", path="Group.type", description="The type of resources the group contains", type="token" ) 2181 public static final String SP_TYPE = "type"; 2182 /** 2183 * <b>Fluent Client</b> search parameter constant for <b>type</b> 2184 * <p> 2185 * Description: <b>The type of resources the group contains</b><br> 2186 * Type: <b>token</b><br> 2187 * Path: <b>Group.type</b><br> 2188 * </p> 2189 */ 2190 public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE); 2191 2192 /** 2193 * Search parameter: <b>value</b> 2194 * <p> 2195 * Description: <b>Value held by characteristic</b><br> 2196 * Type: <b>token</b><br> 2197 * Path: <b>(Group.characteristic.value.ofType(CodeableConcept)) | (Group.characteristic.value.ofType(boolean))</b><br> 2198 * </p> 2199 */ 2200 @SearchParamDefinition(name="value", path="(Group.characteristic.value.ofType(CodeableConcept)) | (Group.characteristic.value.ofType(boolean))", description="Value held by characteristic", type="token" ) 2201 public static final String SP_VALUE = "value"; 2202 /** 2203 * <b>Fluent Client</b> search parameter constant for <b>value</b> 2204 * <p> 2205 * Description: <b>Value held by characteristic</b><br> 2206 * Type: <b>token</b><br> 2207 * Path: <b>(Group.characteristic.value.ofType(CodeableConcept)) | (Group.characteristic.value.ofType(boolean))</b><br> 2208 * </p> 2209 */ 2210 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VALUE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VALUE); 2211 2212 2213} 2214