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.dstu3.model.Enumerations.PublicationStatus;
040import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatusEnumFactory;
041import org.hl7.fhir.exceptions.FHIRException;
042import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
043import org.hl7.fhir.utilities.Utilities;
044
045import ca.uhn.fhir.model.api.annotation.Block;
046import ca.uhn.fhir.model.api.annotation.Child;
047import ca.uhn.fhir.model.api.annotation.ChildOrder;
048import ca.uhn.fhir.model.api.annotation.Description;
049import ca.uhn.fhir.model.api.annotation.ResourceDef;
050import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
051/**
052 * The formal description of a single piece of information that can be gathered and reported.
053 */
054@ResourceDef(name="DataElement", profile="http://hl7.org/fhir/Profile/DataElement")
055@ChildOrder(names={"url", "identifier", "version", "status", "experimental", "date", "publisher", "name", "title", "contact", "useContext", "jurisdiction", "copyright", "stringency", "mapping", "element"})
056public class DataElement extends MetadataResource {
057
058    public enum DataElementStringency {
059        /**
060         * The data element is sufficiently well-constrained that multiple pieces of data captured according to the constraints of the data element will be comparable (though in some cases, a degree of automated conversion/normalization may be required).
061         */
062        COMPARABLE, 
063        /**
064         * The data element is fully specified down to a single value set, single unit of measure, single data type, etc.  Multiple pieces of data associated with this data element are fully comparable.
065         */
066        FULLYSPECIFIED, 
067        /**
068         * The data element allows multiple units of measure having equivalent meaning; e.g. "cc" (cubic centimeter) and "mL" (milliliter).
069         */
070        EQUIVALENT, 
071        /**
072         * The data element allows multiple units of measure that are convertable between each other (e.g. inches and centimeters) and/or allows data to be captured in multiple value sets for which a known mapping exists allowing conversion of meaning.
073         */
074        CONVERTABLE, 
075        /**
076         * A convertable data element where unit conversions are different only by a power of 10; e.g. g, mg, kg.
077         */
078        SCALEABLE, 
079        /**
080         * The data element is unconstrained in units, choice of data types and/or choice of vocabulary such that automated comparison of data captured using the data element is not possible.
081         */
082        FLEXIBLE, 
083        /**
084         * added to help the parsers with the generic types
085         */
086        NULL;
087        public static DataElementStringency fromCode(String codeString) throws FHIRException {
088            if (codeString == null || "".equals(codeString))
089                return null;
090        if ("comparable".equals(codeString))
091          return COMPARABLE;
092        if ("fully-specified".equals(codeString))
093          return FULLYSPECIFIED;
094        if ("equivalent".equals(codeString))
095          return EQUIVALENT;
096        if ("convertable".equals(codeString))
097          return CONVERTABLE;
098        if ("scaleable".equals(codeString))
099          return SCALEABLE;
100        if ("flexible".equals(codeString))
101          return FLEXIBLE;
102        if (Configuration.isAcceptInvalidEnums())
103          return null;
104        else
105          throw new FHIRException("Unknown DataElementStringency code '"+codeString+"'");
106        }
107        public String toCode() {
108          switch (this) {
109            case COMPARABLE: return "comparable";
110            case FULLYSPECIFIED: return "fully-specified";
111            case EQUIVALENT: return "equivalent";
112            case CONVERTABLE: return "convertable";
113            case SCALEABLE: return "scaleable";
114            case FLEXIBLE: return "flexible";
115            case NULL: return null;
116            default: return "?";
117          }
118        }
119        public String getSystem() {
120          switch (this) {
121            case COMPARABLE: return "http://hl7.org/fhir/dataelement-stringency";
122            case FULLYSPECIFIED: return "http://hl7.org/fhir/dataelement-stringency";
123            case EQUIVALENT: return "http://hl7.org/fhir/dataelement-stringency";
124            case CONVERTABLE: return "http://hl7.org/fhir/dataelement-stringency";
125            case SCALEABLE: return "http://hl7.org/fhir/dataelement-stringency";
126            case FLEXIBLE: return "http://hl7.org/fhir/dataelement-stringency";
127            case NULL: return null;
128            default: return "?";
129          }
130        }
131        public String getDefinition() {
132          switch (this) {
133            case COMPARABLE: return "The data element is sufficiently well-constrained that multiple pieces of data captured according to the constraints of the data element will be comparable (though in some cases, a degree of automated conversion/normalization may be required).";
134            case FULLYSPECIFIED: return "The data element is fully specified down to a single value set, single unit of measure, single data type, etc.  Multiple pieces of data associated with this data element are fully comparable.";
135            case EQUIVALENT: return "The data element allows multiple units of measure having equivalent meaning; e.g. \"cc\" (cubic centimeter) and \"mL\" (milliliter).";
136            case CONVERTABLE: return "The data element allows multiple units of measure that are convertable between each other (e.g. inches and centimeters) and/or allows data to be captured in multiple value sets for which a known mapping exists allowing conversion of meaning.";
137            case SCALEABLE: return "A convertable data element where unit conversions are different only by a power of 10; e.g. g, mg, kg.";
138            case FLEXIBLE: return "The data element is unconstrained in units, choice of data types and/or choice of vocabulary such that automated comparison of data captured using the data element is not possible.";
139            case NULL: return null;
140            default: return "?";
141          }
142        }
143        public String getDisplay() {
144          switch (this) {
145            case COMPARABLE: return "Comparable";
146            case FULLYSPECIFIED: return "Fully Specified";
147            case EQUIVALENT: return "Equivalent";
148            case CONVERTABLE: return "Convertable";
149            case SCALEABLE: return "Scaleable";
150            case FLEXIBLE: return "Flexible";
151            case NULL: return null;
152            default: return "?";
153          }
154        }
155    }
156
157  public static class DataElementStringencyEnumFactory implements EnumFactory<DataElementStringency> {
158    public DataElementStringency fromCode(String codeString) throws IllegalArgumentException {
159      if (codeString == null || "".equals(codeString))
160            if (codeString == null || "".equals(codeString))
161                return null;
162        if ("comparable".equals(codeString))
163          return DataElementStringency.COMPARABLE;
164        if ("fully-specified".equals(codeString))
165          return DataElementStringency.FULLYSPECIFIED;
166        if ("equivalent".equals(codeString))
167          return DataElementStringency.EQUIVALENT;
168        if ("convertable".equals(codeString))
169          return DataElementStringency.CONVERTABLE;
170        if ("scaleable".equals(codeString))
171          return DataElementStringency.SCALEABLE;
172        if ("flexible".equals(codeString))
173          return DataElementStringency.FLEXIBLE;
174        throw new IllegalArgumentException("Unknown DataElementStringency code '"+codeString+"'");
175        }
176        public Enumeration<DataElementStringency> fromType(Base code) throws FHIRException {
177          if (code == null)
178            return null;
179          if (code.isEmpty())
180            return new Enumeration<DataElementStringency>(this);
181          String codeString = ((PrimitiveType) code).asStringValue();
182          if (codeString == null || "".equals(codeString))
183            return null;
184        if ("comparable".equals(codeString))
185          return new Enumeration<DataElementStringency>(this, DataElementStringency.COMPARABLE);
186        if ("fully-specified".equals(codeString))
187          return new Enumeration<DataElementStringency>(this, DataElementStringency.FULLYSPECIFIED);
188        if ("equivalent".equals(codeString))
189          return new Enumeration<DataElementStringency>(this, DataElementStringency.EQUIVALENT);
190        if ("convertable".equals(codeString))
191          return new Enumeration<DataElementStringency>(this, DataElementStringency.CONVERTABLE);
192        if ("scaleable".equals(codeString))
193          return new Enumeration<DataElementStringency>(this, DataElementStringency.SCALEABLE);
194        if ("flexible".equals(codeString))
195          return new Enumeration<DataElementStringency>(this, DataElementStringency.FLEXIBLE);
196        throw new FHIRException("Unknown DataElementStringency code '"+codeString+"'");
197        }
198    public String toCode(DataElementStringency code) {
199      if (code == DataElementStringency.COMPARABLE)
200        return "comparable";
201      if (code == DataElementStringency.FULLYSPECIFIED)
202        return "fully-specified";
203      if (code == DataElementStringency.EQUIVALENT)
204        return "equivalent";
205      if (code == DataElementStringency.CONVERTABLE)
206        return "convertable";
207      if (code == DataElementStringency.SCALEABLE)
208        return "scaleable";
209      if (code == DataElementStringency.FLEXIBLE)
210        return "flexible";
211      return "?";
212      }
213    public String toSystem(DataElementStringency code) {
214      return code.getSystem();
215      }
216    }
217
218    @Block()
219    public static class DataElementMappingComponent extends BackboneElement implements IBaseBackboneElement {
220        /**
221         * An internal id that is used to identify this mapping set when specific mappings are made on a per-element basis.
222         */
223        @Child(name = "identity", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=false)
224        @Description(shortDefinition="Internal id when this mapping is used", formalDefinition="An internal id that is used to identify this mapping set when specific mappings are made on a per-element basis." )
225        protected IdType identity;
226
227        /**
228         * An absolute URI that identifies the specification that this mapping is expressed to.
229         */
230        @Child(name = "uri", type = {UriType.class}, order=2, min=0, max=1, modifier=false, summary=false)
231        @Description(shortDefinition="Identifies what this mapping refers to", formalDefinition="An absolute URI that identifies the specification that this mapping is expressed to." )
232        protected UriType uri;
233
234        /**
235         * A name for the specification that is being mapped to.
236         */
237        @Child(name = "name", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false)
238        @Description(shortDefinition="Names what this mapping refers to", formalDefinition="A name for the specification that is being mapped to." )
239        protected StringType name;
240
241        /**
242         * Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
243         */
244        @Child(name = "comment", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
245        @Description(shortDefinition="Versions, issues, scope limitations, etc.", formalDefinition="Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage." )
246        protected StringType comment;
247
248        private static final long serialVersionUID = 9610265L;
249
250    /**
251     * Constructor
252     */
253      public DataElementMappingComponent() {
254        super();
255      }
256
257    /**
258     * Constructor
259     */
260      public DataElementMappingComponent(IdType identity) {
261        super();
262        this.identity = identity;
263      }
264
265        /**
266         * @return {@link #identity} (An internal id that is used to identify this mapping set when specific mappings are made on a per-element basis.). This is the underlying object with id, value and extensions. The accessor "getIdentity" gives direct access to the value
267         */
268        public IdType getIdentityElement() { 
269          if (this.identity == null)
270            if (Configuration.errorOnAutoCreate())
271              throw new Error("Attempt to auto-create DataElementMappingComponent.identity");
272            else if (Configuration.doAutoCreate())
273              this.identity = new IdType(); // bb
274          return this.identity;
275        }
276
277        public boolean hasIdentityElement() { 
278          return this.identity != null && !this.identity.isEmpty();
279        }
280
281        public boolean hasIdentity() { 
282          return this.identity != null && !this.identity.isEmpty();
283        }
284
285        /**
286         * @param value {@link #identity} (An internal id that is used to identify this mapping set when specific mappings are made on a per-element basis.). This is the underlying object with id, value and extensions. The accessor "getIdentity" gives direct access to the value
287         */
288        public DataElementMappingComponent setIdentityElement(IdType value) { 
289          this.identity = value;
290          return this;
291        }
292
293        /**
294         * @return An internal id that is used to identify this mapping set when specific mappings are made on a per-element basis.
295         */
296        public String getIdentity() { 
297          return this.identity == null ? null : this.identity.getValue();
298        }
299
300        /**
301         * @param value An internal id that is used to identify this mapping set when specific mappings are made on a per-element basis.
302         */
303        public DataElementMappingComponent setIdentity(String value) { 
304            if (this.identity == null)
305              this.identity = new IdType();
306            this.identity.setValue(value);
307          return this;
308        }
309
310        /**
311         * @return {@link #uri} (An absolute URI that identifies the specification that this mapping is expressed to.). This is the underlying object with id, value and extensions. The accessor "getUri" gives direct access to the value
312         */
313        public UriType getUriElement() { 
314          if (this.uri == null)
315            if (Configuration.errorOnAutoCreate())
316              throw new Error("Attempt to auto-create DataElementMappingComponent.uri");
317            else if (Configuration.doAutoCreate())
318              this.uri = new UriType(); // bb
319          return this.uri;
320        }
321
322        public boolean hasUriElement() { 
323          return this.uri != null && !this.uri.isEmpty();
324        }
325
326        public boolean hasUri() { 
327          return this.uri != null && !this.uri.isEmpty();
328        }
329
330        /**
331         * @param value {@link #uri} (An absolute URI that identifies the specification that this mapping is expressed to.). This is the underlying object with id, value and extensions. The accessor "getUri" gives direct access to the value
332         */
333        public DataElementMappingComponent setUriElement(UriType value) { 
334          this.uri = value;
335          return this;
336        }
337
338        /**
339         * @return An absolute URI that identifies the specification that this mapping is expressed to.
340         */
341        public String getUri() { 
342          return this.uri == null ? null : this.uri.getValue();
343        }
344
345        /**
346         * @param value An absolute URI that identifies the specification that this mapping is expressed to.
347         */
348        public DataElementMappingComponent setUri(String value) { 
349          if (Utilities.noString(value))
350            this.uri = null;
351          else {
352            if (this.uri == null)
353              this.uri = new UriType();
354            this.uri.setValue(value);
355          }
356          return this;
357        }
358
359        /**
360         * @return {@link #name} (A name for the specification that is being mapped to.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
361         */
362        public StringType getNameElement() { 
363          if (this.name == null)
364            if (Configuration.errorOnAutoCreate())
365              throw new Error("Attempt to auto-create DataElementMappingComponent.name");
366            else if (Configuration.doAutoCreate())
367              this.name = new StringType(); // bb
368          return this.name;
369        }
370
371        public boolean hasNameElement() { 
372          return this.name != null && !this.name.isEmpty();
373        }
374
375        public boolean hasName() { 
376          return this.name != null && !this.name.isEmpty();
377        }
378
379        /**
380         * @param value {@link #name} (A name for the specification that is being mapped to.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
381         */
382        public DataElementMappingComponent setNameElement(StringType value) { 
383          this.name = value;
384          return this;
385        }
386
387        /**
388         * @return A name for the specification that is being mapped to.
389         */
390        public String getName() { 
391          return this.name == null ? null : this.name.getValue();
392        }
393
394        /**
395         * @param value A name for the specification that is being mapped to.
396         */
397        public DataElementMappingComponent setName(String value) { 
398          if (Utilities.noString(value))
399            this.name = null;
400          else {
401            if (this.name == null)
402              this.name = new StringType();
403            this.name.setValue(value);
404          }
405          return this;
406        }
407
408        /**
409         * @return {@link #comment} (Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
410         */
411        public StringType getCommentElement() { 
412          if (this.comment == null)
413            if (Configuration.errorOnAutoCreate())
414              throw new Error("Attempt to auto-create DataElementMappingComponent.comment");
415            else if (Configuration.doAutoCreate())
416              this.comment = new StringType(); // bb
417          return this.comment;
418        }
419
420        public boolean hasCommentElement() { 
421          return this.comment != null && !this.comment.isEmpty();
422        }
423
424        public boolean hasComment() { 
425          return this.comment != null && !this.comment.isEmpty();
426        }
427
428        /**
429         * @param value {@link #comment} (Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
430         */
431        public DataElementMappingComponent setCommentElement(StringType value) { 
432          this.comment = value;
433          return this;
434        }
435
436        /**
437         * @return Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
438         */
439        public String getComment() { 
440          return this.comment == null ? null : this.comment.getValue();
441        }
442
443        /**
444         * @param value Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
445         */
446        public DataElementMappingComponent setComment(String value) { 
447          if (Utilities.noString(value))
448            this.comment = null;
449          else {
450            if (this.comment == null)
451              this.comment = new StringType();
452            this.comment.setValue(value);
453          }
454          return this;
455        }
456
457        protected void listChildren(List<Property> children) {
458          super.listChildren(children);
459          children.add(new Property("identity", "id", "An internal id that is used to identify this mapping set when specific mappings are made on a per-element basis.", 0, 1, identity));
460          children.add(new Property("uri", "uri", "An absolute URI that identifies the specification that this mapping is expressed to.", 0, 1, uri));
461          children.add(new Property("name", "string", "A name for the specification that is being mapped to.", 0, 1, name));
462          children.add(new Property("comment", "string", "Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.", 0, 1, comment));
463        }
464
465        @Override
466        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
467          switch (_hash) {
468          case -135761730: /*identity*/  return new Property("identity", "id", "An internal id that is used to identify this mapping set when specific mappings are made on a per-element basis.", 0, 1, identity);
469          case 116076: /*uri*/  return new Property("uri", "uri", "An absolute URI that identifies the specification that this mapping is expressed to.", 0, 1, uri);
470          case 3373707: /*name*/  return new Property("name", "string", "A name for the specification that is being mapped to.", 0, 1, name);
471          case 950398559: /*comment*/  return new Property("comment", "string", "Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.", 0, 1, comment);
472          default: return super.getNamedProperty(_hash, _name, _checkValid);
473          }
474
475        }
476
477      @Override
478      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
479        switch (hash) {
480        case -135761730: /*identity*/ return this.identity == null ? new Base[0] : new Base[] {this.identity}; // IdType
481        case 116076: /*uri*/ return this.uri == null ? new Base[0] : new Base[] {this.uri}; // UriType
482        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
483        case 950398559: /*comment*/ return this.comment == null ? new Base[0] : new Base[] {this.comment}; // StringType
484        default: return super.getProperty(hash, name, checkValid);
485        }
486
487      }
488
489      @Override
490      public Base setProperty(int hash, String name, Base value) throws FHIRException {
491        switch (hash) {
492        case -135761730: // identity
493          this.identity = castToId(value); // IdType
494          return value;
495        case 116076: // uri
496          this.uri = castToUri(value); // UriType
497          return value;
498        case 3373707: // name
499          this.name = castToString(value); // StringType
500          return value;
501        case 950398559: // comment
502          this.comment = castToString(value); // StringType
503          return value;
504        default: return super.setProperty(hash, name, value);
505        }
506
507      }
508
509      @Override
510      public Base setProperty(String name, Base value) throws FHIRException {
511        if (name.equals("identity")) {
512          this.identity = castToId(value); // IdType
513        } else if (name.equals("uri")) {
514          this.uri = castToUri(value); // UriType
515        } else if (name.equals("name")) {
516          this.name = castToString(value); // StringType
517        } else if (name.equals("comment")) {
518          this.comment = castToString(value); // StringType
519        } else
520          return super.setProperty(name, value);
521        return value;
522      }
523
524      @Override
525      public Base makeProperty(int hash, String name) throws FHIRException {
526        switch (hash) {
527        case -135761730:  return getIdentityElement();
528        case 116076:  return getUriElement();
529        case 3373707:  return getNameElement();
530        case 950398559:  return getCommentElement();
531        default: return super.makeProperty(hash, name);
532        }
533
534      }
535
536      @Override
537      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
538        switch (hash) {
539        case -135761730: /*identity*/ return new String[] {"id"};
540        case 116076: /*uri*/ return new String[] {"uri"};
541        case 3373707: /*name*/ return new String[] {"string"};
542        case 950398559: /*comment*/ return new String[] {"string"};
543        default: return super.getTypesForProperty(hash, name);
544        }
545
546      }
547
548      @Override
549      public Base addChild(String name) throws FHIRException {
550        if (name.equals("identity")) {
551          throw new FHIRException("Cannot call addChild on a primitive type DataElement.identity");
552        }
553        else if (name.equals("uri")) {
554          throw new FHIRException("Cannot call addChild on a primitive type DataElement.uri");
555        }
556        else if (name.equals("name")) {
557          throw new FHIRException("Cannot call addChild on a primitive type DataElement.name");
558        }
559        else if (name.equals("comment")) {
560          throw new FHIRException("Cannot call addChild on a primitive type DataElement.comment");
561        }
562        else
563          return super.addChild(name);
564      }
565
566      public DataElementMappingComponent copy() {
567        DataElementMappingComponent dst = new DataElementMappingComponent();
568        copyValues(dst);
569        dst.identity = identity == null ? null : identity.copy();
570        dst.uri = uri == null ? null : uri.copy();
571        dst.name = name == null ? null : name.copy();
572        dst.comment = comment == null ? null : comment.copy();
573        return dst;
574      }
575
576      @Override
577      public boolean equalsDeep(Base other_) {
578        if (!super.equalsDeep(other_))
579          return false;
580        if (!(other_ instanceof DataElementMappingComponent))
581          return false;
582        DataElementMappingComponent o = (DataElementMappingComponent) other_;
583        return compareDeep(identity, o.identity, true) && compareDeep(uri, o.uri, true) && compareDeep(name, o.name, true)
584           && compareDeep(comment, o.comment, true);
585      }
586
587      @Override
588      public boolean equalsShallow(Base other_) {
589        if (!super.equalsShallow(other_))
590          return false;
591        if (!(other_ instanceof DataElementMappingComponent))
592          return false;
593        DataElementMappingComponent o = (DataElementMappingComponent) other_;
594        return compareValues(identity, o.identity, true) && compareValues(uri, o.uri, true) && compareValues(name, o.name, true)
595           && compareValues(comment, o.comment, true);
596      }
597
598      public boolean isEmpty() {
599        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identity, uri, name, comment
600          );
601      }
602
603  public String fhirType() {
604    return "DataElement.mapping";
605
606  }
607
608  }
609
610    /**
611     * A formal identifier that is used to identify this data element when it is represented in other formats, or referenced in a specification, model, design or an instance.
612     */
613    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
614    @Description(shortDefinition="Additional identifier for the data element", formalDefinition="A formal identifier that is used to identify this data element when it is represented in other formats, or referenced in a specification, model, design or an instance." )
615    protected List<Identifier> identifier;
616
617    /**
618     * A copyright statement relating to the data element and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the data element.
619     */
620    @Child(name = "copyright", type = {MarkdownType.class}, order=1, min=0, max=1, modifier=false, summary=false)
621    @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the data element and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the data element." )
622    protected MarkdownType copyright;
623
624    /**
625     * Identifies how precise the data element is in its definition.
626     */
627    @Child(name = "stringency", type = {CodeType.class}, order=2, min=0, max=1, modifier=false, summary=true)
628    @Description(shortDefinition="comparable | fully-specified | equivalent | convertable | scaleable | flexible", formalDefinition="Identifies how precise the data element is in its definition." )
629    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/dataelement-stringency")
630    protected Enumeration<DataElementStringency> stringency;
631
632    /**
633     * Identifies a specification (other than a terminology) that the elements which make up the DataElement have some correspondence with.
634     */
635    @Child(name = "mapping", type = {}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
636    @Description(shortDefinition="External specification mapped to", formalDefinition="Identifies a specification (other than a terminology) that the elements which make up the DataElement have some correspondence with." )
637    protected List<DataElementMappingComponent> mapping;
638
639    /**
640     * Defines the structure, type, allowed values and other constraining characteristics of the data element.
641     */
642    @Child(name = "element", type = {ElementDefinition.class}, order=4, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
643    @Description(shortDefinition="Definition of element", formalDefinition="Defines the structure, type, allowed values and other constraining characteristics of the data element." )
644    protected List<ElementDefinition> element;
645
646    private static final long serialVersionUID = 634422795L;
647
648  /**
649   * Constructor
650   */
651    public DataElement() {
652      super();
653    }
654
655  /**
656   * Constructor
657   */
658    public DataElement(Enumeration<PublicationStatus> status) {
659      super();
660      this.status = status;
661    }
662
663    /**
664     * @return {@link #url} (An absolute URI that is used to identify this data element when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this data element is (or will be) published. The URL SHOULD include the major version of the data element. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
665     */
666    public UriType getUrlElement() { 
667      if (this.url == null)
668        if (Configuration.errorOnAutoCreate())
669          throw new Error("Attempt to auto-create DataElement.url");
670        else if (Configuration.doAutoCreate())
671          this.url = new UriType(); // bb
672      return this.url;
673    }
674
675    public boolean hasUrlElement() { 
676      return this.url != null && !this.url.isEmpty();
677    }
678
679    public boolean hasUrl() { 
680      return this.url != null && !this.url.isEmpty();
681    }
682
683    /**
684     * @param value {@link #url} (An absolute URI that is used to identify this data element when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this data element is (or will be) published. The URL SHOULD include the major version of the data element. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
685     */
686    public DataElement setUrlElement(UriType value) { 
687      this.url = value;
688      return this;
689    }
690
691    /**
692     * @return An absolute URI that is used to identify this data element when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this data element is (or will be) published. The URL SHOULD include the major version of the data element. For more information see [Technical and Business Versions](resource.html#versions).
693     */
694    public String getUrl() { 
695      return this.url == null ? null : this.url.getValue();
696    }
697
698    /**
699     * @param value An absolute URI that is used to identify this data element when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this data element is (or will be) published. The URL SHOULD include the major version of the data element. For more information see [Technical and Business Versions](resource.html#versions).
700     */
701    public DataElement setUrl(String value) { 
702      if (Utilities.noString(value))
703        this.url = null;
704      else {
705        if (this.url == null)
706          this.url = new UriType();
707        this.url.setValue(value);
708      }
709      return this;
710    }
711
712    /**
713     * @return {@link #identifier} (A formal identifier that is used to identify this data element when it is represented in other formats, or referenced in a specification, model, design or an instance.)
714     */
715    public List<Identifier> getIdentifier() { 
716      if (this.identifier == null)
717        this.identifier = new ArrayList<Identifier>();
718      return this.identifier;
719    }
720
721    /**
722     * @return Returns a reference to <code>this</code> for easy method chaining
723     */
724    public DataElement setIdentifier(List<Identifier> theIdentifier) { 
725      this.identifier = theIdentifier;
726      return this;
727    }
728
729    public boolean hasIdentifier() { 
730      if (this.identifier == null)
731        return false;
732      for (Identifier item : this.identifier)
733        if (!item.isEmpty())
734          return true;
735      return false;
736    }
737
738    public Identifier addIdentifier() { //3
739      Identifier t = new Identifier();
740      if (this.identifier == null)
741        this.identifier = new ArrayList<Identifier>();
742      this.identifier.add(t);
743      return t;
744    }
745
746    public DataElement addIdentifier(Identifier t) { //3
747      if (t == null)
748        return this;
749      if (this.identifier == null)
750        this.identifier = new ArrayList<Identifier>();
751      this.identifier.add(t);
752      return this;
753    }
754
755    /**
756     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist
757     */
758    public Identifier getIdentifierFirstRep() { 
759      if (getIdentifier().isEmpty()) {
760        addIdentifier();
761      }
762      return getIdentifier().get(0);
763    }
764
765    /**
766     * @return {@link #version} (The identifier that is used to identify this version of the data element when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the data element author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
767     */
768    public StringType getVersionElement() { 
769      if (this.version == null)
770        if (Configuration.errorOnAutoCreate())
771          throw new Error("Attempt to auto-create DataElement.version");
772        else if (Configuration.doAutoCreate())
773          this.version = new StringType(); // bb
774      return this.version;
775    }
776
777    public boolean hasVersionElement() { 
778      return this.version != null && !this.version.isEmpty();
779    }
780
781    public boolean hasVersion() { 
782      return this.version != null && !this.version.isEmpty();
783    }
784
785    /**
786     * @param value {@link #version} (The identifier that is used to identify this version of the data element when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the data element author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
787     */
788    public DataElement setVersionElement(StringType value) { 
789      this.version = value;
790      return this;
791    }
792
793    /**
794     * @return The identifier that is used to identify this version of the data element when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the data element author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
795     */
796    public String getVersion() { 
797      return this.version == null ? null : this.version.getValue();
798    }
799
800    /**
801     * @param value The identifier that is used to identify this version of the data element when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the data element author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
802     */
803    public DataElement setVersion(String value) { 
804      if (Utilities.noString(value))
805        this.version = null;
806      else {
807        if (this.version == null)
808          this.version = new StringType();
809        this.version.setValue(value);
810      }
811      return this;
812    }
813
814    /**
815     * @return {@link #status} (The status of this data element. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
816     */
817    public Enumeration<PublicationStatus> getStatusElement() { 
818      if (this.status == null)
819        if (Configuration.errorOnAutoCreate())
820          throw new Error("Attempt to auto-create DataElement.status");
821        else if (Configuration.doAutoCreate())
822          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
823      return this.status;
824    }
825
826    public boolean hasStatusElement() { 
827      return this.status != null && !this.status.isEmpty();
828    }
829
830    public boolean hasStatus() { 
831      return this.status != null && !this.status.isEmpty();
832    }
833
834    /**
835     * @param value {@link #status} (The status of this data element. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
836     */
837    public DataElement setStatusElement(Enumeration<PublicationStatus> value) { 
838      this.status = value;
839      return this;
840    }
841
842    /**
843     * @return The status of this data element. Enables tracking the life-cycle of the content.
844     */
845    public PublicationStatus getStatus() { 
846      return this.status == null ? null : this.status.getValue();
847    }
848
849    /**
850     * @param value The status of this data element. Enables tracking the life-cycle of the content.
851     */
852    public DataElement setStatus(PublicationStatus value) { 
853        if (this.status == null)
854          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
855        this.status.setValue(value);
856      return this;
857    }
858
859    /**
860     * @return {@link #experimental} (A boolean value to indicate that this data element is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
861     */
862    public BooleanType getExperimentalElement() { 
863      if (this.experimental == null)
864        if (Configuration.errorOnAutoCreate())
865          throw new Error("Attempt to auto-create DataElement.experimental");
866        else if (Configuration.doAutoCreate())
867          this.experimental = new BooleanType(); // bb
868      return this.experimental;
869    }
870
871    public boolean hasExperimentalElement() { 
872      return this.experimental != null && !this.experimental.isEmpty();
873    }
874
875    public boolean hasExperimental() { 
876      return this.experimental != null && !this.experimental.isEmpty();
877    }
878
879    /**
880     * @param value {@link #experimental} (A boolean value to indicate that this data element is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
881     */
882    public DataElement setExperimentalElement(BooleanType value) { 
883      this.experimental = value;
884      return this;
885    }
886
887    /**
888     * @return A boolean value to indicate that this data element is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.
889     */
890    public boolean getExperimental() { 
891      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
892    }
893
894    /**
895     * @param value A boolean value to indicate that this data element is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.
896     */
897    public DataElement setExperimental(boolean value) { 
898        if (this.experimental == null)
899          this.experimental = new BooleanType();
900        this.experimental.setValue(value);
901      return this;
902    }
903
904    /**
905     * @return {@link #date} (The date  (and optionally time) when the data element was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the data element changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
906     */
907    public DateTimeType getDateElement() { 
908      if (this.date == null)
909        if (Configuration.errorOnAutoCreate())
910          throw new Error("Attempt to auto-create DataElement.date");
911        else if (Configuration.doAutoCreate())
912          this.date = new DateTimeType(); // bb
913      return this.date;
914    }
915
916    public boolean hasDateElement() { 
917      return this.date != null && !this.date.isEmpty();
918    }
919
920    public boolean hasDate() { 
921      return this.date != null && !this.date.isEmpty();
922    }
923
924    /**
925     * @param value {@link #date} (The date  (and optionally time) when the data element was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the data element changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
926     */
927    public DataElement setDateElement(DateTimeType value) { 
928      this.date = value;
929      return this;
930    }
931
932    /**
933     * @return The date  (and optionally time) when the data element was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the data element changes.
934     */
935    public Date getDate() { 
936      return this.date == null ? null : this.date.getValue();
937    }
938
939    /**
940     * @param value The date  (and optionally time) when the data element was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the data element changes.
941     */
942    public DataElement setDate(Date value) { 
943      if (value == null)
944        this.date = null;
945      else {
946        if (this.date == null)
947          this.date = new DateTimeType();
948        this.date.setValue(value);
949      }
950      return this;
951    }
952
953    /**
954     * @return {@link #publisher} (The name of the individual or organization that published the data element.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
955     */
956    public StringType getPublisherElement() { 
957      if (this.publisher == null)
958        if (Configuration.errorOnAutoCreate())
959          throw new Error("Attempt to auto-create DataElement.publisher");
960        else if (Configuration.doAutoCreate())
961          this.publisher = new StringType(); // bb
962      return this.publisher;
963    }
964
965    public boolean hasPublisherElement() { 
966      return this.publisher != null && !this.publisher.isEmpty();
967    }
968
969    public boolean hasPublisher() { 
970      return this.publisher != null && !this.publisher.isEmpty();
971    }
972
973    /**
974     * @param value {@link #publisher} (The name of the individual or organization that published the data element.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
975     */
976    public DataElement setPublisherElement(StringType value) { 
977      this.publisher = value;
978      return this;
979    }
980
981    /**
982     * @return The name of the individual or organization that published the data element.
983     */
984    public String getPublisher() { 
985      return this.publisher == null ? null : this.publisher.getValue();
986    }
987
988    /**
989     * @param value The name of the individual or organization that published the data element.
990     */
991    public DataElement setPublisher(String value) { 
992      if (Utilities.noString(value))
993        this.publisher = null;
994      else {
995        if (this.publisher == null)
996          this.publisher = new StringType();
997        this.publisher.setValue(value);
998      }
999      return this;
1000    }
1001
1002    /**
1003     * @return {@link #name} (A natural language name identifying the data element. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1004     */
1005    public StringType getNameElement() { 
1006      if (this.name == null)
1007        if (Configuration.errorOnAutoCreate())
1008          throw new Error("Attempt to auto-create DataElement.name");
1009        else if (Configuration.doAutoCreate())
1010          this.name = new StringType(); // bb
1011      return this.name;
1012    }
1013
1014    public boolean hasNameElement() { 
1015      return this.name != null && !this.name.isEmpty();
1016    }
1017
1018    public boolean hasName() { 
1019      return this.name != null && !this.name.isEmpty();
1020    }
1021
1022    /**
1023     * @param value {@link #name} (A natural language name identifying the data element. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1024     */
1025    public DataElement setNameElement(StringType value) { 
1026      this.name = value;
1027      return this;
1028    }
1029
1030    /**
1031     * @return A natural language name identifying the data element. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1032     */
1033    public String getName() { 
1034      return this.name == null ? null : this.name.getValue();
1035    }
1036
1037    /**
1038     * @param value A natural language name identifying the data element. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1039     */
1040    public DataElement setName(String value) { 
1041      if (Utilities.noString(value))
1042        this.name = null;
1043      else {
1044        if (this.name == null)
1045          this.name = new StringType();
1046        this.name.setValue(value);
1047      }
1048      return this;
1049    }
1050
1051    /**
1052     * @return {@link #title} (A short, descriptive, user-friendly title for the data element.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
1053     */
1054    public StringType getTitleElement() { 
1055      if (this.title == null)
1056        if (Configuration.errorOnAutoCreate())
1057          throw new Error("Attempt to auto-create DataElement.title");
1058        else if (Configuration.doAutoCreate())
1059          this.title = new StringType(); // bb
1060      return this.title;
1061    }
1062
1063    public boolean hasTitleElement() { 
1064      return this.title != null && !this.title.isEmpty();
1065    }
1066
1067    public boolean hasTitle() { 
1068      return this.title != null && !this.title.isEmpty();
1069    }
1070
1071    /**
1072     * @param value {@link #title} (A short, descriptive, user-friendly title for the data element.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
1073     */
1074    public DataElement setTitleElement(StringType value) { 
1075      this.title = value;
1076      return this;
1077    }
1078
1079    /**
1080     * @return A short, descriptive, user-friendly title for the data element.
1081     */
1082    public String getTitle() { 
1083      return this.title == null ? null : this.title.getValue();
1084    }
1085
1086    /**
1087     * @param value A short, descriptive, user-friendly title for the data element.
1088     */
1089    public DataElement setTitle(String value) { 
1090      if (Utilities.noString(value))
1091        this.title = null;
1092      else {
1093        if (this.title == null)
1094          this.title = new StringType();
1095        this.title.setValue(value);
1096      }
1097      return this;
1098    }
1099
1100    /**
1101     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
1102     */
1103    public List<ContactDetail> getContact() { 
1104      if (this.contact == null)
1105        this.contact = new ArrayList<ContactDetail>();
1106      return this.contact;
1107    }
1108
1109    /**
1110     * @return Returns a reference to <code>this</code> for easy method chaining
1111     */
1112    public DataElement setContact(List<ContactDetail> theContact) { 
1113      this.contact = theContact;
1114      return this;
1115    }
1116
1117    public boolean hasContact() { 
1118      if (this.contact == null)
1119        return false;
1120      for (ContactDetail item : this.contact)
1121        if (!item.isEmpty())
1122          return true;
1123      return false;
1124    }
1125
1126    public ContactDetail addContact() { //3
1127      ContactDetail t = new ContactDetail();
1128      if (this.contact == null)
1129        this.contact = new ArrayList<ContactDetail>();
1130      this.contact.add(t);
1131      return t;
1132    }
1133
1134    public DataElement addContact(ContactDetail t) { //3
1135      if (t == null)
1136        return this;
1137      if (this.contact == null)
1138        this.contact = new ArrayList<ContactDetail>();
1139      this.contact.add(t);
1140      return this;
1141    }
1142
1143    /**
1144     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist
1145     */
1146    public ContactDetail getContactFirstRep() { 
1147      if (getContact().isEmpty()) {
1148        addContact();
1149      }
1150      return getContact().get(0);
1151    }
1152
1153    /**
1154     * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate data element instances.)
1155     */
1156    public List<UsageContext> getUseContext() { 
1157      if (this.useContext == null)
1158        this.useContext = new ArrayList<UsageContext>();
1159      return this.useContext;
1160    }
1161
1162    /**
1163     * @return Returns a reference to <code>this</code> for easy method chaining
1164     */
1165    public DataElement setUseContext(List<UsageContext> theUseContext) { 
1166      this.useContext = theUseContext;
1167      return this;
1168    }
1169
1170    public boolean hasUseContext() { 
1171      if (this.useContext == null)
1172        return false;
1173      for (UsageContext item : this.useContext)
1174        if (!item.isEmpty())
1175          return true;
1176      return false;
1177    }
1178
1179    public UsageContext addUseContext() { //3
1180      UsageContext t = new UsageContext();
1181      if (this.useContext == null)
1182        this.useContext = new ArrayList<UsageContext>();
1183      this.useContext.add(t);
1184      return t;
1185    }
1186
1187    public DataElement addUseContext(UsageContext t) { //3
1188      if (t == null)
1189        return this;
1190      if (this.useContext == null)
1191        this.useContext = new ArrayList<UsageContext>();
1192      this.useContext.add(t);
1193      return this;
1194    }
1195
1196    /**
1197     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist
1198     */
1199    public UsageContext getUseContextFirstRep() { 
1200      if (getUseContext().isEmpty()) {
1201        addUseContext();
1202      }
1203      return getUseContext().get(0);
1204    }
1205
1206    /**
1207     * @return {@link #jurisdiction} (A legal or geographic region in which the data element is intended to be used.)
1208     */
1209    public List<CodeableConcept> getJurisdiction() { 
1210      if (this.jurisdiction == null)
1211        this.jurisdiction = new ArrayList<CodeableConcept>();
1212      return this.jurisdiction;
1213    }
1214
1215    /**
1216     * @return Returns a reference to <code>this</code> for easy method chaining
1217     */
1218    public DataElement setJurisdiction(List<CodeableConcept> theJurisdiction) { 
1219      this.jurisdiction = theJurisdiction;
1220      return this;
1221    }
1222
1223    public boolean hasJurisdiction() { 
1224      if (this.jurisdiction == null)
1225        return false;
1226      for (CodeableConcept item : this.jurisdiction)
1227        if (!item.isEmpty())
1228          return true;
1229      return false;
1230    }
1231
1232    public CodeableConcept addJurisdiction() { //3
1233      CodeableConcept t = new CodeableConcept();
1234      if (this.jurisdiction == null)
1235        this.jurisdiction = new ArrayList<CodeableConcept>();
1236      this.jurisdiction.add(t);
1237      return t;
1238    }
1239
1240    public DataElement addJurisdiction(CodeableConcept t) { //3
1241      if (t == null)
1242        return this;
1243      if (this.jurisdiction == null)
1244        this.jurisdiction = new ArrayList<CodeableConcept>();
1245      this.jurisdiction.add(t);
1246      return this;
1247    }
1248
1249    /**
1250     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist
1251     */
1252    public CodeableConcept getJurisdictionFirstRep() { 
1253      if (getJurisdiction().isEmpty()) {
1254        addJurisdiction();
1255      }
1256      return getJurisdiction().get(0);
1257    }
1258
1259    /**
1260     * @return {@link #copyright} (A copyright statement relating to the data element and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the data element.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
1261     */
1262    public MarkdownType getCopyrightElement() { 
1263      if (this.copyright == null)
1264        if (Configuration.errorOnAutoCreate())
1265          throw new Error("Attempt to auto-create DataElement.copyright");
1266        else if (Configuration.doAutoCreate())
1267          this.copyright = new MarkdownType(); // bb
1268      return this.copyright;
1269    }
1270
1271    public boolean hasCopyrightElement() { 
1272      return this.copyright != null && !this.copyright.isEmpty();
1273    }
1274
1275    public boolean hasCopyright() { 
1276      return this.copyright != null && !this.copyright.isEmpty();
1277    }
1278
1279    /**
1280     * @param value {@link #copyright} (A copyright statement relating to the data element and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the data element.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
1281     */
1282    public DataElement setCopyrightElement(MarkdownType value) { 
1283      this.copyright = value;
1284      return this;
1285    }
1286
1287    /**
1288     * @return A copyright statement relating to the data element and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the data element.
1289     */
1290    public String getCopyright() { 
1291      return this.copyright == null ? null : this.copyright.getValue();
1292    }
1293
1294    /**
1295     * @param value A copyright statement relating to the data element and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the data element.
1296     */
1297    public DataElement setCopyright(String value) { 
1298      if (value == null)
1299        this.copyright = null;
1300      else {
1301        if (this.copyright == null)
1302          this.copyright = new MarkdownType();
1303        this.copyright.setValue(value);
1304      }
1305      return this;
1306    }
1307
1308    /**
1309     * @return {@link #stringency} (Identifies how precise the data element is in its definition.). This is the underlying object with id, value and extensions. The accessor "getStringency" gives direct access to the value
1310     */
1311    public Enumeration<DataElementStringency> getStringencyElement() { 
1312      if (this.stringency == null)
1313        if (Configuration.errorOnAutoCreate())
1314          throw new Error("Attempt to auto-create DataElement.stringency");
1315        else if (Configuration.doAutoCreate())
1316          this.stringency = new Enumeration<DataElementStringency>(new DataElementStringencyEnumFactory()); // bb
1317      return this.stringency;
1318    }
1319
1320    public boolean hasStringencyElement() { 
1321      return this.stringency != null && !this.stringency.isEmpty();
1322    }
1323
1324    public boolean hasStringency() { 
1325      return this.stringency != null && !this.stringency.isEmpty();
1326    }
1327
1328    /**
1329     * @param value {@link #stringency} (Identifies how precise the data element is in its definition.). This is the underlying object with id, value and extensions. The accessor "getStringency" gives direct access to the value
1330     */
1331    public DataElement setStringencyElement(Enumeration<DataElementStringency> value) { 
1332      this.stringency = value;
1333      return this;
1334    }
1335
1336    /**
1337     * @return Identifies how precise the data element is in its definition.
1338     */
1339    public DataElementStringency getStringency() { 
1340      return this.stringency == null ? null : this.stringency.getValue();
1341    }
1342
1343    /**
1344     * @param value Identifies how precise the data element is in its definition.
1345     */
1346    public DataElement setStringency(DataElementStringency value) { 
1347      if (value == null)
1348        this.stringency = null;
1349      else {
1350        if (this.stringency == null)
1351          this.stringency = new Enumeration<DataElementStringency>(new DataElementStringencyEnumFactory());
1352        this.stringency.setValue(value);
1353      }
1354      return this;
1355    }
1356
1357    /**
1358     * @return {@link #mapping} (Identifies a specification (other than a terminology) that the elements which make up the DataElement have some correspondence with.)
1359     */
1360    public List<DataElementMappingComponent> getMapping() { 
1361      if (this.mapping == null)
1362        this.mapping = new ArrayList<DataElementMappingComponent>();
1363      return this.mapping;
1364    }
1365
1366    /**
1367     * @return Returns a reference to <code>this</code> for easy method chaining
1368     */
1369    public DataElement setMapping(List<DataElementMappingComponent> theMapping) { 
1370      this.mapping = theMapping;
1371      return this;
1372    }
1373
1374    public boolean hasMapping() { 
1375      if (this.mapping == null)
1376        return false;
1377      for (DataElementMappingComponent item : this.mapping)
1378        if (!item.isEmpty())
1379          return true;
1380      return false;
1381    }
1382
1383    public DataElementMappingComponent addMapping() { //3
1384      DataElementMappingComponent t = new DataElementMappingComponent();
1385      if (this.mapping == null)
1386        this.mapping = new ArrayList<DataElementMappingComponent>();
1387      this.mapping.add(t);
1388      return t;
1389    }
1390
1391    public DataElement addMapping(DataElementMappingComponent t) { //3
1392      if (t == null)
1393        return this;
1394      if (this.mapping == null)
1395        this.mapping = new ArrayList<DataElementMappingComponent>();
1396      this.mapping.add(t);
1397      return this;
1398    }
1399
1400    /**
1401     * @return The first repetition of repeating field {@link #mapping}, creating it if it does not already exist
1402     */
1403    public DataElementMappingComponent getMappingFirstRep() { 
1404      if (getMapping().isEmpty()) {
1405        addMapping();
1406      }
1407      return getMapping().get(0);
1408    }
1409
1410    /**
1411     * @return {@link #element} (Defines the structure, type, allowed values and other constraining characteristics of the data element.)
1412     */
1413    public List<ElementDefinition> getElement() { 
1414      if (this.element == null)
1415        this.element = new ArrayList<ElementDefinition>();
1416      return this.element;
1417    }
1418
1419    /**
1420     * @return Returns a reference to <code>this</code> for easy method chaining
1421     */
1422    public DataElement setElement(List<ElementDefinition> theElement) { 
1423      this.element = theElement;
1424      return this;
1425    }
1426
1427    public boolean hasElement() { 
1428      if (this.element == null)
1429        return false;
1430      for (ElementDefinition item : this.element)
1431        if (!item.isEmpty())
1432          return true;
1433      return false;
1434    }
1435
1436    public ElementDefinition addElement() { //3
1437      ElementDefinition t = new ElementDefinition();
1438      if (this.element == null)
1439        this.element = new ArrayList<ElementDefinition>();
1440      this.element.add(t);
1441      return t;
1442    }
1443
1444    public DataElement addElement(ElementDefinition t) { //3
1445      if (t == null)
1446        return this;
1447      if (this.element == null)
1448        this.element = new ArrayList<ElementDefinition>();
1449      this.element.add(t);
1450      return this;
1451    }
1452
1453    /**
1454     * @return The first repetition of repeating field {@link #element}, creating it if it does not already exist
1455     */
1456    public ElementDefinition getElementFirstRep() { 
1457      if (getElement().isEmpty()) {
1458        addElement();
1459      }
1460      return getElement().get(0);
1461    }
1462
1463      protected void listChildren(List<Property> children) {
1464        super.listChildren(children);
1465        children.add(new Property("url", "uri", "An absolute URI that is used to identify this data element when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this data element is (or will be) published. The URL SHOULD include the major version of the data element. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url));
1466        children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this data element when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier));
1467        children.add(new Property("version", "string", "The identifier that is used to identify this version of the data element when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the data element author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version));
1468        children.add(new Property("status", "code", "The status of this data element. Enables tracking the life-cycle of the content.", 0, 1, status));
1469        children.add(new Property("experimental", "boolean", "A boolean value to indicate that this data element is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental));
1470        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the data element was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the data element changes.", 0, 1, date));
1471        children.add(new Property("publisher", "string", "The name of the individual or organization that published the data element.", 0, 1, publisher));
1472        children.add(new Property("name", "string", "A natural language name identifying the data element. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
1473        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the data element.", 0, 1, title));
1474        children.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact));
1475        children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate data element instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
1476        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the data element is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
1477        children.add(new Property("copyright", "markdown", "A copyright statement relating to the data element and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the data element.", 0, 1, copyright));
1478        children.add(new Property("stringency", "code", "Identifies how precise the data element is in its definition.", 0, 1, stringency));
1479        children.add(new Property("mapping", "", "Identifies a specification (other than a terminology) that the elements which make up the DataElement have some correspondence with.", 0, java.lang.Integer.MAX_VALUE, mapping));
1480        children.add(new Property("element", "ElementDefinition", "Defines the structure, type, allowed values and other constraining characteristics of the data element.", 0, java.lang.Integer.MAX_VALUE, element));
1481      }
1482
1483      @Override
1484      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1485        switch (_hash) {
1486        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this data element when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this data element is (or will be) published. The URL SHOULD include the major version of the data element. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url);
1487        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "A formal identifier that is used to identify this data element when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier);
1488        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the data element when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the data element author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version);
1489        case -892481550: /*status*/  return new Property("status", "code", "The status of this data element. Enables tracking the life-cycle of the content.", 0, 1, status);
1490        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A boolean value to indicate that this data element is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental);
1491        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the data element was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the data element changes.", 0, 1, date);
1492        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the individual or organization that published the data element.", 0, 1, publisher);
1493        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the data element. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
1494        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the data element.", 0, 1, title);
1495        case 951526432: /*contact*/  return new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact);
1496        case -669707736: /*useContext*/  return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate data element instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
1497        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the data element is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
1498        case 1522889671: /*copyright*/  return new Property("copyright", "markdown", "A copyright statement relating to the data element and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the data element.", 0, 1, copyright);
1499        case -1572568464: /*stringency*/  return new Property("stringency", "code", "Identifies how precise the data element is in its definition.", 0, 1, stringency);
1500        case 837556430: /*mapping*/  return new Property("mapping", "", "Identifies a specification (other than a terminology) that the elements which make up the DataElement have some correspondence with.", 0, java.lang.Integer.MAX_VALUE, mapping);
1501        case -1662836996: /*element*/  return new Property("element", "ElementDefinition", "Defines the structure, type, allowed values and other constraining characteristics of the data element.", 0, java.lang.Integer.MAX_VALUE, element);
1502        default: return super.getNamedProperty(_hash, _name, _checkValid);
1503        }
1504
1505      }
1506
1507      @Override
1508      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1509        switch (hash) {
1510        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
1511        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
1512        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
1513        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
1514        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
1515        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
1516        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
1517        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
1518        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
1519        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
1520        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
1521        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
1522        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
1523        case -1572568464: /*stringency*/ return this.stringency == null ? new Base[0] : new Base[] {this.stringency}; // Enumeration<DataElementStringency>
1524        case 837556430: /*mapping*/ return this.mapping == null ? new Base[0] : this.mapping.toArray(new Base[this.mapping.size()]); // DataElementMappingComponent
1525        case -1662836996: /*element*/ return this.element == null ? new Base[0] : this.element.toArray(new Base[this.element.size()]); // ElementDefinition
1526        default: return super.getProperty(hash, name, checkValid);
1527        }
1528
1529      }
1530
1531      @Override
1532      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1533        switch (hash) {
1534        case 116079: // url
1535          this.url = castToUri(value); // UriType
1536          return value;
1537        case -1618432855: // identifier
1538          this.getIdentifier().add(castToIdentifier(value)); // Identifier
1539          return value;
1540        case 351608024: // version
1541          this.version = castToString(value); // StringType
1542          return value;
1543        case -892481550: // status
1544          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
1545          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
1546          return value;
1547        case -404562712: // experimental
1548          this.experimental = castToBoolean(value); // BooleanType
1549          return value;
1550        case 3076014: // date
1551          this.date = castToDateTime(value); // DateTimeType
1552          return value;
1553        case 1447404028: // publisher
1554          this.publisher = castToString(value); // StringType
1555          return value;
1556        case 3373707: // name
1557          this.name = castToString(value); // StringType
1558          return value;
1559        case 110371416: // title
1560          this.title = castToString(value); // StringType
1561          return value;
1562        case 951526432: // contact
1563          this.getContact().add(castToContactDetail(value)); // ContactDetail
1564          return value;
1565        case -669707736: // useContext
1566          this.getUseContext().add(castToUsageContext(value)); // UsageContext
1567          return value;
1568        case -507075711: // jurisdiction
1569          this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept
1570          return value;
1571        case 1522889671: // copyright
1572          this.copyright = castToMarkdown(value); // MarkdownType
1573          return value;
1574        case -1572568464: // stringency
1575          value = new DataElementStringencyEnumFactory().fromType(castToCode(value));
1576          this.stringency = (Enumeration) value; // Enumeration<DataElementStringency>
1577          return value;
1578        case 837556430: // mapping
1579          this.getMapping().add((DataElementMappingComponent) value); // DataElementMappingComponent
1580          return value;
1581        case -1662836996: // element
1582          this.getElement().add(castToElementDefinition(value)); // ElementDefinition
1583          return value;
1584        default: return super.setProperty(hash, name, value);
1585        }
1586
1587      }
1588
1589      @Override
1590      public Base setProperty(String name, Base value) throws FHIRException {
1591        if (name.equals("url")) {
1592          this.url = castToUri(value); // UriType
1593        } else if (name.equals("identifier")) {
1594          this.getIdentifier().add(castToIdentifier(value));
1595        } else if (name.equals("version")) {
1596          this.version = castToString(value); // StringType
1597        } else if (name.equals("status")) {
1598          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
1599          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
1600        } else if (name.equals("experimental")) {
1601          this.experimental = castToBoolean(value); // BooleanType
1602        } else if (name.equals("date")) {
1603          this.date = castToDateTime(value); // DateTimeType
1604        } else if (name.equals("publisher")) {
1605          this.publisher = castToString(value); // StringType
1606        } else if (name.equals("name")) {
1607          this.name = castToString(value); // StringType
1608        } else if (name.equals("title")) {
1609          this.title = castToString(value); // StringType
1610        } else if (name.equals("contact")) {
1611          this.getContact().add(castToContactDetail(value));
1612        } else if (name.equals("useContext")) {
1613          this.getUseContext().add(castToUsageContext(value));
1614        } else if (name.equals("jurisdiction")) {
1615          this.getJurisdiction().add(castToCodeableConcept(value));
1616        } else if (name.equals("copyright")) {
1617          this.copyright = castToMarkdown(value); // MarkdownType
1618        } else if (name.equals("stringency")) {
1619          value = new DataElementStringencyEnumFactory().fromType(castToCode(value));
1620          this.stringency = (Enumeration) value; // Enumeration<DataElementStringency>
1621        } else if (name.equals("mapping")) {
1622          this.getMapping().add((DataElementMappingComponent) value);
1623        } else if (name.equals("element")) {
1624          this.getElement().add(castToElementDefinition(value));
1625        } else
1626          return super.setProperty(name, value);
1627        return value;
1628      }
1629
1630      @Override
1631      public Base makeProperty(int hash, String name) throws FHIRException {
1632        switch (hash) {
1633        case 116079:  return getUrlElement();
1634        case -1618432855:  return addIdentifier(); 
1635        case 351608024:  return getVersionElement();
1636        case -892481550:  return getStatusElement();
1637        case -404562712:  return getExperimentalElement();
1638        case 3076014:  return getDateElement();
1639        case 1447404028:  return getPublisherElement();
1640        case 3373707:  return getNameElement();
1641        case 110371416:  return getTitleElement();
1642        case 951526432:  return addContact(); 
1643        case -669707736:  return addUseContext(); 
1644        case -507075711:  return addJurisdiction(); 
1645        case 1522889671:  return getCopyrightElement();
1646        case -1572568464:  return getStringencyElement();
1647        case 837556430:  return addMapping(); 
1648        case -1662836996:  return addElement(); 
1649        default: return super.makeProperty(hash, name);
1650        }
1651
1652      }
1653
1654      @Override
1655      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1656        switch (hash) {
1657        case 116079: /*url*/ return new String[] {"uri"};
1658        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
1659        case 351608024: /*version*/ return new String[] {"string"};
1660        case -892481550: /*status*/ return new String[] {"code"};
1661        case -404562712: /*experimental*/ return new String[] {"boolean"};
1662        case 3076014: /*date*/ return new String[] {"dateTime"};
1663        case 1447404028: /*publisher*/ return new String[] {"string"};
1664        case 3373707: /*name*/ return new String[] {"string"};
1665        case 110371416: /*title*/ return new String[] {"string"};
1666        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
1667        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
1668        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
1669        case 1522889671: /*copyright*/ return new String[] {"markdown"};
1670        case -1572568464: /*stringency*/ return new String[] {"code"};
1671        case 837556430: /*mapping*/ return new String[] {};
1672        case -1662836996: /*element*/ return new String[] {"ElementDefinition"};
1673        default: return super.getTypesForProperty(hash, name);
1674        }
1675
1676      }
1677
1678      @Override
1679      public Base addChild(String name) throws FHIRException {
1680        if (name.equals("url")) {
1681          throw new FHIRException("Cannot call addChild on a primitive type DataElement.url");
1682        }
1683        else if (name.equals("identifier")) {
1684          return addIdentifier();
1685        }
1686        else if (name.equals("version")) {
1687          throw new FHIRException("Cannot call addChild on a primitive type DataElement.version");
1688        }
1689        else if (name.equals("status")) {
1690          throw new FHIRException("Cannot call addChild on a primitive type DataElement.status");
1691        }
1692        else if (name.equals("experimental")) {
1693          throw new FHIRException("Cannot call addChild on a primitive type DataElement.experimental");
1694        }
1695        else if (name.equals("date")) {
1696          throw new FHIRException("Cannot call addChild on a primitive type DataElement.date");
1697        }
1698        else if (name.equals("publisher")) {
1699          throw new FHIRException("Cannot call addChild on a primitive type DataElement.publisher");
1700        }
1701        else if (name.equals("name")) {
1702          throw new FHIRException("Cannot call addChild on a primitive type DataElement.name");
1703        }
1704        else if (name.equals("title")) {
1705          throw new FHIRException("Cannot call addChild on a primitive type DataElement.title");
1706        }
1707        else if (name.equals("contact")) {
1708          return addContact();
1709        }
1710        else if (name.equals("useContext")) {
1711          return addUseContext();
1712        }
1713        else if (name.equals("jurisdiction")) {
1714          return addJurisdiction();
1715        }
1716        else if (name.equals("copyright")) {
1717          throw new FHIRException("Cannot call addChild on a primitive type DataElement.copyright");
1718        }
1719        else if (name.equals("stringency")) {
1720          throw new FHIRException("Cannot call addChild on a primitive type DataElement.stringency");
1721        }
1722        else if (name.equals("mapping")) {
1723          return addMapping();
1724        }
1725        else if (name.equals("element")) {
1726          return addElement();
1727        }
1728        else
1729          return super.addChild(name);
1730      }
1731
1732  public String fhirType() {
1733    return "DataElement";
1734
1735  }
1736
1737      public DataElement copy() {
1738        DataElement dst = new DataElement();
1739        copyValues(dst);
1740        dst.url = url == null ? null : url.copy();
1741        if (identifier != null) {
1742          dst.identifier = new ArrayList<Identifier>();
1743          for (Identifier i : identifier)
1744            dst.identifier.add(i.copy());
1745        };
1746        dst.version = version == null ? null : version.copy();
1747        dst.status = status == null ? null : status.copy();
1748        dst.experimental = experimental == null ? null : experimental.copy();
1749        dst.date = date == null ? null : date.copy();
1750        dst.publisher = publisher == null ? null : publisher.copy();
1751        dst.name = name == null ? null : name.copy();
1752        dst.title = title == null ? null : title.copy();
1753        if (contact != null) {
1754          dst.contact = new ArrayList<ContactDetail>();
1755          for (ContactDetail i : contact)
1756            dst.contact.add(i.copy());
1757        };
1758        if (useContext != null) {
1759          dst.useContext = new ArrayList<UsageContext>();
1760          for (UsageContext i : useContext)
1761            dst.useContext.add(i.copy());
1762        };
1763        if (jurisdiction != null) {
1764          dst.jurisdiction = new ArrayList<CodeableConcept>();
1765          for (CodeableConcept i : jurisdiction)
1766            dst.jurisdiction.add(i.copy());
1767        };
1768        dst.copyright = copyright == null ? null : copyright.copy();
1769        dst.stringency = stringency == null ? null : stringency.copy();
1770        if (mapping != null) {
1771          dst.mapping = new ArrayList<DataElementMappingComponent>();
1772          for (DataElementMappingComponent i : mapping)
1773            dst.mapping.add(i.copy());
1774        };
1775        if (element != null) {
1776          dst.element = new ArrayList<ElementDefinition>();
1777          for (ElementDefinition i : element)
1778            dst.element.add(i.copy());
1779        };
1780        return dst;
1781      }
1782
1783      protected DataElement typedCopy() {
1784        return copy();
1785      }
1786
1787      @Override
1788      public boolean equalsDeep(Base other_) {
1789        if (!super.equalsDeep(other_))
1790          return false;
1791        if (!(other_ instanceof DataElement))
1792          return false;
1793        DataElement o = (DataElement) other_;
1794        return compareDeep(identifier, o.identifier, true) && compareDeep(copyright, o.copyright, true)
1795           && compareDeep(stringency, o.stringency, true) && compareDeep(mapping, o.mapping, true) && compareDeep(element, o.element, true)
1796          ;
1797      }
1798
1799      @Override
1800      public boolean equalsShallow(Base other_) {
1801        if (!super.equalsShallow(other_))
1802          return false;
1803        if (!(other_ instanceof DataElement))
1804          return false;
1805        DataElement o = (DataElement) other_;
1806        return compareValues(copyright, o.copyright, true) && compareValues(stringency, o.stringency, true)
1807          ;
1808      }
1809
1810      public boolean isEmpty() {
1811        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, copyright, stringency
1812          , mapping, element);
1813      }
1814
1815  @Override
1816  public ResourceType getResourceType() {
1817    return ResourceType.DataElement;
1818   }
1819
1820 /**
1821   * Search parameter: <b>date</b>
1822   * <p>
1823   * Description: <b>The data element publication date</b><br>
1824   * Type: <b>date</b><br>
1825   * Path: <b>DataElement.date</b><br>
1826   * </p>
1827   */
1828  @SearchParamDefinition(name="date", path="DataElement.date", description="The data element publication date", type="date" )
1829  public static final String SP_DATE = "date";
1830 /**
1831   * <b>Fluent Client</b> search parameter constant for <b>date</b>
1832   * <p>
1833   * Description: <b>The data element publication date</b><br>
1834   * Type: <b>date</b><br>
1835   * Path: <b>DataElement.date</b><br>
1836   * </p>
1837   */
1838  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
1839
1840 /**
1841   * Search parameter: <b>identifier</b>
1842   * <p>
1843   * Description: <b>External identifier for the data element</b><br>
1844   * Type: <b>token</b><br>
1845   * Path: <b>DataElement.identifier</b><br>
1846   * </p>
1847   */
1848  @SearchParamDefinition(name="identifier", path="DataElement.identifier", description="External identifier for the data element", type="token" )
1849  public static final String SP_IDENTIFIER = "identifier";
1850 /**
1851   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
1852   * <p>
1853   * Description: <b>External identifier for the data element</b><br>
1854   * Type: <b>token</b><br>
1855   * Path: <b>DataElement.identifier</b><br>
1856   * </p>
1857   */
1858  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
1859
1860 /**
1861   * Search parameter: <b>code</b>
1862   * <p>
1863   * Description: <b>A code for the data element (server may choose to do subsumption)</b><br>
1864   * Type: <b>token</b><br>
1865   * Path: <b>DataElement.element.code</b><br>
1866   * </p>
1867   */
1868  @SearchParamDefinition(name="code", path="DataElement.element.code", description="A code for the data element (server may choose to do subsumption)", type="token" )
1869  public static final String SP_CODE = "code";
1870 /**
1871   * <b>Fluent Client</b> search parameter constant for <b>code</b>
1872   * <p>
1873   * Description: <b>A code for the data element (server may choose to do subsumption)</b><br>
1874   * Type: <b>token</b><br>
1875   * Path: <b>DataElement.element.code</b><br>
1876   * </p>
1877   */
1878  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CODE);
1879
1880 /**
1881   * Search parameter: <b>stringency</b>
1882   * <p>
1883   * Description: <b>The stringency of the data element definition</b><br>
1884   * Type: <b>token</b><br>
1885   * Path: <b>DataElement.stringency</b><br>
1886   * </p>
1887   */
1888  @SearchParamDefinition(name="stringency", path="DataElement.stringency", description="The stringency of the data element definition", type="token" )
1889  public static final String SP_STRINGENCY = "stringency";
1890 /**
1891   * <b>Fluent Client</b> search parameter constant for <b>stringency</b>
1892   * <p>
1893   * Description: <b>The stringency of the data element definition</b><br>
1894   * Type: <b>token</b><br>
1895   * Path: <b>DataElement.stringency</b><br>
1896   * </p>
1897   */
1898  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STRINGENCY = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STRINGENCY);
1899
1900 /**
1901   * Search parameter: <b>jurisdiction</b>
1902   * <p>
1903   * Description: <b>Intended jurisdiction for the data element</b><br>
1904   * Type: <b>token</b><br>
1905   * Path: <b>DataElement.jurisdiction</b><br>
1906   * </p>
1907   */
1908  @SearchParamDefinition(name="jurisdiction", path="DataElement.jurisdiction", description="Intended jurisdiction for the data element", type="token" )
1909  public static final String SP_JURISDICTION = "jurisdiction";
1910 /**
1911   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
1912   * <p>
1913   * Description: <b>Intended jurisdiction for the data element</b><br>
1914   * Type: <b>token</b><br>
1915   * Path: <b>DataElement.jurisdiction</b><br>
1916   * </p>
1917   */
1918  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
1919
1920 /**
1921   * Search parameter: <b>name</b>
1922   * <p>
1923   * Description: <b>Computationally friendly name of the data element</b><br>
1924   * Type: <b>string</b><br>
1925   * Path: <b>DataElement.name</b><br>
1926   * </p>
1927   */
1928  @SearchParamDefinition(name="name", path="DataElement.name", description="Computationally friendly name of the data element", type="string" )
1929  public static final String SP_NAME = "name";
1930 /**
1931   * <b>Fluent Client</b> search parameter constant for <b>name</b>
1932   * <p>
1933   * Description: <b>Computationally friendly name of the data element</b><br>
1934   * Type: <b>string</b><br>
1935   * Path: <b>DataElement.name</b><br>
1936   * </p>
1937   */
1938  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
1939
1940 /**
1941   * Search parameter: <b>publisher</b>
1942   * <p>
1943   * Description: <b>Name of the publisher of the data element</b><br>
1944   * Type: <b>string</b><br>
1945   * Path: <b>DataElement.publisher</b><br>
1946   * </p>
1947   */
1948  @SearchParamDefinition(name="publisher", path="DataElement.publisher", description="Name of the publisher of the data element", type="string" )
1949  public static final String SP_PUBLISHER = "publisher";
1950 /**
1951   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
1952   * <p>
1953   * Description: <b>Name of the publisher of the data element</b><br>
1954   * Type: <b>string</b><br>
1955   * Path: <b>DataElement.publisher</b><br>
1956   * </p>
1957   */
1958  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
1959
1960 /**
1961   * Search parameter: <b>description</b>
1962   * <p>
1963   * Description: <b>Text search in the description of the data element.  This corresponds to the definition of the first DataElement.element.</b><br>
1964   * Type: <b>string</b><br>
1965   * Path: <b>DataElement.element.definition</b><br>
1966   * </p>
1967   */
1968  @SearchParamDefinition(name="description", path="DataElement.element.definition", description="Text search in the description of the data element.  This corresponds to the definition of the first DataElement.element.", type="string" )
1969  public static final String SP_DESCRIPTION = "description";
1970 /**
1971   * <b>Fluent Client</b> search parameter constant for <b>description</b>
1972   * <p>
1973   * Description: <b>Text search in the description of the data element.  This corresponds to the definition of the first DataElement.element.</b><br>
1974   * Type: <b>string</b><br>
1975   * Path: <b>DataElement.element.definition</b><br>
1976   * </p>
1977   */
1978  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
1979
1980 /**
1981   * Search parameter: <b>title</b>
1982   * <p>
1983   * Description: <b>The human-friendly name of the data element</b><br>
1984   * Type: <b>string</b><br>
1985   * Path: <b>DataElement.title</b><br>
1986   * </p>
1987   */
1988  @SearchParamDefinition(name="title", path="DataElement.title", description="The human-friendly name of the data element", type="string" )
1989  public static final String SP_TITLE = "title";
1990 /**
1991   * <b>Fluent Client</b> search parameter constant for <b>title</b>
1992   * <p>
1993   * Description: <b>The human-friendly name of the data element</b><br>
1994   * Type: <b>string</b><br>
1995   * Path: <b>DataElement.title</b><br>
1996   * </p>
1997   */
1998  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
1999
2000 /**
2001   * Search parameter: <b>version</b>
2002   * <p>
2003   * Description: <b>The business version of the data element</b><br>
2004   * Type: <b>token</b><br>
2005   * Path: <b>DataElement.version</b><br>
2006   * </p>
2007   */
2008  @SearchParamDefinition(name="version", path="DataElement.version", description="The business version of the data element", type="token" )
2009  public static final String SP_VERSION = "version";
2010 /**
2011   * <b>Fluent Client</b> search parameter constant for <b>version</b>
2012   * <p>
2013   * Description: <b>The business version of the data element</b><br>
2014   * Type: <b>token</b><br>
2015   * Path: <b>DataElement.version</b><br>
2016   * </p>
2017   */
2018  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
2019
2020 /**
2021   * Search parameter: <b>url</b>
2022   * <p>
2023   * Description: <b>The uri that identifies the data element</b><br>
2024   * Type: <b>uri</b><br>
2025   * Path: <b>DataElement.url</b><br>
2026   * </p>
2027   */
2028  @SearchParamDefinition(name="url", path="DataElement.url", description="The uri that identifies the data element", type="uri" )
2029  public static final String SP_URL = "url";
2030 /**
2031   * <b>Fluent Client</b> search parameter constant for <b>url</b>
2032   * <p>
2033   * Description: <b>The uri that identifies the data element</b><br>
2034   * Type: <b>uri</b><br>
2035   * Path: <b>DataElement.url</b><br>
2036   * </p>
2037   */
2038  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
2039
2040 /**
2041   * Search parameter: <b>status</b>
2042   * <p>
2043   * Description: <b>The current status of the data element</b><br>
2044   * Type: <b>token</b><br>
2045   * Path: <b>DataElement.status</b><br>
2046   * </p>
2047   */
2048  @SearchParamDefinition(name="status", path="DataElement.status", description="The current status of the data element", type="token" )
2049  public static final String SP_STATUS = "status";
2050 /**
2051   * <b>Fluent Client</b> search parameter constant for <b>status</b>
2052   * <p>
2053   * Description: <b>The current status of the data element</b><br>
2054   * Type: <b>token</b><br>
2055   * Path: <b>DataElement.status</b><br>
2056   * </p>
2057   */
2058  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
2059
2060
2061}