001package org.hl7.fhir.dstu3.model;
002
003
004
005/*
006  Copyright (c) 2011+, HL7, Inc.
007  All rights reserved.
008  
009  Redistribution and use in source and binary forms, with or without modification, 
010  are permitted provided that the following conditions are met:
011  
012   * Redistributions of source code must retain the above copyright notice, this 
013     list of conditions and the following disclaimer.
014   * Redistributions in binary form must reproduce the above copyright notice, 
015     this list of conditions and the following disclaimer in the documentation 
016     and/or other materials provided with the distribution.
017   * Neither the name of HL7 nor the names of its contributors may be used to 
018     endorse or promote products derived from this software without specific 
019     prior written permission.
020  
021  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
022  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
023  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
024  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
025  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
026  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
027  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
028  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
029  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
030  POSSIBILITY OF SUCH DAMAGE.
031  
032*/
033
034// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x
035import java.util.ArrayList;
036import java.util.Date;
037import java.util.List;
038
039import org.hl7.fhir.exceptions.FHIRException;
040import org.hl7.fhir.exceptions.FHIRFormatError;
041import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
042import org.hl7.fhir.utilities.Utilities;
043
044import ca.uhn.fhir.model.api.annotation.Block;
045import ca.uhn.fhir.model.api.annotation.Child;
046import ca.uhn.fhir.model.api.annotation.Description;
047import ca.uhn.fhir.model.api.annotation.ResourceDef;
048import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
049/**
050 * A sample to be used for analysis.
051 */
052@ResourceDef(name="Specimen", profile="http://hl7.org/fhir/Profile/Specimen")
053public class Specimen extends DomainResource {
054
055    public enum SpecimenStatus {
056        /**
057         * The physical specimen is present and in good condition.
058         */
059        AVAILABLE, 
060        /**
061         * There is no physical specimen because it is either lost, destroyed or consumed.
062         */
063        UNAVAILABLE, 
064        /**
065         * The specimen cannot be used because of a quality issue such as a broken container, contamination, or too old.
066         */
067        UNSATISFACTORY, 
068        /**
069         * The specimen was entered in error and therefore nullified.
070         */
071        ENTEREDINERROR, 
072        /**
073         * added to help the parsers with the generic types
074         */
075        NULL;
076        public static SpecimenStatus fromCode(String codeString) throws FHIRException {
077            if (codeString == null || "".equals(codeString))
078                return null;
079        if ("available".equals(codeString))
080          return AVAILABLE;
081        if ("unavailable".equals(codeString))
082          return UNAVAILABLE;
083        if ("unsatisfactory".equals(codeString))
084          return UNSATISFACTORY;
085        if ("entered-in-error".equals(codeString))
086          return ENTEREDINERROR;
087        if (Configuration.isAcceptInvalidEnums())
088          return null;
089        else
090          throw new FHIRException("Unknown SpecimenStatus code '"+codeString+"'");
091        }
092        public String toCode() {
093          switch (this) {
094            case AVAILABLE: return "available";
095            case UNAVAILABLE: return "unavailable";
096            case UNSATISFACTORY: return "unsatisfactory";
097            case ENTEREDINERROR: return "entered-in-error";
098            case NULL: return null;
099            default: return "?";
100          }
101        }
102        public String getSystem() {
103          switch (this) {
104            case AVAILABLE: return "http://hl7.org/fhir/specimen-status";
105            case UNAVAILABLE: return "http://hl7.org/fhir/specimen-status";
106            case UNSATISFACTORY: return "http://hl7.org/fhir/specimen-status";
107            case ENTEREDINERROR: return "http://hl7.org/fhir/specimen-status";
108            case NULL: return null;
109            default: return "?";
110          }
111        }
112        public String getDefinition() {
113          switch (this) {
114            case AVAILABLE: return "The physical specimen is present and in good condition.";
115            case UNAVAILABLE: return "There is no physical specimen because it is either lost, destroyed or consumed.";
116            case UNSATISFACTORY: return "The specimen cannot be used because of a quality issue such as a broken container, contamination, or too old.";
117            case ENTEREDINERROR: return "The specimen was entered in error and therefore nullified.";
118            case NULL: return null;
119            default: return "?";
120          }
121        }
122        public String getDisplay() {
123          switch (this) {
124            case AVAILABLE: return "Available";
125            case UNAVAILABLE: return "Unavailable";
126            case UNSATISFACTORY: return "Unsatisfactory";
127            case ENTEREDINERROR: return "Entered-in-error";
128            case NULL: return null;
129            default: return "?";
130          }
131        }
132    }
133
134  public static class SpecimenStatusEnumFactory implements EnumFactory<SpecimenStatus> {
135    public SpecimenStatus fromCode(String codeString) throws IllegalArgumentException {
136      if (codeString == null || "".equals(codeString))
137            if (codeString == null || "".equals(codeString))
138                return null;
139        if ("available".equals(codeString))
140          return SpecimenStatus.AVAILABLE;
141        if ("unavailable".equals(codeString))
142          return SpecimenStatus.UNAVAILABLE;
143        if ("unsatisfactory".equals(codeString))
144          return SpecimenStatus.UNSATISFACTORY;
145        if ("entered-in-error".equals(codeString))
146          return SpecimenStatus.ENTEREDINERROR;
147        throw new IllegalArgumentException("Unknown SpecimenStatus code '"+codeString+"'");
148        }
149        public Enumeration<SpecimenStatus> fromType(Base code) throws FHIRException {
150          if (code == null)
151            return null;
152          if (code.isEmpty())
153            return new Enumeration<SpecimenStatus>(this);
154          String codeString = ((PrimitiveType) code).asStringValue();
155          if (codeString == null || "".equals(codeString))
156            return null;
157        if ("available".equals(codeString))
158          return new Enumeration<SpecimenStatus>(this, SpecimenStatus.AVAILABLE);
159        if ("unavailable".equals(codeString))
160          return new Enumeration<SpecimenStatus>(this, SpecimenStatus.UNAVAILABLE);
161        if ("unsatisfactory".equals(codeString))
162          return new Enumeration<SpecimenStatus>(this, SpecimenStatus.UNSATISFACTORY);
163        if ("entered-in-error".equals(codeString))
164          return new Enumeration<SpecimenStatus>(this, SpecimenStatus.ENTEREDINERROR);
165        throw new FHIRException("Unknown SpecimenStatus code '"+codeString+"'");
166        }
167    public String toCode(SpecimenStatus code) {
168      if (code == SpecimenStatus.AVAILABLE)
169        return "available";
170      if (code == SpecimenStatus.UNAVAILABLE)
171        return "unavailable";
172      if (code == SpecimenStatus.UNSATISFACTORY)
173        return "unsatisfactory";
174      if (code == SpecimenStatus.ENTEREDINERROR)
175        return "entered-in-error";
176      return "?";
177      }
178    public String toSystem(SpecimenStatus code) {
179      return code.getSystem();
180      }
181    }
182
183    @Block()
184    public static class SpecimenCollectionComponent extends BackboneElement implements IBaseBackboneElement {
185        /**
186         * Person who collected the specimen.
187         */
188        @Child(name = "collector", type = {Practitioner.class}, order=1, min=0, max=1, modifier=false, summary=true)
189        @Description(shortDefinition="Who collected the specimen", formalDefinition="Person who collected the specimen." )
190        protected Reference collector;
191
192        /**
193         * The actual object that is the target of the reference (Person who collected the specimen.)
194         */
195        protected Practitioner collectorTarget;
196
197        /**
198         * Time when specimen was collected from subject - the physiologically relevant time.
199         */
200        @Child(name = "collected", type = {DateTimeType.class, Period.class}, order=2, min=0, max=1, modifier=false, summary=true)
201        @Description(shortDefinition="Collection time", formalDefinition="Time when specimen was collected from subject - the physiologically relevant time." )
202        protected Type collected;
203
204        /**
205         * The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample.
206         */
207        @Child(name = "quantity", type = {SimpleQuantity.class}, order=3, min=0, max=1, modifier=false, summary=false)
208        @Description(shortDefinition="The quantity of specimen collected", formalDefinition="The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample." )
209        protected SimpleQuantity quantity;
210
211        /**
212         * A coded value specifying the technique that is used to perform the procedure.
213         */
214        @Child(name = "method", type = {CodeableConcept.class}, order=4, min=0, max=1, modifier=false, summary=false)
215        @Description(shortDefinition="Technique used to perform collection", formalDefinition="A coded value specifying the technique that is used to perform the procedure." )
216        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/specimen-collection-method")
217        protected CodeableConcept method;
218
219        /**
220         * Anatomical location from which the specimen was collected (if subject is a patient). This is the target site.  This element is not used for environmental specimens.
221         */
222        @Child(name = "bodySite", type = {CodeableConcept.class}, order=5, min=0, max=1, modifier=false, summary=false)
223        @Description(shortDefinition="Anatomical collection site", formalDefinition="Anatomical location from which the specimen was collected (if subject is a patient). This is the target site.  This element is not used for environmental specimens." )
224        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/body-site")
225        protected CodeableConcept bodySite;
226
227        private static final long serialVersionUID = -1324142853L;
228
229    /**
230     * Constructor
231     */
232      public SpecimenCollectionComponent() {
233        super();
234      }
235
236        /**
237         * @return {@link #collector} (Person who collected the specimen.)
238         */
239        public Reference getCollector() { 
240          if (this.collector == null)
241            if (Configuration.errorOnAutoCreate())
242              throw new Error("Attempt to auto-create SpecimenCollectionComponent.collector");
243            else if (Configuration.doAutoCreate())
244              this.collector = new Reference(); // cc
245          return this.collector;
246        }
247
248        public boolean hasCollector() { 
249          return this.collector != null && !this.collector.isEmpty();
250        }
251
252        /**
253         * @param value {@link #collector} (Person who collected the specimen.)
254         */
255        public SpecimenCollectionComponent setCollector(Reference value)  { 
256          this.collector = value;
257          return this;
258        }
259
260        /**
261         * @return {@link #collector} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Person who collected the specimen.)
262         */
263        public Practitioner getCollectorTarget() { 
264          if (this.collectorTarget == null)
265            if (Configuration.errorOnAutoCreate())
266              throw new Error("Attempt to auto-create SpecimenCollectionComponent.collector");
267            else if (Configuration.doAutoCreate())
268              this.collectorTarget = new Practitioner(); // aa
269          return this.collectorTarget;
270        }
271
272        /**
273         * @param value {@link #collector} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Person who collected the specimen.)
274         */
275        public SpecimenCollectionComponent setCollectorTarget(Practitioner value) { 
276          this.collectorTarget = value;
277          return this;
278        }
279
280        /**
281         * @return {@link #collected} (Time when specimen was collected from subject - the physiologically relevant time.)
282         */
283        public Type getCollected() { 
284          return this.collected;
285        }
286
287        /**
288         * @return {@link #collected} (Time when specimen was collected from subject - the physiologically relevant time.)
289         */
290        public DateTimeType getCollectedDateTimeType() throws FHIRException { 
291          if (this.collected == null)
292            return null;
293          if (!(this.collected instanceof DateTimeType))
294            throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.collected.getClass().getName()+" was encountered");
295          return (DateTimeType) this.collected;
296        }
297
298        public boolean hasCollectedDateTimeType() { 
299          return this != null && this.collected instanceof DateTimeType;
300        }
301
302        /**
303         * @return {@link #collected} (Time when specimen was collected from subject - the physiologically relevant time.)
304         */
305        public Period getCollectedPeriod() throws FHIRException { 
306          if (this.collected == null)
307            return null;
308          if (!(this.collected instanceof Period))
309            throw new FHIRException("Type mismatch: the type Period was expected, but "+this.collected.getClass().getName()+" was encountered");
310          return (Period) this.collected;
311        }
312
313        public boolean hasCollectedPeriod() { 
314          return this != null && this.collected instanceof Period;
315        }
316
317        public boolean hasCollected() { 
318          return this.collected != null && !this.collected.isEmpty();
319        }
320
321        /**
322         * @param value {@link #collected} (Time when specimen was collected from subject - the physiologically relevant time.)
323         */
324        public SpecimenCollectionComponent setCollected(Type value) throws FHIRFormatError { 
325          if (value != null && !(value instanceof DateTimeType || value instanceof Period))
326            throw new FHIRFormatError("Not the right type for Specimen.collection.collected[x]: "+value.fhirType());
327          this.collected = value;
328          return this;
329        }
330
331        /**
332         * @return {@link #quantity} (The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample.)
333         */
334        public SimpleQuantity getQuantity() { 
335          if (this.quantity == null)
336            if (Configuration.errorOnAutoCreate())
337              throw new Error("Attempt to auto-create SpecimenCollectionComponent.quantity");
338            else if (Configuration.doAutoCreate())
339              this.quantity = new SimpleQuantity(); // cc
340          return this.quantity;
341        }
342
343        public boolean hasQuantity() { 
344          return this.quantity != null && !this.quantity.isEmpty();
345        }
346
347        /**
348         * @param value {@link #quantity} (The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample.)
349         */
350        public SpecimenCollectionComponent setQuantity(SimpleQuantity value)  { 
351          this.quantity = value;
352          return this;
353        }
354
355        /**
356         * @return {@link #method} (A coded value specifying the technique that is used to perform the procedure.)
357         */
358        public CodeableConcept getMethod() { 
359          if (this.method == null)
360            if (Configuration.errorOnAutoCreate())
361              throw new Error("Attempt to auto-create SpecimenCollectionComponent.method");
362            else if (Configuration.doAutoCreate())
363              this.method = new CodeableConcept(); // cc
364          return this.method;
365        }
366
367        public boolean hasMethod() { 
368          return this.method != null && !this.method.isEmpty();
369        }
370
371        /**
372         * @param value {@link #method} (A coded value specifying the technique that is used to perform the procedure.)
373         */
374        public SpecimenCollectionComponent setMethod(CodeableConcept value)  { 
375          this.method = value;
376          return this;
377        }
378
379        /**
380         * @return {@link #bodySite} (Anatomical location from which the specimen was collected (if subject is a patient). This is the target site.  This element is not used for environmental specimens.)
381         */
382        public CodeableConcept getBodySite() { 
383          if (this.bodySite == null)
384            if (Configuration.errorOnAutoCreate())
385              throw new Error("Attempt to auto-create SpecimenCollectionComponent.bodySite");
386            else if (Configuration.doAutoCreate())
387              this.bodySite = new CodeableConcept(); // cc
388          return this.bodySite;
389        }
390
391        public boolean hasBodySite() { 
392          return this.bodySite != null && !this.bodySite.isEmpty();
393        }
394
395        /**
396         * @param value {@link #bodySite} (Anatomical location from which the specimen was collected (if subject is a patient). This is the target site.  This element is not used for environmental specimens.)
397         */
398        public SpecimenCollectionComponent setBodySite(CodeableConcept value)  { 
399          this.bodySite = value;
400          return this;
401        }
402
403        protected void listChildren(List<Property> children) {
404          super.listChildren(children);
405          children.add(new Property("collector", "Reference(Practitioner)", "Person who collected the specimen.", 0, 1, collector));
406          children.add(new Property("collected[x]", "dateTime|Period", "Time when specimen was collected from subject - the physiologically relevant time.", 0, 1, collected));
407          children.add(new Property("quantity", "SimpleQuantity", "The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample.", 0, 1, quantity));
408          children.add(new Property("method", "CodeableConcept", "A coded value specifying the technique that is used to perform the procedure.", 0, 1, method));
409          children.add(new Property("bodySite", "CodeableConcept", "Anatomical location from which the specimen was collected (if subject is a patient). This is the target site.  This element is not used for environmental specimens.", 0, 1, bodySite));
410        }
411
412        @Override
413        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
414          switch (_hash) {
415          case 1883491469: /*collector*/  return new Property("collector", "Reference(Practitioner)", "Person who collected the specimen.", 0, 1, collector);
416          case 1632037015: /*collected[x]*/  return new Property("collected[x]", "dateTime|Period", "Time when specimen was collected from subject - the physiologically relevant time.", 0, 1, collected);
417          case 1883491145: /*collected*/  return new Property("collected[x]", "dateTime|Period", "Time when specimen was collected from subject - the physiologically relevant time.", 0, 1, collected);
418          case 2005009924: /*collectedDateTime*/  return new Property("collected[x]", "dateTime|Period", "Time when specimen was collected from subject - the physiologically relevant time.", 0, 1, collected);
419          case 653185642: /*collectedPeriod*/  return new Property("collected[x]", "dateTime|Period", "Time when specimen was collected from subject - the physiologically relevant time.", 0, 1, collected);
420          case -1285004149: /*quantity*/  return new Property("quantity", "SimpleQuantity", "The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample.", 0, 1, quantity);
421          case -1077554975: /*method*/  return new Property("method", "CodeableConcept", "A coded value specifying the technique that is used to perform the procedure.", 0, 1, method);
422          case 1702620169: /*bodySite*/  return new Property("bodySite", "CodeableConcept", "Anatomical location from which the specimen was collected (if subject is a patient). This is the target site.  This element is not used for environmental specimens.", 0, 1, bodySite);
423          default: return super.getNamedProperty(_hash, _name, _checkValid);
424          }
425
426        }
427
428      @Override
429      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
430        switch (hash) {
431        case 1883491469: /*collector*/ return this.collector == null ? new Base[0] : new Base[] {this.collector}; // Reference
432        case 1883491145: /*collected*/ return this.collected == null ? new Base[0] : new Base[] {this.collected}; // Type
433        case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // SimpleQuantity
434        case -1077554975: /*method*/ return this.method == null ? new Base[0] : new Base[] {this.method}; // CodeableConcept
435        case 1702620169: /*bodySite*/ return this.bodySite == null ? new Base[0] : new Base[] {this.bodySite}; // CodeableConcept
436        default: return super.getProperty(hash, name, checkValid);
437        }
438
439      }
440
441      @Override
442      public Base setProperty(int hash, String name, Base value) throws FHIRException {
443        switch (hash) {
444        case 1883491469: // collector
445          this.collector = castToReference(value); // Reference
446          return value;
447        case 1883491145: // collected
448          this.collected = castToType(value); // Type
449          return value;
450        case -1285004149: // quantity
451          this.quantity = castToSimpleQuantity(value); // SimpleQuantity
452          return value;
453        case -1077554975: // method
454          this.method = castToCodeableConcept(value); // CodeableConcept
455          return value;
456        case 1702620169: // bodySite
457          this.bodySite = castToCodeableConcept(value); // CodeableConcept
458          return value;
459        default: return super.setProperty(hash, name, value);
460        }
461
462      }
463
464      @Override
465      public Base setProperty(String name, Base value) throws FHIRException {
466        if (name.equals("collector")) {
467          this.collector = castToReference(value); // Reference
468        } else if (name.equals("collected[x]")) {
469          this.collected = castToType(value); // Type
470        } else if (name.equals("quantity")) {
471          this.quantity = castToSimpleQuantity(value); // SimpleQuantity
472        } else if (name.equals("method")) {
473          this.method = castToCodeableConcept(value); // CodeableConcept
474        } else if (name.equals("bodySite")) {
475          this.bodySite = castToCodeableConcept(value); // CodeableConcept
476        } else
477          return super.setProperty(name, value);
478        return value;
479      }
480
481      @Override
482      public Base makeProperty(int hash, String name) throws FHIRException {
483        switch (hash) {
484        case 1883491469:  return getCollector(); 
485        case 1632037015:  return getCollected(); 
486        case 1883491145:  return getCollected(); 
487        case -1285004149:  return getQuantity(); 
488        case -1077554975:  return getMethod(); 
489        case 1702620169:  return getBodySite(); 
490        default: return super.makeProperty(hash, name);
491        }
492
493      }
494
495      @Override
496      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
497        switch (hash) {
498        case 1883491469: /*collector*/ return new String[] {"Reference"};
499        case 1883491145: /*collected*/ return new String[] {"dateTime", "Period"};
500        case -1285004149: /*quantity*/ return new String[] {"SimpleQuantity"};
501        case -1077554975: /*method*/ return new String[] {"CodeableConcept"};
502        case 1702620169: /*bodySite*/ return new String[] {"CodeableConcept"};
503        default: return super.getTypesForProperty(hash, name);
504        }
505
506      }
507
508      @Override
509      public Base addChild(String name) throws FHIRException {
510        if (name.equals("collector")) {
511          this.collector = new Reference();
512          return this.collector;
513        }
514        else if (name.equals("collectedDateTime")) {
515          this.collected = new DateTimeType();
516          return this.collected;
517        }
518        else if (name.equals("collectedPeriod")) {
519          this.collected = new Period();
520          return this.collected;
521        }
522        else if (name.equals("quantity")) {
523          this.quantity = new SimpleQuantity();
524          return this.quantity;
525        }
526        else if (name.equals("method")) {
527          this.method = new CodeableConcept();
528          return this.method;
529        }
530        else if (name.equals("bodySite")) {
531          this.bodySite = new CodeableConcept();
532          return this.bodySite;
533        }
534        else
535          return super.addChild(name);
536      }
537
538      public SpecimenCollectionComponent copy() {
539        SpecimenCollectionComponent dst = new SpecimenCollectionComponent();
540        copyValues(dst);
541        dst.collector = collector == null ? null : collector.copy();
542        dst.collected = collected == null ? null : collected.copy();
543        dst.quantity = quantity == null ? null : quantity.copy();
544        dst.method = method == null ? null : method.copy();
545        dst.bodySite = bodySite == null ? null : bodySite.copy();
546        return dst;
547      }
548
549      @Override
550      public boolean equalsDeep(Base other_) {
551        if (!super.equalsDeep(other_))
552          return false;
553        if (!(other_ instanceof SpecimenCollectionComponent))
554          return false;
555        SpecimenCollectionComponent o = (SpecimenCollectionComponent) other_;
556        return compareDeep(collector, o.collector, true) && compareDeep(collected, o.collected, true) && compareDeep(quantity, o.quantity, true)
557           && compareDeep(method, o.method, true) && compareDeep(bodySite, o.bodySite, true);
558      }
559
560      @Override
561      public boolean equalsShallow(Base other_) {
562        if (!super.equalsShallow(other_))
563          return false;
564        if (!(other_ instanceof SpecimenCollectionComponent))
565          return false;
566        SpecimenCollectionComponent o = (SpecimenCollectionComponent) other_;
567        return true;
568      }
569
570      public boolean isEmpty() {
571        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(collector, collected, quantity
572          , method, bodySite);
573      }
574
575  public String fhirType() {
576    return "Specimen.collection";
577
578  }
579
580  }
581
582    @Block()
583    public static class SpecimenProcessingComponent extends BackboneElement implements IBaseBackboneElement {
584        /**
585         * Textual description of procedure.
586         */
587        @Child(name = "description", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=false)
588        @Description(shortDefinition="Textual description of procedure", formalDefinition="Textual description of procedure." )
589        protected StringType description;
590
591        /**
592         * A coded value specifying the procedure used to process the specimen.
593         */
594        @Child(name = "procedure", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=false)
595        @Description(shortDefinition="Indicates the treatment step  applied to the specimen", formalDefinition="A coded value specifying the procedure used to process the specimen." )
596        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/specimen-processing-procedure")
597        protected CodeableConcept procedure;
598
599        /**
600         * Material used in the processing step.
601         */
602        @Child(name = "additive", type = {Substance.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
603        @Description(shortDefinition="Material used in the processing step", formalDefinition="Material used in the processing step." )
604        protected List<Reference> additive;
605        /**
606         * The actual objects that are the target of the reference (Material used in the processing step.)
607         */
608        protected List<Substance> additiveTarget;
609
610
611        /**
612         * A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.
613         */
614        @Child(name = "time", type = {DateTimeType.class, Period.class}, order=4, min=0, max=1, modifier=false, summary=false)
615        @Description(shortDefinition="Date and time of specimen processing", formalDefinition="A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin." )
616        protected Type time;
617
618        private static final long serialVersionUID = 1467214742L;
619
620    /**
621     * Constructor
622     */
623      public SpecimenProcessingComponent() {
624        super();
625      }
626
627        /**
628         * @return {@link #description} (Textual description of procedure.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
629         */
630        public StringType getDescriptionElement() { 
631          if (this.description == null)
632            if (Configuration.errorOnAutoCreate())
633              throw new Error("Attempt to auto-create SpecimenProcessingComponent.description");
634            else if (Configuration.doAutoCreate())
635              this.description = new StringType(); // bb
636          return this.description;
637        }
638
639        public boolean hasDescriptionElement() { 
640          return this.description != null && !this.description.isEmpty();
641        }
642
643        public boolean hasDescription() { 
644          return this.description != null && !this.description.isEmpty();
645        }
646
647        /**
648         * @param value {@link #description} (Textual description of procedure.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
649         */
650        public SpecimenProcessingComponent setDescriptionElement(StringType value) { 
651          this.description = value;
652          return this;
653        }
654
655        /**
656         * @return Textual description of procedure.
657         */
658        public String getDescription() { 
659          return this.description == null ? null : this.description.getValue();
660        }
661
662        /**
663         * @param value Textual description of procedure.
664         */
665        public SpecimenProcessingComponent setDescription(String value) { 
666          if (Utilities.noString(value))
667            this.description = null;
668          else {
669            if (this.description == null)
670              this.description = new StringType();
671            this.description.setValue(value);
672          }
673          return this;
674        }
675
676        /**
677         * @return {@link #procedure} (A coded value specifying the procedure used to process the specimen.)
678         */
679        public CodeableConcept getProcedure() { 
680          if (this.procedure == null)
681            if (Configuration.errorOnAutoCreate())
682              throw new Error("Attempt to auto-create SpecimenProcessingComponent.procedure");
683            else if (Configuration.doAutoCreate())
684              this.procedure = new CodeableConcept(); // cc
685          return this.procedure;
686        }
687
688        public boolean hasProcedure() { 
689          return this.procedure != null && !this.procedure.isEmpty();
690        }
691
692        /**
693         * @param value {@link #procedure} (A coded value specifying the procedure used to process the specimen.)
694         */
695        public SpecimenProcessingComponent setProcedure(CodeableConcept value)  { 
696          this.procedure = value;
697          return this;
698        }
699
700        /**
701         * @return {@link #additive} (Material used in the processing step.)
702         */
703        public List<Reference> getAdditive() { 
704          if (this.additive == null)
705            this.additive = new ArrayList<Reference>();
706          return this.additive;
707        }
708
709        /**
710         * @return Returns a reference to <code>this</code> for easy method chaining
711         */
712        public SpecimenProcessingComponent setAdditive(List<Reference> theAdditive) { 
713          this.additive = theAdditive;
714          return this;
715        }
716
717        public boolean hasAdditive() { 
718          if (this.additive == null)
719            return false;
720          for (Reference item : this.additive)
721            if (!item.isEmpty())
722              return true;
723          return false;
724        }
725
726        public Reference addAdditive() { //3
727          Reference t = new Reference();
728          if (this.additive == null)
729            this.additive = new ArrayList<Reference>();
730          this.additive.add(t);
731          return t;
732        }
733
734        public SpecimenProcessingComponent addAdditive(Reference t) { //3
735          if (t == null)
736            return this;
737          if (this.additive == null)
738            this.additive = new ArrayList<Reference>();
739          this.additive.add(t);
740          return this;
741        }
742
743        /**
744         * @return The first repetition of repeating field {@link #additive}, creating it if it does not already exist
745         */
746        public Reference getAdditiveFirstRep() { 
747          if (getAdditive().isEmpty()) {
748            addAdditive();
749          }
750          return getAdditive().get(0);
751        }
752
753        /**
754         * @deprecated Use Reference#setResource(IBaseResource) instead
755         */
756        @Deprecated
757        public List<Substance> getAdditiveTarget() { 
758          if (this.additiveTarget == null)
759            this.additiveTarget = new ArrayList<Substance>();
760          return this.additiveTarget;
761        }
762
763        /**
764         * @deprecated Use Reference#setResource(IBaseResource) instead
765         */
766        @Deprecated
767        public Substance addAdditiveTarget() { 
768          Substance r = new Substance();
769          if (this.additiveTarget == null)
770            this.additiveTarget = new ArrayList<Substance>();
771          this.additiveTarget.add(r);
772          return r;
773        }
774
775        /**
776         * @return {@link #time} (A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.)
777         */
778        public Type getTime() { 
779          return this.time;
780        }
781
782        /**
783         * @return {@link #time} (A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.)
784         */
785        public DateTimeType getTimeDateTimeType() throws FHIRException { 
786          if (this.time == null)
787            return null;
788          if (!(this.time instanceof DateTimeType))
789            throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.time.getClass().getName()+" was encountered");
790          return (DateTimeType) this.time;
791        }
792
793        public boolean hasTimeDateTimeType() { 
794          return this != null && this.time instanceof DateTimeType;
795        }
796
797        /**
798         * @return {@link #time} (A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.)
799         */
800        public Period getTimePeriod() throws FHIRException { 
801          if (this.time == null)
802            return null;
803          if (!(this.time instanceof Period))
804            throw new FHIRException("Type mismatch: the type Period was expected, but "+this.time.getClass().getName()+" was encountered");
805          return (Period) this.time;
806        }
807
808        public boolean hasTimePeriod() { 
809          return this != null && this.time instanceof Period;
810        }
811
812        public boolean hasTime() { 
813          return this.time != null && !this.time.isEmpty();
814        }
815
816        /**
817         * @param value {@link #time} (A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.)
818         */
819        public SpecimenProcessingComponent setTime(Type value) throws FHIRFormatError { 
820          if (value != null && !(value instanceof DateTimeType || value instanceof Period))
821            throw new FHIRFormatError("Not the right type for Specimen.processing.time[x]: "+value.fhirType());
822          this.time = value;
823          return this;
824        }
825
826        protected void listChildren(List<Property> children) {
827          super.listChildren(children);
828          children.add(new Property("description", "string", "Textual description of procedure.", 0, 1, description));
829          children.add(new Property("procedure", "CodeableConcept", "A coded value specifying the procedure used to process the specimen.", 0, 1, procedure));
830          children.add(new Property("additive", "Reference(Substance)", "Material used in the processing step.", 0, java.lang.Integer.MAX_VALUE, additive));
831          children.add(new Property("time[x]", "dateTime|Period", "A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.", 0, 1, time));
832        }
833
834        @Override
835        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
836          switch (_hash) {
837          case -1724546052: /*description*/  return new Property("description", "string", "Textual description of procedure.", 0, 1, description);
838          case -1095204141: /*procedure*/  return new Property("procedure", "CodeableConcept", "A coded value specifying the procedure used to process the specimen.", 0, 1, procedure);
839          case -1226589236: /*additive*/  return new Property("additive", "Reference(Substance)", "Material used in the processing step.", 0, java.lang.Integer.MAX_VALUE, additive);
840          case -1313930605: /*time[x]*/  return new Property("time[x]", "dateTime|Period", "A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.", 0, 1, time);
841          case 3560141: /*time*/  return new Property("time[x]", "dateTime|Period", "A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.", 0, 1, time);
842          case 2135345544: /*timeDateTime*/  return new Property("time[x]", "dateTime|Period", "A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.", 0, 1, time);
843          case 693544686: /*timePeriod*/  return new Property("time[x]", "dateTime|Period", "A record of the time or period when the specimen processing occurred.  For example the time of sample fixation or the period of time the sample was in formalin.", 0, 1, time);
844          default: return super.getNamedProperty(_hash, _name, _checkValid);
845          }
846
847        }
848
849      @Override
850      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
851        switch (hash) {
852        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
853        case -1095204141: /*procedure*/ return this.procedure == null ? new Base[0] : new Base[] {this.procedure}; // CodeableConcept
854        case -1226589236: /*additive*/ return this.additive == null ? new Base[0] : this.additive.toArray(new Base[this.additive.size()]); // Reference
855        case 3560141: /*time*/ return this.time == null ? new Base[0] : new Base[] {this.time}; // Type
856        default: return super.getProperty(hash, name, checkValid);
857        }
858
859      }
860
861      @Override
862      public Base setProperty(int hash, String name, Base value) throws FHIRException {
863        switch (hash) {
864        case -1724546052: // description
865          this.description = castToString(value); // StringType
866          return value;
867        case -1095204141: // procedure
868          this.procedure = castToCodeableConcept(value); // CodeableConcept
869          return value;
870        case -1226589236: // additive
871          this.getAdditive().add(castToReference(value)); // Reference
872          return value;
873        case 3560141: // time
874          this.time = castToType(value); // Type
875          return value;
876        default: return super.setProperty(hash, name, value);
877        }
878
879      }
880
881      @Override
882      public Base setProperty(String name, Base value) throws FHIRException {
883        if (name.equals("description")) {
884          this.description = castToString(value); // StringType
885        } else if (name.equals("procedure")) {
886          this.procedure = castToCodeableConcept(value); // CodeableConcept
887        } else if (name.equals("additive")) {
888          this.getAdditive().add(castToReference(value));
889        } else if (name.equals("time[x]")) {
890          this.time = castToType(value); // Type
891        } else
892          return super.setProperty(name, value);
893        return value;
894      }
895
896      @Override
897      public Base makeProperty(int hash, String name) throws FHIRException {
898        switch (hash) {
899        case -1724546052:  return getDescriptionElement();
900        case -1095204141:  return getProcedure(); 
901        case -1226589236:  return addAdditive(); 
902        case -1313930605:  return getTime(); 
903        case 3560141:  return getTime(); 
904        default: return super.makeProperty(hash, name);
905        }
906
907      }
908
909      @Override
910      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
911        switch (hash) {
912        case -1724546052: /*description*/ return new String[] {"string"};
913        case -1095204141: /*procedure*/ return new String[] {"CodeableConcept"};
914        case -1226589236: /*additive*/ return new String[] {"Reference"};
915        case 3560141: /*time*/ return new String[] {"dateTime", "Period"};
916        default: return super.getTypesForProperty(hash, name);
917        }
918
919      }
920
921      @Override
922      public Base addChild(String name) throws FHIRException {
923        if (name.equals("description")) {
924          throw new FHIRException("Cannot call addChild on a primitive type Specimen.description");
925        }
926        else if (name.equals("procedure")) {
927          this.procedure = new CodeableConcept();
928          return this.procedure;
929        }
930        else if (name.equals("additive")) {
931          return addAdditive();
932        }
933        else if (name.equals("timeDateTime")) {
934          this.time = new DateTimeType();
935          return this.time;
936        }
937        else if (name.equals("timePeriod")) {
938          this.time = new Period();
939          return this.time;
940        }
941        else
942          return super.addChild(name);
943      }
944
945      public SpecimenProcessingComponent copy() {
946        SpecimenProcessingComponent dst = new SpecimenProcessingComponent();
947        copyValues(dst);
948        dst.description = description == null ? null : description.copy();
949        dst.procedure = procedure == null ? null : procedure.copy();
950        if (additive != null) {
951          dst.additive = new ArrayList<Reference>();
952          for (Reference i : additive)
953            dst.additive.add(i.copy());
954        };
955        dst.time = time == null ? null : time.copy();
956        return dst;
957      }
958
959      @Override
960      public boolean equalsDeep(Base other_) {
961        if (!super.equalsDeep(other_))
962          return false;
963        if (!(other_ instanceof SpecimenProcessingComponent))
964          return false;
965        SpecimenProcessingComponent o = (SpecimenProcessingComponent) other_;
966        return compareDeep(description, o.description, true) && compareDeep(procedure, o.procedure, true)
967           && compareDeep(additive, o.additive, true) && compareDeep(time, o.time, true);
968      }
969
970      @Override
971      public boolean equalsShallow(Base other_) {
972        if (!super.equalsShallow(other_))
973          return false;
974        if (!(other_ instanceof SpecimenProcessingComponent))
975          return false;
976        SpecimenProcessingComponent o = (SpecimenProcessingComponent) other_;
977        return compareValues(description, o.description, true);
978      }
979
980      public boolean isEmpty() {
981        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(description, procedure, additive
982          , time);
983      }
984
985  public String fhirType() {
986    return "Specimen.processing";
987
988  }
989
990  }
991
992    @Block()
993    public static class SpecimenContainerComponent extends BackboneElement implements IBaseBackboneElement {
994        /**
995         * Id for container. There may be multiple; a manufacturer's bar code, lab assigned identifier, etc. The container ID may differ from the specimen id in some circumstances.
996         */
997        @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
998        @Description(shortDefinition="Id for the container", formalDefinition="Id for container. There may be multiple; a manufacturer's bar code, lab assigned identifier, etc. The container ID may differ from the specimen id in some circumstances." )
999        protected List<Identifier> identifier;
1000
1001        /**
1002         * Textual description of the container.
1003         */
1004        @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
1005        @Description(shortDefinition="Textual description of the container", formalDefinition="Textual description of the container." )
1006        protected StringType description;
1007
1008        /**
1009         * The type of container associated with the specimen (e.g. slide, aliquot, etc.).
1010         */
1011        @Child(name = "type", type = {CodeableConcept.class}, order=3, min=0, max=1, modifier=false, summary=false)
1012        @Description(shortDefinition="Kind of container directly associated with specimen", formalDefinition="The type of container associated with the specimen (e.g. slide, aliquot, etc.)." )
1013        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/specimen-container-type")
1014        protected CodeableConcept type;
1015
1016        /**
1017         * The capacity (volume or other measure) the container may contain.
1018         */
1019        @Child(name = "capacity", type = {SimpleQuantity.class}, order=4, min=0, max=1, modifier=false, summary=false)
1020        @Description(shortDefinition="Container volume or size", formalDefinition="The capacity (volume or other measure) the container may contain." )
1021        protected SimpleQuantity capacity;
1022
1023        /**
1024         * The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type.
1025         */
1026        @Child(name = "specimenQuantity", type = {SimpleQuantity.class}, order=5, min=0, max=1, modifier=false, summary=false)
1027        @Description(shortDefinition="Quantity of specimen within container", formalDefinition="The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type." )
1028        protected SimpleQuantity specimenQuantity;
1029
1030        /**
1031         * Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.
1032         */
1033        @Child(name = "additive", type = {CodeableConcept.class, Substance.class}, order=6, min=0, max=1, modifier=false, summary=false)
1034        @Description(shortDefinition="Additive associated with container", formalDefinition="Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA." )
1035        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/v2-0371")
1036        protected Type additive;
1037
1038        private static final long serialVersionUID = 187274879L;
1039
1040    /**
1041     * Constructor
1042     */
1043      public SpecimenContainerComponent() {
1044        super();
1045      }
1046
1047        /**
1048         * @return {@link #identifier} (Id for container. There may be multiple; a manufacturer's bar code, lab assigned identifier, etc. The container ID may differ from the specimen id in some circumstances.)
1049         */
1050        public List<Identifier> getIdentifier() { 
1051          if (this.identifier == null)
1052            this.identifier = new ArrayList<Identifier>();
1053          return this.identifier;
1054        }
1055
1056        /**
1057         * @return Returns a reference to <code>this</code> for easy method chaining
1058         */
1059        public SpecimenContainerComponent setIdentifier(List<Identifier> theIdentifier) { 
1060          this.identifier = theIdentifier;
1061          return this;
1062        }
1063
1064        public boolean hasIdentifier() { 
1065          if (this.identifier == null)
1066            return false;
1067          for (Identifier item : this.identifier)
1068            if (!item.isEmpty())
1069              return true;
1070          return false;
1071        }
1072
1073        public Identifier addIdentifier() { //3
1074          Identifier t = new Identifier();
1075          if (this.identifier == null)
1076            this.identifier = new ArrayList<Identifier>();
1077          this.identifier.add(t);
1078          return t;
1079        }
1080
1081        public SpecimenContainerComponent addIdentifier(Identifier t) { //3
1082          if (t == null)
1083            return this;
1084          if (this.identifier == null)
1085            this.identifier = new ArrayList<Identifier>();
1086          this.identifier.add(t);
1087          return this;
1088        }
1089
1090        /**
1091         * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist
1092         */
1093        public Identifier getIdentifierFirstRep() { 
1094          if (getIdentifier().isEmpty()) {
1095            addIdentifier();
1096          }
1097          return getIdentifier().get(0);
1098        }
1099
1100        /**
1101         * @return {@link #description} (Textual description of the container.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1102         */
1103        public StringType getDescriptionElement() { 
1104          if (this.description == null)
1105            if (Configuration.errorOnAutoCreate())
1106              throw new Error("Attempt to auto-create SpecimenContainerComponent.description");
1107            else if (Configuration.doAutoCreate())
1108              this.description = new StringType(); // bb
1109          return this.description;
1110        }
1111
1112        public boolean hasDescriptionElement() { 
1113          return this.description != null && !this.description.isEmpty();
1114        }
1115
1116        public boolean hasDescription() { 
1117          return this.description != null && !this.description.isEmpty();
1118        }
1119
1120        /**
1121         * @param value {@link #description} (Textual description of the container.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1122         */
1123        public SpecimenContainerComponent setDescriptionElement(StringType value) { 
1124          this.description = value;
1125          return this;
1126        }
1127
1128        /**
1129         * @return Textual description of the container.
1130         */
1131        public String getDescription() { 
1132          return this.description == null ? null : this.description.getValue();
1133        }
1134
1135        /**
1136         * @param value Textual description of the container.
1137         */
1138        public SpecimenContainerComponent setDescription(String value) { 
1139          if (Utilities.noString(value))
1140            this.description = null;
1141          else {
1142            if (this.description == null)
1143              this.description = new StringType();
1144            this.description.setValue(value);
1145          }
1146          return this;
1147        }
1148
1149        /**
1150         * @return {@link #type} (The type of container associated with the specimen (e.g. slide, aliquot, etc.).)
1151         */
1152        public CodeableConcept getType() { 
1153          if (this.type == null)
1154            if (Configuration.errorOnAutoCreate())
1155              throw new Error("Attempt to auto-create SpecimenContainerComponent.type");
1156            else if (Configuration.doAutoCreate())
1157              this.type = new CodeableConcept(); // cc
1158          return this.type;
1159        }
1160
1161        public boolean hasType() { 
1162          return this.type != null && !this.type.isEmpty();
1163        }
1164
1165        /**
1166         * @param value {@link #type} (The type of container associated with the specimen (e.g. slide, aliquot, etc.).)
1167         */
1168        public SpecimenContainerComponent setType(CodeableConcept value)  { 
1169          this.type = value;
1170          return this;
1171        }
1172
1173        /**
1174         * @return {@link #capacity} (The capacity (volume or other measure) the container may contain.)
1175         */
1176        public SimpleQuantity getCapacity() { 
1177          if (this.capacity == null)
1178            if (Configuration.errorOnAutoCreate())
1179              throw new Error("Attempt to auto-create SpecimenContainerComponent.capacity");
1180            else if (Configuration.doAutoCreate())
1181              this.capacity = new SimpleQuantity(); // cc
1182          return this.capacity;
1183        }
1184
1185        public boolean hasCapacity() { 
1186          return this.capacity != null && !this.capacity.isEmpty();
1187        }
1188
1189        /**
1190         * @param value {@link #capacity} (The capacity (volume or other measure) the container may contain.)
1191         */
1192        public SpecimenContainerComponent setCapacity(SimpleQuantity value)  { 
1193          this.capacity = value;
1194          return this;
1195        }
1196
1197        /**
1198         * @return {@link #specimenQuantity} (The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type.)
1199         */
1200        public SimpleQuantity getSpecimenQuantity() { 
1201          if (this.specimenQuantity == null)
1202            if (Configuration.errorOnAutoCreate())
1203              throw new Error("Attempt to auto-create SpecimenContainerComponent.specimenQuantity");
1204            else if (Configuration.doAutoCreate())
1205              this.specimenQuantity = new SimpleQuantity(); // cc
1206          return this.specimenQuantity;
1207        }
1208
1209        public boolean hasSpecimenQuantity() { 
1210          return this.specimenQuantity != null && !this.specimenQuantity.isEmpty();
1211        }
1212
1213        /**
1214         * @param value {@link #specimenQuantity} (The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type.)
1215         */
1216        public SpecimenContainerComponent setSpecimenQuantity(SimpleQuantity value)  { 
1217          this.specimenQuantity = value;
1218          return this;
1219        }
1220
1221        /**
1222         * @return {@link #additive} (Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.)
1223         */
1224        public Type getAdditive() { 
1225          return this.additive;
1226        }
1227
1228        /**
1229         * @return {@link #additive} (Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.)
1230         */
1231        public CodeableConcept getAdditiveCodeableConcept() throws FHIRException { 
1232          if (this.additive == null)
1233            return null;
1234          if (!(this.additive instanceof CodeableConcept))
1235            throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.additive.getClass().getName()+" was encountered");
1236          return (CodeableConcept) this.additive;
1237        }
1238
1239        public boolean hasAdditiveCodeableConcept() { 
1240          return this != null && this.additive instanceof CodeableConcept;
1241        }
1242
1243        /**
1244         * @return {@link #additive} (Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.)
1245         */
1246        public Reference getAdditiveReference() throws FHIRException { 
1247          if (this.additive == null)
1248            return null;
1249          if (!(this.additive instanceof Reference))
1250            throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.additive.getClass().getName()+" was encountered");
1251          return (Reference) this.additive;
1252        }
1253
1254        public boolean hasAdditiveReference() { 
1255          return this != null && this.additive instanceof Reference;
1256        }
1257
1258        public boolean hasAdditive() { 
1259          return this.additive != null && !this.additive.isEmpty();
1260        }
1261
1262        /**
1263         * @param value {@link #additive} (Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.)
1264         */
1265        public SpecimenContainerComponent setAdditive(Type value) throws FHIRFormatError { 
1266          if (value != null && !(value instanceof CodeableConcept || value instanceof Reference))
1267            throw new FHIRFormatError("Not the right type for Specimen.container.additive[x]: "+value.fhirType());
1268          this.additive = value;
1269          return this;
1270        }
1271
1272        protected void listChildren(List<Property> children) {
1273          super.listChildren(children);
1274          children.add(new Property("identifier", "Identifier", "Id for container. There may be multiple; a manufacturer's bar code, lab assigned identifier, etc. The container ID may differ from the specimen id in some circumstances.", 0, java.lang.Integer.MAX_VALUE, identifier));
1275          children.add(new Property("description", "string", "Textual description of the container.", 0, 1, description));
1276          children.add(new Property("type", "CodeableConcept", "The type of container associated with the specimen (e.g. slide, aliquot, etc.).", 0, 1, type));
1277          children.add(new Property("capacity", "SimpleQuantity", "The capacity (volume or other measure) the container may contain.", 0, 1, capacity));
1278          children.add(new Property("specimenQuantity", "SimpleQuantity", "The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type.", 0, 1, specimenQuantity));
1279          children.add(new Property("additive[x]", "CodeableConcept|Reference(Substance)", "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.", 0, 1, additive));
1280        }
1281
1282        @Override
1283        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1284          switch (_hash) {
1285          case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "Id for container. There may be multiple; a manufacturer's bar code, lab assigned identifier, etc. The container ID may differ from the specimen id in some circumstances.", 0, java.lang.Integer.MAX_VALUE, identifier);
1286          case -1724546052: /*description*/  return new Property("description", "string", "Textual description of the container.", 0, 1, description);
1287          case 3575610: /*type*/  return new Property("type", "CodeableConcept", "The type of container associated with the specimen (e.g. slide, aliquot, etc.).", 0, 1, type);
1288          case -67824454: /*capacity*/  return new Property("capacity", "SimpleQuantity", "The capacity (volume or other measure) the container may contain.", 0, 1, capacity);
1289          case 1485980595: /*specimenQuantity*/  return new Property("specimenQuantity", "SimpleQuantity", "The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type.", 0, 1, specimenQuantity);
1290          case 261915956: /*additive[x]*/  return new Property("additive[x]", "CodeableConcept|Reference(Substance)", "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.", 0, 1, additive);
1291          case -1226589236: /*additive*/  return new Property("additive[x]", "CodeableConcept|Reference(Substance)", "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.", 0, 1, additive);
1292          case 1330272821: /*additiveCodeableConcept*/  return new Property("additive[x]", "CodeableConcept|Reference(Substance)", "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.", 0, 1, additive);
1293          case -386783009: /*additiveReference*/  return new Property("additive[x]", "CodeableConcept|Reference(Substance)", "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.", 0, 1, additive);
1294          default: return super.getNamedProperty(_hash, _name, _checkValid);
1295          }
1296
1297        }
1298
1299      @Override
1300      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1301        switch (hash) {
1302        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
1303        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
1304        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept
1305        case -67824454: /*capacity*/ return this.capacity == null ? new Base[0] : new Base[] {this.capacity}; // SimpleQuantity
1306        case 1485980595: /*specimenQuantity*/ return this.specimenQuantity == null ? new Base[0] : new Base[] {this.specimenQuantity}; // SimpleQuantity
1307        case -1226589236: /*additive*/ return this.additive == null ? new Base[0] : new Base[] {this.additive}; // Type
1308        default: return super.getProperty(hash, name, checkValid);
1309        }
1310
1311      }
1312
1313      @Override
1314      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1315        switch (hash) {
1316        case -1618432855: // identifier
1317          this.getIdentifier().add(castToIdentifier(value)); // Identifier
1318          return value;
1319        case -1724546052: // description
1320          this.description = castToString(value); // StringType
1321          return value;
1322        case 3575610: // type
1323          this.type = castToCodeableConcept(value); // CodeableConcept
1324          return value;
1325        case -67824454: // capacity
1326          this.capacity = castToSimpleQuantity(value); // SimpleQuantity
1327          return value;
1328        case 1485980595: // specimenQuantity
1329          this.specimenQuantity = castToSimpleQuantity(value); // SimpleQuantity
1330          return value;
1331        case -1226589236: // additive
1332          this.additive = castToType(value); // Type
1333          return value;
1334        default: return super.setProperty(hash, name, value);
1335        }
1336
1337      }
1338
1339      @Override
1340      public Base setProperty(String name, Base value) throws FHIRException {
1341        if (name.equals("identifier")) {
1342          this.getIdentifier().add(castToIdentifier(value));
1343        } else if (name.equals("description")) {
1344          this.description = castToString(value); // StringType
1345        } else if (name.equals("type")) {
1346          this.type = castToCodeableConcept(value); // CodeableConcept
1347        } else if (name.equals("capacity")) {
1348          this.capacity = castToSimpleQuantity(value); // SimpleQuantity
1349        } else if (name.equals("specimenQuantity")) {
1350          this.specimenQuantity = castToSimpleQuantity(value); // SimpleQuantity
1351        } else if (name.equals("additive[x]")) {
1352          this.additive = castToType(value); // Type
1353        } else
1354          return super.setProperty(name, value);
1355        return value;
1356      }
1357
1358      @Override
1359      public Base makeProperty(int hash, String name) throws FHIRException {
1360        switch (hash) {
1361        case -1618432855:  return addIdentifier(); 
1362        case -1724546052:  return getDescriptionElement();
1363        case 3575610:  return getType(); 
1364        case -67824454:  return getCapacity(); 
1365        case 1485980595:  return getSpecimenQuantity(); 
1366        case 261915956:  return getAdditive(); 
1367        case -1226589236:  return getAdditive(); 
1368        default: return super.makeProperty(hash, name);
1369        }
1370
1371      }
1372
1373      @Override
1374      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1375        switch (hash) {
1376        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
1377        case -1724546052: /*description*/ return new String[] {"string"};
1378        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
1379        case -67824454: /*capacity*/ return new String[] {"SimpleQuantity"};
1380        case 1485980595: /*specimenQuantity*/ return new String[] {"SimpleQuantity"};
1381        case -1226589236: /*additive*/ return new String[] {"CodeableConcept", "Reference"};
1382        default: return super.getTypesForProperty(hash, name);
1383        }
1384
1385      }
1386
1387      @Override
1388      public Base addChild(String name) throws FHIRException {
1389        if (name.equals("identifier")) {
1390          return addIdentifier();
1391        }
1392        else if (name.equals("description")) {
1393          throw new FHIRException("Cannot call addChild on a primitive type Specimen.description");
1394        }
1395        else if (name.equals("type")) {
1396          this.type = new CodeableConcept();
1397          return this.type;
1398        }
1399        else if (name.equals("capacity")) {
1400          this.capacity = new SimpleQuantity();
1401          return this.capacity;
1402        }
1403        else if (name.equals("specimenQuantity")) {
1404          this.specimenQuantity = new SimpleQuantity();
1405          return this.specimenQuantity;
1406        }
1407        else if (name.equals("additiveCodeableConcept")) {
1408          this.additive = new CodeableConcept();
1409          return this.additive;
1410        }
1411        else if (name.equals("additiveReference")) {
1412          this.additive = new Reference();
1413          return this.additive;
1414        }
1415        else
1416          return super.addChild(name);
1417      }
1418
1419      public SpecimenContainerComponent copy() {
1420        SpecimenContainerComponent dst = new SpecimenContainerComponent();
1421        copyValues(dst);
1422        if (identifier != null) {
1423          dst.identifier = new ArrayList<Identifier>();
1424          for (Identifier i : identifier)
1425            dst.identifier.add(i.copy());
1426        };
1427        dst.description = description == null ? null : description.copy();
1428        dst.type = type == null ? null : type.copy();
1429        dst.capacity = capacity == null ? null : capacity.copy();
1430        dst.specimenQuantity = specimenQuantity == null ? null : specimenQuantity.copy();
1431        dst.additive = additive == null ? null : additive.copy();
1432        return dst;
1433      }
1434
1435      @Override
1436      public boolean equalsDeep(Base other_) {
1437        if (!super.equalsDeep(other_))
1438          return false;
1439        if (!(other_ instanceof SpecimenContainerComponent))
1440          return false;
1441        SpecimenContainerComponent o = (SpecimenContainerComponent) other_;
1442        return compareDeep(identifier, o.identifier, true) && compareDeep(description, o.description, true)
1443           && compareDeep(type, o.type, true) && compareDeep(capacity, o.capacity, true) && compareDeep(specimenQuantity, o.specimenQuantity, true)
1444           && compareDeep(additive, o.additive, true);
1445      }
1446
1447      @Override
1448      public boolean equalsShallow(Base other_) {
1449        if (!super.equalsShallow(other_))
1450          return false;
1451        if (!(other_ instanceof SpecimenContainerComponent))
1452          return false;
1453        SpecimenContainerComponent o = (SpecimenContainerComponent) other_;
1454        return compareValues(description, o.description, true);
1455      }
1456
1457      public boolean isEmpty() {
1458        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, description, type
1459          , capacity, specimenQuantity, additive);
1460      }
1461
1462  public String fhirType() {
1463    return "Specimen.container";
1464
1465  }
1466
1467  }
1468
1469    /**
1470     * Id for specimen.
1471     */
1472    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1473    @Description(shortDefinition="External Identifier", formalDefinition="Id for specimen." )
1474    protected List<Identifier> identifier;
1475
1476    /**
1477     * The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures.
1478     */
1479    @Child(name = "accessionIdentifier", type = {Identifier.class}, order=1, min=0, max=1, modifier=false, summary=true)
1480    @Description(shortDefinition="Identifier assigned by the lab", formalDefinition="The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures." )
1481    protected Identifier accessionIdentifier;
1482
1483    /**
1484     * The availability of the specimen.
1485     */
1486    @Child(name = "status", type = {CodeType.class}, order=2, min=0, max=1, modifier=true, summary=true)
1487    @Description(shortDefinition="available | unavailable | unsatisfactory | entered-in-error", formalDefinition="The availability of the specimen." )
1488    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/specimen-status")
1489    protected Enumeration<SpecimenStatus> status;
1490
1491    /**
1492     * The kind of material that forms the specimen.
1493     */
1494    @Child(name = "type", type = {CodeableConcept.class}, order=3, min=0, max=1, modifier=false, summary=true)
1495    @Description(shortDefinition="Kind of material that forms the specimen", formalDefinition="The kind of material that forms the specimen." )
1496    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/v2-0487")
1497    protected CodeableConcept type;
1498
1499    /**
1500     * Where the specimen came from. This may be from the patient(s) or from the environment or a device.
1501     */
1502    @Child(name = "subject", type = {Patient.class, Group.class, Device.class, Substance.class}, order=4, min=1, max=1, modifier=false, summary=true)
1503    @Description(shortDefinition="Where the specimen came from. This may be from the patient(s) or from the environment or a device", formalDefinition="Where the specimen came from. This may be from the patient(s) or from the environment or a device." )
1504    protected Reference subject;
1505
1506    /**
1507     * The actual object that is the target of the reference (Where the specimen came from. This may be from the patient(s) or from the environment or a device.)
1508     */
1509    protected Resource subjectTarget;
1510
1511    /**
1512     * Time when specimen was received for processing or testing.
1513     */
1514    @Child(name = "receivedTime", type = {DateTimeType.class}, order=5, min=0, max=1, modifier=false, summary=true)
1515    @Description(shortDefinition="The time when specimen was received for processing", formalDefinition="Time when specimen was received for processing or testing." )
1516    protected DateTimeType receivedTime;
1517
1518    /**
1519     * Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen.
1520     */
1521    @Child(name = "parent", type = {Specimen.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1522    @Description(shortDefinition="Specimen from which this specimen originated", formalDefinition="Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen." )
1523    protected List<Reference> parent;
1524    /**
1525     * The actual objects that are the target of the reference (Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen.)
1526     */
1527    protected List<Specimen> parentTarget;
1528
1529
1530    /**
1531     * Details concerning a test or procedure request that required a specimen to be collected.
1532     */
1533    @Child(name = "request", type = {ProcedureRequest.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1534    @Description(shortDefinition="Why the specimen was collected", formalDefinition="Details concerning a test or procedure request that required a specimen to be collected." )
1535    protected List<Reference> request;
1536    /**
1537     * The actual objects that are the target of the reference (Details concerning a test or procedure request that required a specimen to be collected.)
1538     */
1539    protected List<ProcedureRequest> requestTarget;
1540
1541
1542    /**
1543     * Details concerning the specimen collection.
1544     */
1545    @Child(name = "collection", type = {}, order=8, min=0, max=1, modifier=false, summary=false)
1546    @Description(shortDefinition="Collection details", formalDefinition="Details concerning the specimen collection." )
1547    protected SpecimenCollectionComponent collection;
1548
1549    /**
1550     * Details concerning processing and processing steps for the specimen.
1551     */
1552    @Child(name = "processing", type = {}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1553    @Description(shortDefinition="Processing and processing step details", formalDefinition="Details concerning processing and processing steps for the specimen." )
1554    protected List<SpecimenProcessingComponent> processing;
1555
1556    /**
1557     * The container holding the specimen.  The recursive nature of containers; i.e. blood in tube in tray in rack is not addressed here.
1558     */
1559    @Child(name = "container", type = {}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1560    @Description(shortDefinition="Direct container of specimen (tube/slide, etc.)", formalDefinition="The container holding the specimen.  The recursive nature of containers; i.e. blood in tube in tray in rack is not addressed here." )
1561    protected List<SpecimenContainerComponent> container;
1562
1563    /**
1564     * To communicate any details or issues about the specimen or during the specimen collection. (for example: broken vial, sent with patient, frozen).
1565     */
1566    @Child(name = "note", type = {Annotation.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1567    @Description(shortDefinition="Comments", formalDefinition="To communicate any details or issues about the specimen or during the specimen collection. (for example: broken vial, sent with patient, frozen)." )
1568    protected List<Annotation> note;
1569
1570    private static final long serialVersionUID = -743921079L;
1571
1572  /**
1573   * Constructor
1574   */
1575    public Specimen() {
1576      super();
1577    }
1578
1579  /**
1580   * Constructor
1581   */
1582    public Specimen(Reference subject) {
1583      super();
1584      this.subject = subject;
1585    }
1586
1587    /**
1588     * @return {@link #identifier} (Id for specimen.)
1589     */
1590    public List<Identifier> getIdentifier() { 
1591      if (this.identifier == null)
1592        this.identifier = new ArrayList<Identifier>();
1593      return this.identifier;
1594    }
1595
1596    /**
1597     * @return Returns a reference to <code>this</code> for easy method chaining
1598     */
1599    public Specimen setIdentifier(List<Identifier> theIdentifier) { 
1600      this.identifier = theIdentifier;
1601      return this;
1602    }
1603
1604    public boolean hasIdentifier() { 
1605      if (this.identifier == null)
1606        return false;
1607      for (Identifier item : this.identifier)
1608        if (!item.isEmpty())
1609          return true;
1610      return false;
1611    }
1612
1613    public Identifier addIdentifier() { //3
1614      Identifier t = new Identifier();
1615      if (this.identifier == null)
1616        this.identifier = new ArrayList<Identifier>();
1617      this.identifier.add(t);
1618      return t;
1619    }
1620
1621    public Specimen addIdentifier(Identifier t) { //3
1622      if (t == null)
1623        return this;
1624      if (this.identifier == null)
1625        this.identifier = new ArrayList<Identifier>();
1626      this.identifier.add(t);
1627      return this;
1628    }
1629
1630    /**
1631     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist
1632     */
1633    public Identifier getIdentifierFirstRep() { 
1634      if (getIdentifier().isEmpty()) {
1635        addIdentifier();
1636      }
1637      return getIdentifier().get(0);
1638    }
1639
1640    /**
1641     * @return {@link #accessionIdentifier} (The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures.)
1642     */
1643    public Identifier getAccessionIdentifier() { 
1644      if (this.accessionIdentifier == null)
1645        if (Configuration.errorOnAutoCreate())
1646          throw new Error("Attempt to auto-create Specimen.accessionIdentifier");
1647        else if (Configuration.doAutoCreate())
1648          this.accessionIdentifier = new Identifier(); // cc
1649      return this.accessionIdentifier;
1650    }
1651
1652    public boolean hasAccessionIdentifier() { 
1653      return this.accessionIdentifier != null && !this.accessionIdentifier.isEmpty();
1654    }
1655
1656    /**
1657     * @param value {@link #accessionIdentifier} (The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures.)
1658     */
1659    public Specimen setAccessionIdentifier(Identifier value)  { 
1660      this.accessionIdentifier = value;
1661      return this;
1662    }
1663
1664    /**
1665     * @return {@link #status} (The availability of the specimen.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
1666     */
1667    public Enumeration<SpecimenStatus> getStatusElement() { 
1668      if (this.status == null)
1669        if (Configuration.errorOnAutoCreate())
1670          throw new Error("Attempt to auto-create Specimen.status");
1671        else if (Configuration.doAutoCreate())
1672          this.status = new Enumeration<SpecimenStatus>(new SpecimenStatusEnumFactory()); // bb
1673      return this.status;
1674    }
1675
1676    public boolean hasStatusElement() { 
1677      return this.status != null && !this.status.isEmpty();
1678    }
1679
1680    public boolean hasStatus() { 
1681      return this.status != null && !this.status.isEmpty();
1682    }
1683
1684    /**
1685     * @param value {@link #status} (The availability of the specimen.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
1686     */
1687    public Specimen setStatusElement(Enumeration<SpecimenStatus> value) { 
1688      this.status = value;
1689      return this;
1690    }
1691
1692    /**
1693     * @return The availability of the specimen.
1694     */
1695    public SpecimenStatus getStatus() { 
1696      return this.status == null ? null : this.status.getValue();
1697    }
1698
1699    /**
1700     * @param value The availability of the specimen.
1701     */
1702    public Specimen setStatus(SpecimenStatus value) { 
1703      if (value == null)
1704        this.status = null;
1705      else {
1706        if (this.status == null)
1707          this.status = new Enumeration<SpecimenStatus>(new SpecimenStatusEnumFactory());
1708        this.status.setValue(value);
1709      }
1710      return this;
1711    }
1712
1713    /**
1714     * @return {@link #type} (The kind of material that forms the specimen.)
1715     */
1716    public CodeableConcept getType() { 
1717      if (this.type == null)
1718        if (Configuration.errorOnAutoCreate())
1719          throw new Error("Attempt to auto-create Specimen.type");
1720        else if (Configuration.doAutoCreate())
1721          this.type = new CodeableConcept(); // cc
1722      return this.type;
1723    }
1724
1725    public boolean hasType() { 
1726      return this.type != null && !this.type.isEmpty();
1727    }
1728
1729    /**
1730     * @param value {@link #type} (The kind of material that forms the specimen.)
1731     */
1732    public Specimen setType(CodeableConcept value)  { 
1733      this.type = value;
1734      return this;
1735    }
1736
1737    /**
1738     * @return {@link #subject} (Where the specimen came from. This may be from the patient(s) or from the environment or a device.)
1739     */
1740    public Reference getSubject() { 
1741      if (this.subject == null)
1742        if (Configuration.errorOnAutoCreate())
1743          throw new Error("Attempt to auto-create Specimen.subject");
1744        else if (Configuration.doAutoCreate())
1745          this.subject = new Reference(); // cc
1746      return this.subject;
1747    }
1748
1749    public boolean hasSubject() { 
1750      return this.subject != null && !this.subject.isEmpty();
1751    }
1752
1753    /**
1754     * @param value {@link #subject} (Where the specimen came from. This may be from the patient(s) or from the environment or a device.)
1755     */
1756    public Specimen setSubject(Reference value)  { 
1757      this.subject = value;
1758      return this;
1759    }
1760
1761    /**
1762     * @return {@link #subject} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Where the specimen came from. This may be from the patient(s) or from the environment or a device.)
1763     */
1764    public Resource getSubjectTarget() { 
1765      return this.subjectTarget;
1766    }
1767
1768    /**
1769     * @param value {@link #subject} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Where the specimen came from. This may be from the patient(s) or from the environment or a device.)
1770     */
1771    public Specimen setSubjectTarget(Resource value) { 
1772      this.subjectTarget = value;
1773      return this;
1774    }
1775
1776    /**
1777     * @return {@link #receivedTime} (Time when specimen was received for processing or testing.). This is the underlying object with id, value and extensions. The accessor "getReceivedTime" gives direct access to the value
1778     */
1779    public DateTimeType getReceivedTimeElement() { 
1780      if (this.receivedTime == null)
1781        if (Configuration.errorOnAutoCreate())
1782          throw new Error("Attempt to auto-create Specimen.receivedTime");
1783        else if (Configuration.doAutoCreate())
1784          this.receivedTime = new DateTimeType(); // bb
1785      return this.receivedTime;
1786    }
1787
1788    public boolean hasReceivedTimeElement() { 
1789      return this.receivedTime != null && !this.receivedTime.isEmpty();
1790    }
1791
1792    public boolean hasReceivedTime() { 
1793      return this.receivedTime != null && !this.receivedTime.isEmpty();
1794    }
1795
1796    /**
1797     * @param value {@link #receivedTime} (Time when specimen was received for processing or testing.). This is the underlying object with id, value and extensions. The accessor "getReceivedTime" gives direct access to the value
1798     */
1799    public Specimen setReceivedTimeElement(DateTimeType value) { 
1800      this.receivedTime = value;
1801      return this;
1802    }
1803
1804    /**
1805     * @return Time when specimen was received for processing or testing.
1806     */
1807    public Date getReceivedTime() { 
1808      return this.receivedTime == null ? null : this.receivedTime.getValue();
1809    }
1810
1811    /**
1812     * @param value Time when specimen was received for processing or testing.
1813     */
1814    public Specimen setReceivedTime(Date value) { 
1815      if (value == null)
1816        this.receivedTime = null;
1817      else {
1818        if (this.receivedTime == null)
1819          this.receivedTime = new DateTimeType();
1820        this.receivedTime.setValue(value);
1821      }
1822      return this;
1823    }
1824
1825    /**
1826     * @return {@link #parent} (Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen.)
1827     */
1828    public List<Reference> getParent() { 
1829      if (this.parent == null)
1830        this.parent = new ArrayList<Reference>();
1831      return this.parent;
1832    }
1833
1834    /**
1835     * @return Returns a reference to <code>this</code> for easy method chaining
1836     */
1837    public Specimen setParent(List<Reference> theParent) { 
1838      this.parent = theParent;
1839      return this;
1840    }
1841
1842    public boolean hasParent() { 
1843      if (this.parent == null)
1844        return false;
1845      for (Reference item : this.parent)
1846        if (!item.isEmpty())
1847          return true;
1848      return false;
1849    }
1850
1851    public Reference addParent() { //3
1852      Reference t = new Reference();
1853      if (this.parent == null)
1854        this.parent = new ArrayList<Reference>();
1855      this.parent.add(t);
1856      return t;
1857    }
1858
1859    public Specimen addParent(Reference t) { //3
1860      if (t == null)
1861        return this;
1862      if (this.parent == null)
1863        this.parent = new ArrayList<Reference>();
1864      this.parent.add(t);
1865      return this;
1866    }
1867
1868    /**
1869     * @return The first repetition of repeating field {@link #parent}, creating it if it does not already exist
1870     */
1871    public Reference getParentFirstRep() { 
1872      if (getParent().isEmpty()) {
1873        addParent();
1874      }
1875      return getParent().get(0);
1876    }
1877
1878    /**
1879     * @deprecated Use Reference#setResource(IBaseResource) instead
1880     */
1881    @Deprecated
1882    public List<Specimen> getParentTarget() { 
1883      if (this.parentTarget == null)
1884        this.parentTarget = new ArrayList<Specimen>();
1885      return this.parentTarget;
1886    }
1887
1888    /**
1889     * @deprecated Use Reference#setResource(IBaseResource) instead
1890     */
1891    @Deprecated
1892    public Specimen addParentTarget() { 
1893      Specimen r = new Specimen();
1894      if (this.parentTarget == null)
1895        this.parentTarget = new ArrayList<Specimen>();
1896      this.parentTarget.add(r);
1897      return r;
1898    }
1899
1900    /**
1901     * @return {@link #request} (Details concerning a test or procedure request that required a specimen to be collected.)
1902     */
1903    public List<Reference> getRequest() { 
1904      if (this.request == null)
1905        this.request = new ArrayList<Reference>();
1906      return this.request;
1907    }
1908
1909    /**
1910     * @return Returns a reference to <code>this</code> for easy method chaining
1911     */
1912    public Specimen setRequest(List<Reference> theRequest) { 
1913      this.request = theRequest;
1914      return this;
1915    }
1916
1917    public boolean hasRequest() { 
1918      if (this.request == null)
1919        return false;
1920      for (Reference item : this.request)
1921        if (!item.isEmpty())
1922          return true;
1923      return false;
1924    }
1925
1926    public Reference addRequest() { //3
1927      Reference t = new Reference();
1928      if (this.request == null)
1929        this.request = new ArrayList<Reference>();
1930      this.request.add(t);
1931      return t;
1932    }
1933
1934    public Specimen addRequest(Reference t) { //3
1935      if (t == null)
1936        return this;
1937      if (this.request == null)
1938        this.request = new ArrayList<Reference>();
1939      this.request.add(t);
1940      return this;
1941    }
1942
1943    /**
1944     * @return The first repetition of repeating field {@link #request}, creating it if it does not already exist
1945     */
1946    public Reference getRequestFirstRep() { 
1947      if (getRequest().isEmpty()) {
1948        addRequest();
1949      }
1950      return getRequest().get(0);
1951    }
1952
1953    /**
1954     * @deprecated Use Reference#setResource(IBaseResource) instead
1955     */
1956    @Deprecated
1957    public List<ProcedureRequest> getRequestTarget() { 
1958      if (this.requestTarget == null)
1959        this.requestTarget = new ArrayList<ProcedureRequest>();
1960      return this.requestTarget;
1961    }
1962
1963    /**
1964     * @deprecated Use Reference#setResource(IBaseResource) instead
1965     */
1966    @Deprecated
1967    public ProcedureRequest addRequestTarget() { 
1968      ProcedureRequest r = new ProcedureRequest();
1969      if (this.requestTarget == null)
1970        this.requestTarget = new ArrayList<ProcedureRequest>();
1971      this.requestTarget.add(r);
1972      return r;
1973    }
1974
1975    /**
1976     * @return {@link #collection} (Details concerning the specimen collection.)
1977     */
1978    public SpecimenCollectionComponent getCollection() { 
1979      if (this.collection == null)
1980        if (Configuration.errorOnAutoCreate())
1981          throw new Error("Attempt to auto-create Specimen.collection");
1982        else if (Configuration.doAutoCreate())
1983          this.collection = new SpecimenCollectionComponent(); // cc
1984      return this.collection;
1985    }
1986
1987    public boolean hasCollection() { 
1988      return this.collection != null && !this.collection.isEmpty();
1989    }
1990
1991    /**
1992     * @param value {@link #collection} (Details concerning the specimen collection.)
1993     */
1994    public Specimen setCollection(SpecimenCollectionComponent value)  { 
1995      this.collection = value;
1996      return this;
1997    }
1998
1999    /**
2000     * @return {@link #processing} (Details concerning processing and processing steps for the specimen.)
2001     */
2002    public List<SpecimenProcessingComponent> getProcessing() { 
2003      if (this.processing == null)
2004        this.processing = new ArrayList<SpecimenProcessingComponent>();
2005      return this.processing;
2006    }
2007
2008    /**
2009     * @return Returns a reference to <code>this</code> for easy method chaining
2010     */
2011    public Specimen setProcessing(List<SpecimenProcessingComponent> theProcessing) { 
2012      this.processing = theProcessing;
2013      return this;
2014    }
2015
2016    public boolean hasProcessing() { 
2017      if (this.processing == null)
2018        return false;
2019      for (SpecimenProcessingComponent item : this.processing)
2020        if (!item.isEmpty())
2021          return true;
2022      return false;
2023    }
2024
2025    public SpecimenProcessingComponent addProcessing() { //3
2026      SpecimenProcessingComponent t = new SpecimenProcessingComponent();
2027      if (this.processing == null)
2028        this.processing = new ArrayList<SpecimenProcessingComponent>();
2029      this.processing.add(t);
2030      return t;
2031    }
2032
2033    public Specimen addProcessing(SpecimenProcessingComponent t) { //3
2034      if (t == null)
2035        return this;
2036      if (this.processing == null)
2037        this.processing = new ArrayList<SpecimenProcessingComponent>();
2038      this.processing.add(t);
2039      return this;
2040    }
2041
2042    /**
2043     * @return The first repetition of repeating field {@link #processing}, creating it if it does not already exist
2044     */
2045    public SpecimenProcessingComponent getProcessingFirstRep() { 
2046      if (getProcessing().isEmpty()) {
2047        addProcessing();
2048      }
2049      return getProcessing().get(0);
2050    }
2051
2052    /**
2053     * @return {@link #container} (The container holding the specimen.  The recursive nature of containers; i.e. blood in tube in tray in rack is not addressed here.)
2054     */
2055    public List<SpecimenContainerComponent> getContainer() { 
2056      if (this.container == null)
2057        this.container = new ArrayList<SpecimenContainerComponent>();
2058      return this.container;
2059    }
2060
2061    /**
2062     * @return Returns a reference to <code>this</code> for easy method chaining
2063     */
2064    public Specimen setContainer(List<SpecimenContainerComponent> theContainer) { 
2065      this.container = theContainer;
2066      return this;
2067    }
2068
2069    public boolean hasContainer() { 
2070      if (this.container == null)
2071        return false;
2072      for (SpecimenContainerComponent item : this.container)
2073        if (!item.isEmpty())
2074          return true;
2075      return false;
2076    }
2077
2078    public SpecimenContainerComponent addContainer() { //3
2079      SpecimenContainerComponent t = new SpecimenContainerComponent();
2080      if (this.container == null)
2081        this.container = new ArrayList<SpecimenContainerComponent>();
2082      this.container.add(t);
2083      return t;
2084    }
2085
2086    public Specimen addContainer(SpecimenContainerComponent t) { //3
2087      if (t == null)
2088        return this;
2089      if (this.container == null)
2090        this.container = new ArrayList<SpecimenContainerComponent>();
2091      this.container.add(t);
2092      return this;
2093    }
2094
2095    /**
2096     * @return The first repetition of repeating field {@link #container}, creating it if it does not already exist
2097     */
2098    public SpecimenContainerComponent getContainerFirstRep() { 
2099      if (getContainer().isEmpty()) {
2100        addContainer();
2101      }
2102      return getContainer().get(0);
2103    }
2104
2105    /**
2106     * @return {@link #note} (To communicate any details or issues about the specimen or during the specimen collection. (for example: broken vial, sent with patient, frozen).)
2107     */
2108    public List<Annotation> getNote() { 
2109      if (this.note == null)
2110        this.note = new ArrayList<Annotation>();
2111      return this.note;
2112    }
2113
2114    /**
2115     * @return Returns a reference to <code>this</code> for easy method chaining
2116     */
2117    public Specimen setNote(List<Annotation> theNote) { 
2118      this.note = theNote;
2119      return this;
2120    }
2121
2122    public boolean hasNote() { 
2123      if (this.note == null)
2124        return false;
2125      for (Annotation item : this.note)
2126        if (!item.isEmpty())
2127          return true;
2128      return false;
2129    }
2130
2131    public Annotation addNote() { //3
2132      Annotation t = new Annotation();
2133      if (this.note == null)
2134        this.note = new ArrayList<Annotation>();
2135      this.note.add(t);
2136      return t;
2137    }
2138
2139    public Specimen addNote(Annotation t) { //3
2140      if (t == null)
2141        return this;
2142      if (this.note == null)
2143        this.note = new ArrayList<Annotation>();
2144      this.note.add(t);
2145      return this;
2146    }
2147
2148    /**
2149     * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist
2150     */
2151    public Annotation getNoteFirstRep() { 
2152      if (getNote().isEmpty()) {
2153        addNote();
2154      }
2155      return getNote().get(0);
2156    }
2157
2158      protected void listChildren(List<Property> children) {
2159        super.listChildren(children);
2160        children.add(new Property("identifier", "Identifier", "Id for specimen.", 0, java.lang.Integer.MAX_VALUE, identifier));
2161        children.add(new Property("accessionIdentifier", "Identifier", "The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures.", 0, 1, accessionIdentifier));
2162        children.add(new Property("status", "code", "The availability of the specimen.", 0, 1, status));
2163        children.add(new Property("type", "CodeableConcept", "The kind of material that forms the specimen.", 0, 1, type));
2164        children.add(new Property("subject", "Reference(Patient|Group|Device|Substance)", "Where the specimen came from. This may be from the patient(s) or from the environment or a device.", 0, 1, subject));
2165        children.add(new Property("receivedTime", "dateTime", "Time when specimen was received for processing or testing.", 0, 1, receivedTime));
2166        children.add(new Property("parent", "Reference(Specimen)", "Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen.", 0, java.lang.Integer.MAX_VALUE, parent));
2167        children.add(new Property("request", "Reference(ProcedureRequest)", "Details concerning a test or procedure request that required a specimen to be collected.", 0, java.lang.Integer.MAX_VALUE, request));
2168        children.add(new Property("collection", "", "Details concerning the specimen collection.", 0, 1, collection));
2169        children.add(new Property("processing", "", "Details concerning processing and processing steps for the specimen.", 0, java.lang.Integer.MAX_VALUE, processing));
2170        children.add(new Property("container", "", "The container holding the specimen.  The recursive nature of containers; i.e. blood in tube in tray in rack is not addressed here.", 0, java.lang.Integer.MAX_VALUE, container));
2171        children.add(new Property("note", "Annotation", "To communicate any details or issues about the specimen or during the specimen collection. (for example: broken vial, sent with patient, frozen).", 0, java.lang.Integer.MAX_VALUE, note));
2172      }
2173
2174      @Override
2175      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2176        switch (_hash) {
2177        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "Id for specimen.", 0, java.lang.Integer.MAX_VALUE, identifier);
2178        case 818734061: /*accessionIdentifier*/  return new Property("accessionIdentifier", "Identifier", "The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures.", 0, 1, accessionIdentifier);
2179        case -892481550: /*status*/  return new Property("status", "code", "The availability of the specimen.", 0, 1, status);
2180        case 3575610: /*type*/  return new Property("type", "CodeableConcept", "The kind of material that forms the specimen.", 0, 1, type);
2181        case -1867885268: /*subject*/  return new Property("subject", "Reference(Patient|Group|Device|Substance)", "Where the specimen came from. This may be from the patient(s) or from the environment or a device.", 0, 1, subject);
2182        case -767961010: /*receivedTime*/  return new Property("receivedTime", "dateTime", "Time when specimen was received for processing or testing.", 0, 1, receivedTime);
2183        case -995424086: /*parent*/  return new Property("parent", "Reference(Specimen)", "Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen.", 0, java.lang.Integer.MAX_VALUE, parent);
2184        case 1095692943: /*request*/  return new Property("request", "Reference(ProcedureRequest)", "Details concerning a test or procedure request that required a specimen to be collected.", 0, java.lang.Integer.MAX_VALUE, request);
2185        case -1741312354: /*collection*/  return new Property("collection", "", "Details concerning the specimen collection.", 0, 1, collection);
2186        case 422194963: /*processing*/  return new Property("processing", "", "Details concerning processing and processing steps for the specimen.", 0, java.lang.Integer.MAX_VALUE, processing);
2187        case -410956671: /*container*/  return new Property("container", "", "The container holding the specimen.  The recursive nature of containers; i.e. blood in tube in tray in rack is not addressed here.", 0, java.lang.Integer.MAX_VALUE, container);
2188        case 3387378: /*note*/  return new Property("note", "Annotation", "To communicate any details or issues about the specimen or during the specimen collection. (for example: broken vial, sent with patient, frozen).", 0, java.lang.Integer.MAX_VALUE, note);
2189        default: return super.getNamedProperty(_hash, _name, _checkValid);
2190        }
2191
2192      }
2193
2194      @Override
2195      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2196        switch (hash) {
2197        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
2198        case 818734061: /*accessionIdentifier*/ return this.accessionIdentifier == null ? new Base[0] : new Base[] {this.accessionIdentifier}; // Identifier
2199        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<SpecimenStatus>
2200        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept
2201        case -1867885268: /*subject*/ return this.subject == null ? new Base[0] : new Base[] {this.subject}; // Reference
2202        case -767961010: /*receivedTime*/ return this.receivedTime == null ? new Base[0] : new Base[] {this.receivedTime}; // DateTimeType
2203        case -995424086: /*parent*/ return this.parent == null ? new Base[0] : this.parent.toArray(new Base[this.parent.size()]); // Reference
2204        case 1095692943: /*request*/ return this.request == null ? new Base[0] : this.request.toArray(new Base[this.request.size()]); // Reference
2205        case -1741312354: /*collection*/ return this.collection == null ? new Base[0] : new Base[] {this.collection}; // SpecimenCollectionComponent
2206        case 422194963: /*processing*/ return this.processing == null ? new Base[0] : this.processing.toArray(new Base[this.processing.size()]); // SpecimenProcessingComponent
2207        case -410956671: /*container*/ return this.container == null ? new Base[0] : this.container.toArray(new Base[this.container.size()]); // SpecimenContainerComponent
2208        case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation
2209        default: return super.getProperty(hash, name, checkValid);
2210        }
2211
2212      }
2213
2214      @Override
2215      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2216        switch (hash) {
2217        case -1618432855: // identifier
2218          this.getIdentifier().add(castToIdentifier(value)); // Identifier
2219          return value;
2220        case 818734061: // accessionIdentifier
2221          this.accessionIdentifier = castToIdentifier(value); // Identifier
2222          return value;
2223        case -892481550: // status
2224          value = new SpecimenStatusEnumFactory().fromType(castToCode(value));
2225          this.status = (Enumeration) value; // Enumeration<SpecimenStatus>
2226          return value;
2227        case 3575610: // type
2228          this.type = castToCodeableConcept(value); // CodeableConcept
2229          return value;
2230        case -1867885268: // subject
2231          this.subject = castToReference(value); // Reference
2232          return value;
2233        case -767961010: // receivedTime
2234          this.receivedTime = castToDateTime(value); // DateTimeType
2235          return value;
2236        case -995424086: // parent
2237          this.getParent().add(castToReference(value)); // Reference
2238          return value;
2239        case 1095692943: // request
2240          this.getRequest().add(castToReference(value)); // Reference
2241          return value;
2242        case -1741312354: // collection
2243          this.collection = (SpecimenCollectionComponent) value; // SpecimenCollectionComponent
2244          return value;
2245        case 422194963: // processing
2246          this.getProcessing().add((SpecimenProcessingComponent) value); // SpecimenProcessingComponent
2247          return value;
2248        case -410956671: // container
2249          this.getContainer().add((SpecimenContainerComponent) value); // SpecimenContainerComponent
2250          return value;
2251        case 3387378: // note
2252          this.getNote().add(castToAnnotation(value)); // Annotation
2253          return value;
2254        default: return super.setProperty(hash, name, value);
2255        }
2256
2257      }
2258
2259      @Override
2260      public Base setProperty(String name, Base value) throws FHIRException {
2261        if (name.equals("identifier")) {
2262          this.getIdentifier().add(castToIdentifier(value));
2263        } else if (name.equals("accessionIdentifier")) {
2264          this.accessionIdentifier = castToIdentifier(value); // Identifier
2265        } else if (name.equals("status")) {
2266          value = new SpecimenStatusEnumFactory().fromType(castToCode(value));
2267          this.status = (Enumeration) value; // Enumeration<SpecimenStatus>
2268        } else if (name.equals("type")) {
2269          this.type = castToCodeableConcept(value); // CodeableConcept
2270        } else if (name.equals("subject")) {
2271          this.subject = castToReference(value); // Reference
2272        } else if (name.equals("receivedTime")) {
2273          this.receivedTime = castToDateTime(value); // DateTimeType
2274        } else if (name.equals("parent")) {
2275          this.getParent().add(castToReference(value));
2276        } else if (name.equals("request")) {
2277          this.getRequest().add(castToReference(value));
2278        } else if (name.equals("collection")) {
2279          this.collection = (SpecimenCollectionComponent) value; // SpecimenCollectionComponent
2280        } else if (name.equals("processing")) {
2281          this.getProcessing().add((SpecimenProcessingComponent) value);
2282        } else if (name.equals("container")) {
2283          this.getContainer().add((SpecimenContainerComponent) value);
2284        } else if (name.equals("note")) {
2285          this.getNote().add(castToAnnotation(value));
2286        } else
2287          return super.setProperty(name, value);
2288        return value;
2289      }
2290
2291      @Override
2292      public Base makeProperty(int hash, String name) throws FHIRException {
2293        switch (hash) {
2294        case -1618432855:  return addIdentifier(); 
2295        case 818734061:  return getAccessionIdentifier(); 
2296        case -892481550:  return getStatusElement();
2297        case 3575610:  return getType(); 
2298        case -1867885268:  return getSubject(); 
2299        case -767961010:  return getReceivedTimeElement();
2300        case -995424086:  return addParent(); 
2301        case 1095692943:  return addRequest(); 
2302        case -1741312354:  return getCollection(); 
2303        case 422194963:  return addProcessing(); 
2304        case -410956671:  return addContainer(); 
2305        case 3387378:  return addNote(); 
2306        default: return super.makeProperty(hash, name);
2307        }
2308
2309      }
2310
2311      @Override
2312      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2313        switch (hash) {
2314        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
2315        case 818734061: /*accessionIdentifier*/ return new String[] {"Identifier"};
2316        case -892481550: /*status*/ return new String[] {"code"};
2317        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
2318        case -1867885268: /*subject*/ return new String[] {"Reference"};
2319        case -767961010: /*receivedTime*/ return new String[] {"dateTime"};
2320        case -995424086: /*parent*/ return new String[] {"Reference"};
2321        case 1095692943: /*request*/ return new String[] {"Reference"};
2322        case -1741312354: /*collection*/ return new String[] {};
2323        case 422194963: /*processing*/ return new String[] {};
2324        case -410956671: /*container*/ return new String[] {};
2325        case 3387378: /*note*/ return new String[] {"Annotation"};
2326        default: return super.getTypesForProperty(hash, name);
2327        }
2328
2329      }
2330
2331      @Override
2332      public Base addChild(String name) throws FHIRException {
2333        if (name.equals("identifier")) {
2334          return addIdentifier();
2335        }
2336        else if (name.equals("accessionIdentifier")) {
2337          this.accessionIdentifier = new Identifier();
2338          return this.accessionIdentifier;
2339        }
2340        else if (name.equals("status")) {
2341          throw new FHIRException("Cannot call addChild on a primitive type Specimen.status");
2342        }
2343        else if (name.equals("type")) {
2344          this.type = new CodeableConcept();
2345          return this.type;
2346        }
2347        else if (name.equals("subject")) {
2348          this.subject = new Reference();
2349          return this.subject;
2350        }
2351        else if (name.equals("receivedTime")) {
2352          throw new FHIRException("Cannot call addChild on a primitive type Specimen.receivedTime");
2353        }
2354        else if (name.equals("parent")) {
2355          return addParent();
2356        }
2357        else if (name.equals("request")) {
2358          return addRequest();
2359        }
2360        else if (name.equals("collection")) {
2361          this.collection = new SpecimenCollectionComponent();
2362          return this.collection;
2363        }
2364        else if (name.equals("processing")) {
2365          return addProcessing();
2366        }
2367        else if (name.equals("container")) {
2368          return addContainer();
2369        }
2370        else if (name.equals("note")) {
2371          return addNote();
2372        }
2373        else
2374          return super.addChild(name);
2375      }
2376
2377  public String fhirType() {
2378    return "Specimen";
2379
2380  }
2381
2382      public Specimen copy() {
2383        Specimen dst = new Specimen();
2384        copyValues(dst);
2385        if (identifier != null) {
2386          dst.identifier = new ArrayList<Identifier>();
2387          for (Identifier i : identifier)
2388            dst.identifier.add(i.copy());
2389        };
2390        dst.accessionIdentifier = accessionIdentifier == null ? null : accessionIdentifier.copy();
2391        dst.status = status == null ? null : status.copy();
2392        dst.type = type == null ? null : type.copy();
2393        dst.subject = subject == null ? null : subject.copy();
2394        dst.receivedTime = receivedTime == null ? null : receivedTime.copy();
2395        if (parent != null) {
2396          dst.parent = new ArrayList<Reference>();
2397          for (Reference i : parent)
2398            dst.parent.add(i.copy());
2399        };
2400        if (request != null) {
2401          dst.request = new ArrayList<Reference>();
2402          for (Reference i : request)
2403            dst.request.add(i.copy());
2404        };
2405        dst.collection = collection == null ? null : collection.copy();
2406        if (processing != null) {
2407          dst.processing = new ArrayList<SpecimenProcessingComponent>();
2408          for (SpecimenProcessingComponent i : processing)
2409            dst.processing.add(i.copy());
2410        };
2411        if (container != null) {
2412          dst.container = new ArrayList<SpecimenContainerComponent>();
2413          for (SpecimenContainerComponent i : container)
2414            dst.container.add(i.copy());
2415        };
2416        if (note != null) {
2417          dst.note = new ArrayList<Annotation>();
2418          for (Annotation i : note)
2419            dst.note.add(i.copy());
2420        };
2421        return dst;
2422      }
2423
2424      protected Specimen typedCopy() {
2425        return copy();
2426      }
2427
2428      @Override
2429      public boolean equalsDeep(Base other_) {
2430        if (!super.equalsDeep(other_))
2431          return false;
2432        if (!(other_ instanceof Specimen))
2433          return false;
2434        Specimen o = (Specimen) other_;
2435        return compareDeep(identifier, o.identifier, true) && compareDeep(accessionIdentifier, o.accessionIdentifier, true)
2436           && compareDeep(status, o.status, true) && compareDeep(type, o.type, true) && compareDeep(subject, o.subject, true)
2437           && compareDeep(receivedTime, o.receivedTime, true) && compareDeep(parent, o.parent, true) && compareDeep(request, o.request, true)
2438           && compareDeep(collection, o.collection, true) && compareDeep(processing, o.processing, true) && compareDeep(container, o.container, true)
2439           && compareDeep(note, o.note, true);
2440      }
2441
2442      @Override
2443      public boolean equalsShallow(Base other_) {
2444        if (!super.equalsShallow(other_))
2445          return false;
2446        if (!(other_ instanceof Specimen))
2447          return false;
2448        Specimen o = (Specimen) other_;
2449        return compareValues(status, o.status, true) && compareValues(receivedTime, o.receivedTime, true);
2450      }
2451
2452      public boolean isEmpty() {
2453        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, accessionIdentifier
2454          , status, type, subject, receivedTime, parent, request, collection, processing
2455          , container, note);
2456      }
2457
2458  @Override
2459  public ResourceType getResourceType() {
2460    return ResourceType.Specimen;
2461   }
2462
2463 /**
2464   * Search parameter: <b>container</b>
2465   * <p>
2466   * Description: <b>The kind of specimen container</b><br>
2467   * Type: <b>token</b><br>
2468   * Path: <b>Specimen.container.type</b><br>
2469   * </p>
2470   */
2471  @SearchParamDefinition(name="container", path="Specimen.container.type", description="The kind of specimen container", type="token" )
2472  public static final String SP_CONTAINER = "container";
2473 /**
2474   * <b>Fluent Client</b> search parameter constant for <b>container</b>
2475   * <p>
2476   * Description: <b>The kind of specimen container</b><br>
2477   * Type: <b>token</b><br>
2478   * Path: <b>Specimen.container.type</b><br>
2479   * </p>
2480   */
2481  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTAINER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTAINER);
2482
2483 /**
2484   * Search parameter: <b>identifier</b>
2485   * <p>
2486   * Description: <b>The unique identifier associated with the specimen</b><br>
2487   * Type: <b>token</b><br>
2488   * Path: <b>Specimen.identifier</b><br>
2489   * </p>
2490   */
2491  @SearchParamDefinition(name="identifier", path="Specimen.identifier", description="The unique identifier associated with the specimen", type="token" )
2492  public static final String SP_IDENTIFIER = "identifier";
2493 /**
2494   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
2495   * <p>
2496   * Description: <b>The unique identifier associated with the specimen</b><br>
2497   * Type: <b>token</b><br>
2498   * Path: <b>Specimen.identifier</b><br>
2499   * </p>
2500   */
2501  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
2502
2503 /**
2504   * Search parameter: <b>parent</b>
2505   * <p>
2506   * Description: <b>The parent of the specimen</b><br>
2507   * Type: <b>reference</b><br>
2508   * Path: <b>Specimen.parent</b><br>
2509   * </p>
2510   */
2511  @SearchParamDefinition(name="parent", path="Specimen.parent", description="The parent of the specimen", type="reference", target={Specimen.class } )
2512  public static final String SP_PARENT = "parent";
2513 /**
2514   * <b>Fluent Client</b> search parameter constant for <b>parent</b>
2515   * <p>
2516   * Description: <b>The parent of the specimen</b><br>
2517   * Type: <b>reference</b><br>
2518   * Path: <b>Specimen.parent</b><br>
2519   * </p>
2520   */
2521  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PARENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PARENT);
2522
2523/**
2524   * Constant for fluent queries to be used to add include statements. Specifies
2525   * the path value of "<b>Specimen:parent</b>".
2526   */
2527  public static final ca.uhn.fhir.model.api.Include INCLUDE_PARENT = new ca.uhn.fhir.model.api.Include("Specimen:parent").toLocked();
2528
2529 /**
2530   * Search parameter: <b>container-id</b>
2531   * <p>
2532   * Description: <b>The unique identifier associated with the specimen container</b><br>
2533   * Type: <b>token</b><br>
2534   * Path: <b>Specimen.container.identifier</b><br>
2535   * </p>
2536   */
2537  @SearchParamDefinition(name="container-id", path="Specimen.container.identifier", description="The unique identifier associated with the specimen container", type="token" )
2538  public static final String SP_CONTAINER_ID = "container-id";
2539 /**
2540   * <b>Fluent Client</b> search parameter constant for <b>container-id</b>
2541   * <p>
2542   * Description: <b>The unique identifier associated with the specimen container</b><br>
2543   * Type: <b>token</b><br>
2544   * Path: <b>Specimen.container.identifier</b><br>
2545   * </p>
2546   */
2547  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTAINER_ID = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTAINER_ID);
2548
2549 /**
2550   * Search parameter: <b>bodysite</b>
2551   * <p>
2552   * Description: <b>The code for the body site from where the specimen originated</b><br>
2553   * Type: <b>token</b><br>
2554   * Path: <b>Specimen.collection.bodySite</b><br>
2555   * </p>
2556   */
2557  @SearchParamDefinition(name="bodysite", path="Specimen.collection.bodySite", description="The code for the body site from where the specimen originated", type="token" )
2558  public static final String SP_BODYSITE = "bodysite";
2559 /**
2560   * <b>Fluent Client</b> search parameter constant for <b>bodysite</b>
2561   * <p>
2562   * Description: <b>The code for the body site from where the specimen originated</b><br>
2563   * Type: <b>token</b><br>
2564   * Path: <b>Specimen.collection.bodySite</b><br>
2565   * </p>
2566   */
2567  public static final ca.uhn.fhir.rest.gclient.TokenClientParam BODYSITE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_BODYSITE);
2568
2569 /**
2570   * Search parameter: <b>subject</b>
2571   * <p>
2572   * Description: <b>The subject of the specimen</b><br>
2573   * Type: <b>reference</b><br>
2574   * Path: <b>Specimen.subject</b><br>
2575   * </p>
2576   */
2577  @SearchParamDefinition(name="subject", path="Specimen.subject", description="The subject of the specimen", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") }, target={Device.class, Group.class, Patient.class, Substance.class } )
2578  public static final String SP_SUBJECT = "subject";
2579 /**
2580   * <b>Fluent Client</b> search parameter constant for <b>subject</b>
2581   * <p>
2582   * Description: <b>The subject of the specimen</b><br>
2583   * Type: <b>reference</b><br>
2584   * Path: <b>Specimen.subject</b><br>
2585   * </p>
2586   */
2587  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUBJECT);
2588
2589/**
2590   * Constant for fluent queries to be used to add include statements. Specifies
2591   * the path value of "<b>Specimen:subject</b>".
2592   */
2593  public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT = new ca.uhn.fhir.model.api.Include("Specimen:subject").toLocked();
2594
2595 /**
2596   * Search parameter: <b>patient</b>
2597   * <p>
2598   * Description: <b>The patient the specimen comes from</b><br>
2599   * Type: <b>reference</b><br>
2600   * Path: <b>Specimen.subject</b><br>
2601   * </p>
2602   */
2603  @SearchParamDefinition(name="patient", path="Specimen.subject", description="The patient the specimen comes from", type="reference", target={Patient.class } )
2604  public static final String SP_PATIENT = "patient";
2605 /**
2606   * <b>Fluent Client</b> search parameter constant for <b>patient</b>
2607   * <p>
2608   * Description: <b>The patient the specimen comes from</b><br>
2609   * Type: <b>reference</b><br>
2610   * Path: <b>Specimen.subject</b><br>
2611   * </p>
2612   */
2613  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT);
2614
2615/**
2616   * Constant for fluent queries to be used to add include statements. Specifies
2617   * the path value of "<b>Specimen:patient</b>".
2618   */
2619  public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("Specimen:patient").toLocked();
2620
2621 /**
2622   * Search parameter: <b>collected</b>
2623   * <p>
2624   * Description: <b>The date the specimen was collected</b><br>
2625   * Type: <b>date</b><br>
2626   * Path: <b>Specimen.collection.collected[x]</b><br>
2627   * </p>
2628   */
2629  @SearchParamDefinition(name="collected", path="Specimen.collection.collected", description="The date the specimen was collected", type="date" )
2630  public static final String SP_COLLECTED = "collected";
2631 /**
2632   * <b>Fluent Client</b> search parameter constant for <b>collected</b>
2633   * <p>
2634   * Description: <b>The date the specimen was collected</b><br>
2635   * Type: <b>date</b><br>
2636   * Path: <b>Specimen.collection.collected[x]</b><br>
2637   * </p>
2638   */
2639  public static final ca.uhn.fhir.rest.gclient.DateClientParam COLLECTED = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_COLLECTED);
2640
2641 /**
2642   * Search parameter: <b>accession</b>
2643   * <p>
2644   * Description: <b>The accession number associated with the specimen</b><br>
2645   * Type: <b>token</b><br>
2646   * Path: <b>Specimen.accessionIdentifier</b><br>
2647   * </p>
2648   */
2649  @SearchParamDefinition(name="accession", path="Specimen.accessionIdentifier", description="The accession number associated with the specimen", type="token" )
2650  public static final String SP_ACCESSION = "accession";
2651 /**
2652   * <b>Fluent Client</b> search parameter constant for <b>accession</b>
2653   * <p>
2654   * Description: <b>The accession number associated with the specimen</b><br>
2655   * Type: <b>token</b><br>
2656   * Path: <b>Specimen.accessionIdentifier</b><br>
2657   * </p>
2658   */
2659  public static final ca.uhn.fhir.rest.gclient.TokenClientParam ACCESSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_ACCESSION);
2660
2661 /**
2662   * Search parameter: <b>type</b>
2663   * <p>
2664   * Description: <b>The specimen type</b><br>
2665   * Type: <b>token</b><br>
2666   * Path: <b>Specimen.type</b><br>
2667   * </p>
2668   */
2669  @SearchParamDefinition(name="type", path="Specimen.type", description="The specimen type", type="token" )
2670  public static final String SP_TYPE = "type";
2671 /**
2672   * <b>Fluent Client</b> search parameter constant for <b>type</b>
2673   * <p>
2674   * Description: <b>The specimen type</b><br>
2675   * Type: <b>token</b><br>
2676   * Path: <b>Specimen.type</b><br>
2677   * </p>
2678   */
2679  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE);
2680
2681 /**
2682   * Search parameter: <b>collector</b>
2683   * <p>
2684   * Description: <b>Who collected the specimen</b><br>
2685   * Type: <b>reference</b><br>
2686   * Path: <b>Specimen.collection.collector</b><br>
2687   * </p>
2688   */
2689  @SearchParamDefinition(name="collector", path="Specimen.collection.collector", description="Who collected the specimen", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") }, target={Practitioner.class } )
2690  public static final String SP_COLLECTOR = "collector";
2691 /**
2692   * <b>Fluent Client</b> search parameter constant for <b>collector</b>
2693   * <p>
2694   * Description: <b>Who collected the specimen</b><br>
2695   * Type: <b>reference</b><br>
2696   * Path: <b>Specimen.collection.collector</b><br>
2697   * </p>
2698   */
2699  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam COLLECTOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_COLLECTOR);
2700
2701/**
2702   * Constant for fluent queries to be used to add include statements. Specifies
2703   * the path value of "<b>Specimen:collector</b>".
2704   */
2705  public static final ca.uhn.fhir.model.api.Include INCLUDE_COLLECTOR = new ca.uhn.fhir.model.api.Include("Specimen:collector").toLocked();
2706
2707 /**
2708   * Search parameter: <b>status</b>
2709   * <p>
2710   * Description: <b>available | unavailable | unsatisfactory | entered-in-error</b><br>
2711   * Type: <b>token</b><br>
2712   * Path: <b>Specimen.status</b><br>
2713   * </p>
2714   */
2715  @SearchParamDefinition(name="status", path="Specimen.status", description="available | unavailable | unsatisfactory | entered-in-error", type="token" )
2716  public static final String SP_STATUS = "status";
2717 /**
2718   * <b>Fluent Client</b> search parameter constant for <b>status</b>
2719   * <p>
2720   * Description: <b>available | unavailable | unsatisfactory | entered-in-error</b><br>
2721   * Type: <b>token</b><br>
2722   * Path: <b>Specimen.status</b><br>
2723   * </p>
2724   */
2725  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
2726
2727
2728}