Source code

001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017package ca.uhn.fhir.model.dstu2.composite;
018
019import java.net.URI;
020import java.math.BigDecimal;
021import org.apache.commons.lang3.StringUtils;
022import java.util.*;
023import ca.uhn.fhir.model.api.*;
024import ca.uhn.fhir.model.primitive.*;
025import ca.uhn.fhir.model.api.annotation.*;
026import ca.uhn.fhir.model.base.composite.*;
027
028import ca.uhn.fhir.model.dstu2.valueset.AddressTypeEnum;
029import ca.uhn.fhir.model.dstu2.valueset.AddressUseEnum;
030import ca.uhn.fhir.model.dstu2.valueset.AggregationModeEnum;
031import ca.uhn.fhir.model.dstu2.valueset.BindingStrengthEnum;
032import ca.uhn.fhir.model.dstu2.composite.CodeableConceptDt;
033import ca.uhn.fhir.model.dstu2.composite.CodingDt;
034import ca.uhn.fhir.model.dstu2.valueset.ConstraintSeverityEnum;
035import ca.uhn.fhir.model.dstu2.valueset.ContactPointSystemEnum;
036import ca.uhn.fhir.model.dstu2.valueset.ContactPointUseEnum;
037import ca.uhn.fhir.model.dstu2.resource.Device;
038import ca.uhn.fhir.model.dstu2.valueset.EventTimingEnum;
039import ca.uhn.fhir.model.dstu2.valueset.IdentifierTypeCodesEnum;
040import ca.uhn.fhir.model.dstu2.valueset.IdentifierUseEnum;
041import ca.uhn.fhir.model.dstu2.valueset.NameUseEnum;
042import ca.uhn.fhir.model.dstu2.resource.Organization;
043import ca.uhn.fhir.model.dstu2.resource.Patient;
044import ca.uhn.fhir.model.dstu2.composite.PeriodDt;
045import ca.uhn.fhir.model.dstu2.resource.Practitioner;
046import ca.uhn.fhir.model.dstu2.valueset.PropertyRepresentationEnum;
047import ca.uhn.fhir.model.dstu2.valueset.QuantityComparatorEnum;
048import ca.uhn.fhir.model.dstu2.composite.QuantityDt;
049import ca.uhn.fhir.model.dstu2.composite.RangeDt;
050import ca.uhn.fhir.model.dstu2.resource.RelatedPerson;
051import ca.uhn.fhir.model.dstu2.valueset.SignatureTypeCodesEnum;
052import ca.uhn.fhir.model.dstu2.valueset.SlicingRulesEnum;
053import ca.uhn.fhir.model.api.TemporalPrecisionEnum;
054import ca.uhn.fhir.model.dstu2.valueset.TimingAbbreviationEnum;
055import ca.uhn.fhir.model.dstu2.valueset.UnitsOfTimeEnum;
056import ca.uhn.fhir.model.dstu2.resource.ValueSet;
057import ca.uhn.fhir.model.dstu2.composite.BoundCodeableConceptDt;
058import ca.uhn.fhir.model.dstu2.composite.DurationDt;
059import ca.uhn.fhir.model.dstu2.composite.ResourceReferenceDt;
060import ca.uhn.fhir.model.dstu2.composite.SimpleQuantityDt;
061import ca.uhn.fhir.model.primitive.Base64BinaryDt;
062import ca.uhn.fhir.model.primitive.BooleanDt;
063import ca.uhn.fhir.model.primitive.BoundCodeDt;
064import ca.uhn.fhir.model.primitive.CodeDt;
065import ca.uhn.fhir.model.primitive.DateTimeDt;
066import ca.uhn.fhir.model.primitive.DecimalDt;
067import ca.uhn.fhir.model.primitive.IdDt;
068import ca.uhn.fhir.model.primitive.InstantDt;
069import ca.uhn.fhir.model.primitive.IntegerDt;
070import ca.uhn.fhir.model.primitive.MarkdownDt;
071import ca.uhn.fhir.model.primitive.PositiveIntDt;
072import ca.uhn.fhir.model.primitive.StringDt;
073import ca.uhn.fhir.model.primitive.UnsignedIntDt;
074import ca.uhn.fhir.model.primitive.UriDt;
075
076/**
077 * HAPI/FHIR <b>ElementDefinitionDt</b> Datatype
078 * ()
079 *
080 * <p>
081 * <b>Definition:</b>
082 * Captures constraints on each element within the resource, profile, or extension
083 * </p> 
084 *
085 * <p>
086 * <b>Requirements:</b>
087 * 
088 * </p> 
089 */
090@DatatypeDef(name="ElementDefinition") 
091public class ElementDefinitionDt
092        extends  BaseIdentifiableElement         implements ICompositeDatatype{
093
094        /**
095         * Constructor
096         */
097        public ElementDefinitionDt() {
098                // nothing
099        }
100
101
102        @Child(name="path", type=StringDt.class, order=0, min=1, max=1, summary=true, modifier=false)   
103        @Description(
104                shortDefinition="",
105                formalDefinition="The path identifies the element and is expressed as a \".\"-separated list of ancestor elements, beginning with the name of the resource or extension"
106        )
107        private StringDt myPath;
108        
109        @Child(name="representation", type=CodeDt.class, order=1, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false) 
110        @Description(
111                shortDefinition="",
112                formalDefinition="Codes that define how this element is represented in instances, when the deviation varies from the normal case"
113        )
114        @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/property-representation")
115        private java.util.List<BoundCodeDt<PropertyRepresentationEnum>> myRepresentation;
116        
117        @Child(name="name", type=StringDt.class, order=2, min=0, max=1, summary=true, modifier=false)   
118        @Description(
119                shortDefinition="",
120                formalDefinition="The name of this element definition (to refer to it from other element definitions using ElementDefinition.nameReference). This is a unique name referring to a specific set of constraints applied to this element. One use of this is to provide a name to different slices of the same element"
121        )
122        private StringDt myName;
123        
124        @Child(name="label", type=StringDt.class, order=3, min=0, max=1, summary=true, modifier=false)  
125        @Description(
126                shortDefinition="",
127                formalDefinition="The text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form."
128        )
129        private StringDt myLabel;
130        
131        @Child(name="code", type=CodingDt.class, order=4, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false) 
132        @Description(
133                shortDefinition="",
134                formalDefinition="A code that provides the meaning for the element according to a particular terminology."
135        )
136        private java.util.List<CodingDt> myCode;
137        
138        @Child(name="slicing", order=5, min=0, max=1, summary=true, modifier=false)     
139        @Description(
140                shortDefinition="",
141                formalDefinition="Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set)"
142        )
143        private Slicing mySlicing;
144        
145        @Child(name="short", type=StringDt.class, order=6, min=0, max=1, summary=true, modifier=false)  
146        @Description(
147                shortDefinition="",
148                formalDefinition="A concise description of what this element means (e.g. for use in autogenerated summaries)"
149        )
150        private StringDt myShort;
151        
152        @Child(name="definition", type=MarkdownDt.class, order=7, min=0, max=1, summary=true, modifier=false)   
153        @Description(
154                shortDefinition="",
155                formalDefinition="Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource"
156        )
157        private MarkdownDt myDefinition;
158        
159        @Child(name="comments", type=MarkdownDt.class, order=8, min=0, max=1, summary=true, modifier=false)     
160        @Description(
161                shortDefinition="",
162                formalDefinition="Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc."
163        )
164        private MarkdownDt myComments;
165        
166        @Child(name="requirements", type=MarkdownDt.class, order=9, min=0, max=1, summary=true, modifier=false) 
167        @Description(
168                shortDefinition="",
169                formalDefinition="This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element."
170        )
171        private MarkdownDt myRequirements;
172        
173        @Child(name="alias", type=StringDt.class, order=10, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false)       
174        @Description(
175                shortDefinition="",
176                formalDefinition="Identifies additional names by which this element might also be known"
177        )
178        private java.util.List<StringDt> myAlias;
179        
180        @Child(name="min", type=IntegerDt.class, order=11, min=0, max=1, summary=true, modifier=false)  
181        @Description(
182                shortDefinition="",
183                formalDefinition="The minimum number of times this element SHALL appear in the instance"
184        )
185        private IntegerDt myMin;
186        
187        @Child(name="max", type=StringDt.class, order=12, min=0, max=1, summary=true, modifier=false)   
188        @Description(
189                shortDefinition="",
190                formalDefinition="The maximum number of times this element is permitted to appear in the instance"
191        )
192        private StringDt myMax;
193        
194        @Child(name="base", order=13, min=0, max=1, summary=true, modifier=false)       
195        @Description(
196                shortDefinition="",
197                formalDefinition="Information about the base definition of the element, provided to make it unncessary for tools to trace the deviation of the element through the derived and related profiles. This information is only provided where the element definition represents a constraint on another element definition, and must be present if there is a base element definition."
198        )
199        private Base myBase;
200        
201        @Child(name="type", order=14, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false)     
202        @Description(
203                shortDefinition="",
204                formalDefinition="The data type or resource that the value of this element is permitted to be"
205        )
206        private java.util.List<Type> myType;
207        
208        @Child(name="nameReference", type=StringDt.class, order=15, min=0, max=1, summary=true, modifier=false) 
209        @Description(
210                shortDefinition="",
211                formalDefinition="Identifies the name of a slice defined elsewhere in the profile whose constraints should be applied to the current element"
212        )
213        private StringDt myNameReference;
214        
215        @Child(name="defaultValue", type=IDatatype.class, order=16, min=0, max=1, summary=true, modifier=false) 
216        @Description(
217                shortDefinition="",
218                formalDefinition="The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false')"
219        )
220        private IDatatype myDefaultValue;
221        
222        @Child(name="meaningWhenMissing", type=MarkdownDt.class, order=17, min=0, max=1, summary=true, modifier=false)  
223        @Description(
224                shortDefinition="",
225                formalDefinition="The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing'"
226        )
227        private MarkdownDt myMeaningWhenMissing;
228        
229        @Child(name="fixed", type=IDatatype.class, order=18, min=0, max=1, summary=true, modifier=false)        
230        @Description(
231                shortDefinition="",
232                formalDefinition="Specifies a value that SHALL be exactly the value  for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing."
233        )
234        private IDatatype myFixed;
235        
236        @Child(name="pattern", type=IDatatype.class, order=19, min=0, max=1, summary=true, modifier=false)      
237        @Description(
238                shortDefinition="",
239                formalDefinition="Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example.  The values of elements present in the pattern must match exactly (case-sensitive, accent-sensitive, etc.)."
240        )
241        private IDatatype myPattern;
242        
243        @Child(name="example", type=IDatatype.class, order=20, min=0, max=1, summary=true, modifier=false)      
244        @Description(
245                shortDefinition="",
246                formalDefinition="A sample value for this element demonstrating the type of information that would typically be captured."
247        )
248        private IDatatype myExample;
249        
250        @Child(name="minValue", type=IDatatype.class, order=21, min=0, max=1, summary=true, modifier=false)     
251        @Description(
252                shortDefinition="",
253                formalDefinition="The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity"
254        )
255        private IDatatype myMinValue;
256        
257        @Child(name="maxValue", type=IDatatype.class, order=22, min=0, max=1, summary=true, modifier=false)     
258        @Description(
259                shortDefinition="",
260                formalDefinition="The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity"
261        )
262        private IDatatype myMaxValue;
263        
264        @Child(name="maxLength", type=IntegerDt.class, order=23, min=0, max=1, summary=true, modifier=false)    
265        @Description(
266                shortDefinition="",
267                formalDefinition="Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element"
268        )
269        private IntegerDt myMaxLength;
270        
271        @Child(name="condition", type=IdDt.class, order=24, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false)       
272        @Description(
273                shortDefinition="",
274                formalDefinition="A reference to an invariant that may make additional statements about the cardinality or value in the instance"
275        )
276        private java.util.List<IdDt> myCondition;
277        
278        @Child(name="constraint", order=25, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false)       
279        @Description(
280                shortDefinition="",
281                formalDefinition="Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance"
282        )
283        private java.util.List<Constraint> myConstraint;
284        
285        @Child(name="mustSupport", type=BooleanDt.class, order=26, min=0, max=1, summary=true, modifier=false)  
286        @Description(
287                shortDefinition="",
288                formalDefinition="If true, implementations that produce or consume resources SHALL provide \"support\" for the element in some meaningful way.  If false, the element may be ignored and not supported"
289        )
290        private BooleanDt myMustSupport;
291        
292        @Child(name="isModifier", type=BooleanDt.class, order=27, min=0, max=1, summary=true, modifier=false)   
293        @Description(
294                shortDefinition="",
295                formalDefinition="If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system."
296        )
297        private BooleanDt myIsModifier;
298        
299        @Child(name="isSummary", type=BooleanDt.class, order=28, min=0, max=1, summary=true, modifier=false)    
300        @Description(
301                shortDefinition="",
302                formalDefinition="Whether the element should be included if a client requests a search with the parameter _summary=true"
303        )
304        private BooleanDt myIsSummary;
305        
306        @Child(name="binding", order=29, min=0, max=1, summary=true, modifier=false)    
307        @Description(
308                shortDefinition="",
309                formalDefinition="Binds to a value set if this element is coded (code, Coding, CodeableConcept)"
310        )
311        private Binding myBinding;
312        
313        @Child(name="mapping", order=30, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false)  
314        @Description(
315                shortDefinition="",
316                formalDefinition="Identifies a concept from an external specification that roughly corresponds to this element"
317        )
318        private java.util.List<Mapping> myMapping;
319        
320
321        @Override
322        public boolean isEmpty() {
323                return super.isBaseEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(  myPath,  myRepresentation,  myName,  myLabel,  myCode,  mySlicing,  myShort,  myDefinition,  myComments,  myRequirements,  myAlias,  myMin,  myMax,  myBase,  myType,  myNameReference,  myDefaultValue,  myMeaningWhenMissing,  myFixed,  myPattern,  myExample,  myMinValue,  myMaxValue,  myMaxLength,  myCondition,  myConstraint,  myMustSupport,  myIsModifier,  myIsSummary,  myBinding,  myMapping);
324        }
325        
326        @Override
327        public <T extends IElement> List<T> getAllPopulatedChildElementsOfType(Class<T> theType) {
328                return ca.uhn.fhir.util.ElementUtil.allPopulatedChildElements(theType, myPath, myRepresentation, myName, myLabel, myCode, mySlicing, myShort, myDefinition, myComments, myRequirements, myAlias, myMin, myMax, myBase, myType, myNameReference, myDefaultValue, myMeaningWhenMissing, myFixed, myPattern, myExample, myMinValue, myMaxValue, myMaxLength, myCondition, myConstraint, myMustSupport, myIsModifier, myIsSummary, myBinding, myMapping);
329        }
330
331        /**
332         * Gets the value(s) for <b>path</b> ().
333         * creating it if it does
334         * not exist. Will not return <code>null</code>.
335         *
336     * <p>
337     * <b>Definition:</b>
338     * The path identifies the element and is expressed as a \&quot;.\&quot;-separated list of ancestor elements, beginning with the name of the resource or extension
339     * </p> 
340         */
341        public StringDt getPathElement() {  
342                if (myPath == null) {
343                        myPath = new StringDt();
344                }
345                return myPath;
346        }
347
348        
349        /**
350         * Gets the value(s) for <b>path</b> ().
351         * creating it if it does
352         * not exist. This method may return <code>null</code>.
353         *
354     * <p>
355     * <b>Definition:</b>
356     * The path identifies the element and is expressed as a \&quot;.\&quot;-separated list of ancestor elements, beginning with the name of the resource or extension
357     * </p> 
358         */
359        public String getPath() {  
360                return getPathElement().getValue();
361        }
362
363        /**
364         * Sets the value(s) for <b>path</b> ()
365         *
366     * <p>
367     * <b>Definition:</b>
368     * The path identifies the element and is expressed as a \&quot;.\&quot;-separated list of ancestor elements, beginning with the name of the resource or extension
369     * </p> 
370         */
371        public ElementDefinitionDt setPath(StringDt theValue) {
372                myPath = theValue;
373                return this;
374        }
375        
376        
377
378        /**
379         * Sets the value for <b>path</b> ()
380         *
381     * <p>
382     * <b>Definition:</b>
383     * The path identifies the element and is expressed as a \&quot;.\&quot;-separated list of ancestor elements, beginning with the name of the resource or extension
384     * </p> 
385         */
386        public ElementDefinitionDt setPath( String theString) {
387                myPath = new StringDt(theString); 
388                return this; 
389        }
390
391 
392        /**
393         * Gets the value(s) for <b>representation</b> ().
394         * creating it if it does
395         * not exist. Will not return <code>null</code>.
396         *
397     * <p>
398     * <b>Definition:</b>
399     * Codes that define how this element is represented in instances, when the deviation varies from the normal case
400     * </p> 
401         */
402        public java.util.List<BoundCodeDt<PropertyRepresentationEnum>> getRepresentation() {  
403                if (myRepresentation == null) {
404                        myRepresentation = new java.util.ArrayList<BoundCodeDt<PropertyRepresentationEnum>>();
405                }
406                return myRepresentation;
407        }
408
409        /**
410         * Sets the value(s) for <b>representation</b> ()
411         *
412     * <p>
413     * <b>Definition:</b>
414     * Codes that define how this element is represented in instances, when the deviation varies from the normal case
415     * </p> 
416         */
417        public ElementDefinitionDt setRepresentation(java.util.List<BoundCodeDt<PropertyRepresentationEnum>> theValue) {
418                myRepresentation = theValue;
419                return this;
420        }
421        
422        
423
424        /**
425         * Add a value for <b>representation</b> () using an enumerated type. This
426         * is intended as a convenience method for situations where the FHIR defined ValueSets are mandatory
427         * or contain the desirable codes. If you wish to use codes other than those which are built-in, 
428         * you may also use the {@link #addRepresentation()} method.
429         *
430     * <p>
431     * <b>Definition:</b>
432     * Codes that define how this element is represented in instances, when the deviation varies from the normal case
433     * </p> 
434         */
435        public BoundCodeDt<PropertyRepresentationEnum> addRepresentation(PropertyRepresentationEnum theValue) {
436                BoundCodeDt<PropertyRepresentationEnum> retVal = new BoundCodeDt<PropertyRepresentationEnum>(PropertyRepresentationEnum.VALUESET_BINDER, theValue);
437                getRepresentation().add(retVal);
438                return retVal;
439        }
440
441        /**
442         * Gets the first repetition for <b>representation</b> (),
443         * creating it if it does not already exist.
444         *
445     * <p>
446     * <b>Definition:</b>
447     * Codes that define how this element is represented in instances, when the deviation varies from the normal case
448     * </p> 
449         */
450        public BoundCodeDt<PropertyRepresentationEnum> getRepresentationFirstRep() {
451                if (getRepresentation().size() == 0) {
452                        addRepresentation();
453                }
454                return getRepresentation().get(0);
455        }
456
457        /**
458         * Add a value for <b>representation</b> ()
459         *
460     * <p>
461     * <b>Definition:</b>
462     * Codes that define how this element is represented in instances, when the deviation varies from the normal case
463     * </p> 
464         */
465        public BoundCodeDt<PropertyRepresentationEnum> addRepresentation() {
466                BoundCodeDt<PropertyRepresentationEnum> retVal = new BoundCodeDt<PropertyRepresentationEnum>(PropertyRepresentationEnum.VALUESET_BINDER);
467                getRepresentation().add(retVal);
468                return retVal;
469        }
470
471        /**
472         * Sets the value(s), and clears any existing value(s) for <b>representation</b> ()
473         *
474     * <p>
475     * <b>Definition:</b>
476     * Codes that define how this element is represented in instances, when the deviation varies from the normal case
477     * </p> 
478         */
479        public ElementDefinitionDt setRepresentation(PropertyRepresentationEnum theValue) {
480                getRepresentation().clear();
481                addRepresentation(theValue);
482                return this;
483        }
484
485  
486        /**
487         * Gets the value(s) for <b>name</b> ().
488         * creating it if it does
489         * not exist. Will not return <code>null</code>.
490         *
491     * <p>
492     * <b>Definition:</b>
493     * The name of this element definition (to refer to it from other element definitions using ElementDefinition.nameReference). This is a unique name referring to a specific set of constraints applied to this element. One use of this is to provide a name to different slices of the same element
494     * </p> 
495         */
496        public StringDt getNameElement() {  
497                if (myName == null) {
498                        myName = new StringDt();
499                }
500                return myName;
501        }
502
503        
504        /**
505         * Gets the value(s) for <b>name</b> ().
506         * creating it if it does
507         * not exist. This method may return <code>null</code>.
508         *
509     * <p>
510     * <b>Definition:</b>
511     * The name of this element definition (to refer to it from other element definitions using ElementDefinition.nameReference). This is a unique name referring to a specific set of constraints applied to this element. One use of this is to provide a name to different slices of the same element
512     * </p> 
513         */
514        public String getName() {  
515                return getNameElement().getValue();
516        }
517
518        /**
519         * Sets the value(s) for <b>name</b> ()
520         *
521     * <p>
522     * <b>Definition:</b>
523     * The name of this element definition (to refer to it from other element definitions using ElementDefinition.nameReference). This is a unique name referring to a specific set of constraints applied to this element. One use of this is to provide a name to different slices of the same element
524     * </p> 
525         */
526        public ElementDefinitionDt setName(StringDt theValue) {
527                myName = theValue;
528                return this;
529        }
530        
531        
532
533        /**
534         * Sets the value for <b>name</b> ()
535         *
536     * <p>
537     * <b>Definition:</b>
538     * The name of this element definition (to refer to it from other element definitions using ElementDefinition.nameReference). This is a unique name referring to a specific set of constraints applied to this element. One use of this is to provide a name to different slices of the same element
539     * </p> 
540         */
541        public ElementDefinitionDt setName( String theString) {
542                myName = new StringDt(theString); 
543                return this; 
544        }
545
546 
547        /**
548         * Gets the value(s) for <b>label</b> ().
549         * creating it if it does
550         * not exist. Will not return <code>null</code>.
551         *
552     * <p>
553     * <b>Definition:</b>
554     * The text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.
555     * </p> 
556         */
557        public StringDt getLabelElement() {  
558                if (myLabel == null) {
559                        myLabel = new StringDt();
560                }
561                return myLabel;
562        }
563
564        
565        /**
566         * Gets the value(s) for <b>label</b> ().
567         * creating it if it does
568         * not exist. This method may return <code>null</code>.
569         *
570     * <p>
571     * <b>Definition:</b>
572     * The text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.
573     * </p> 
574         */
575        public String getLabel() {  
576                return getLabelElement().getValue();
577        }
578
579        /**
580         * Sets the value(s) for <b>label</b> ()
581         *
582     * <p>
583     * <b>Definition:</b>
584     * The text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.
585     * </p> 
586         */
587        public ElementDefinitionDt setLabel(StringDt theValue) {
588                myLabel = theValue;
589                return this;
590        }
591        
592        
593
594        /**
595         * Sets the value for <b>label</b> ()
596         *
597     * <p>
598     * <b>Definition:</b>
599     * The text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.
600     * </p> 
601         */
602        public ElementDefinitionDt setLabel( String theString) {
603                myLabel = new StringDt(theString); 
604                return this; 
605        }
606
607 
608        /**
609         * Gets the value(s) for <b>code</b> ().
610         * creating it if it does
611         * not exist. Will not return <code>null</code>.
612         *
613     * <p>
614     * <b>Definition:</b>
615     * A code that provides the meaning for the element according to a particular terminology.
616     * </p> 
617         */
618        public java.util.List<CodingDt> getCode() {  
619                if (myCode == null) {
620                        myCode = new java.util.ArrayList<CodingDt>();
621                }
622                return myCode;
623        }
624
625        /**
626         * Sets the value(s) for <b>code</b> ()
627         *
628     * <p>
629     * <b>Definition:</b>
630     * A code that provides the meaning for the element according to a particular terminology.
631     * </p> 
632         */
633        public ElementDefinitionDt setCode(java.util.List<CodingDt> theValue) {
634                myCode = theValue;
635                return this;
636        }
637        
638        
639
640        /**
641         * Adds and returns a new value for <b>code</b> ()
642         *
643     * <p>
644     * <b>Definition:</b>
645     * A code that provides the meaning for the element according to a particular terminology.
646     * </p> 
647         */
648        public CodingDt addCode() {
649                CodingDt newType = new CodingDt();
650                getCode().add(newType);
651                return newType; 
652        }
653
654        /**
655         * Adds a given new value for <b>code</b> ()
656         *
657         * <p>
658         * <b>Definition:</b>
659         * A code that provides the meaning for the element according to a particular terminology.
660         * </p>
661         * @param theValue The code to add (must not be <code>null</code>)
662         */
663        public ElementDefinitionDt addCode(CodingDt theValue) {
664                if (theValue == null) {
665                        throw new NullPointerException("theValue must not be null");
666                }
667                getCode().add(theValue);
668                return this;
669        }
670
671        /**
672         * Gets the first repetition for <b>code</b> (),
673         * creating it if it does not already exist.
674         *
675     * <p>
676     * <b>Definition:</b>
677     * A code that provides the meaning for the element according to a particular terminology.
678     * </p> 
679         */
680        public CodingDt getCodeFirstRep() {
681                if (getCode().isEmpty()) {
682                        return addCode();
683                }
684                return getCode().get(0); 
685        }
686  
687        /**
688         * Gets the value(s) for <b>slicing</b> ().
689         * creating it if it does
690         * not exist. Will not return <code>null</code>.
691         *
692     * <p>
693     * <b>Definition:</b>
694     * Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set)
695     * </p> 
696         */
697        public Slicing getSlicing() {  
698                if (mySlicing == null) {
699                        mySlicing = new Slicing();
700                }
701                return mySlicing;
702        }
703
704        /**
705         * Sets the value(s) for <b>slicing</b> ()
706         *
707     * <p>
708     * <b>Definition:</b>
709     * Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set)
710     * </p> 
711         */
712        public ElementDefinitionDt setSlicing(Slicing theValue) {
713                mySlicing = theValue;
714                return this;
715        }
716        
717        
718
719  
720        /**
721         * Gets the value(s) for <b>short</b> ().
722         * creating it if it does
723         * not exist. Will not return <code>null</code>.
724         *
725     * <p>
726     * <b>Definition:</b>
727     * A concise description of what this element means (e.g. for use in autogenerated summaries)
728     * </p> 
729         */
730        public StringDt getShortElement() {  
731                if (myShort == null) {
732                        myShort = new StringDt();
733                }
734                return myShort;
735        }
736
737        
738        /**
739         * Gets the value(s) for <b>short</b> ().
740         * creating it if it does
741         * not exist. This method may return <code>null</code>.
742         *
743     * <p>
744     * <b>Definition:</b>
745     * A concise description of what this element means (e.g. for use in autogenerated summaries)
746     * </p> 
747         */
748        public String getShort() {  
749                return getShortElement().getValue();
750        }
751
752        /**
753         * Sets the value(s) for <b>short</b> ()
754         *
755     * <p>
756     * <b>Definition:</b>
757     * A concise description of what this element means (e.g. for use in autogenerated summaries)
758     * </p> 
759         */
760        public ElementDefinitionDt setShort(StringDt theValue) {
761                myShort = theValue;
762                return this;
763        }
764        
765        
766
767        /**
768         * Sets the value for <b>short</b> ()
769         *
770     * <p>
771     * <b>Definition:</b>
772     * A concise description of what this element means (e.g. for use in autogenerated summaries)
773     * </p> 
774         */
775        public ElementDefinitionDt setShort( String theString) {
776                myShort = new StringDt(theString); 
777                return this; 
778        }
779
780 
781        /**
782         * Gets the value(s) for <b>definition</b> ().
783         * creating it if it does
784         * not exist. Will not return <code>null</code>.
785         *
786     * <p>
787     * <b>Definition:</b>
788     * Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource
789     * </p> 
790         */
791        public MarkdownDt getDefinitionElement() {  
792                if (myDefinition == null) {
793                        myDefinition = new MarkdownDt();
794                }
795                return myDefinition;
796        }
797
798        
799        /**
800         * Gets the value(s) for <b>definition</b> ().
801         * creating it if it does
802         * not exist. This method may return <code>null</code>.
803         *
804     * <p>
805     * <b>Definition:</b>
806     * Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource
807     * </p> 
808         */
809        public String getDefinition() {  
810                return getDefinitionElement().getValue();
811        }
812
813        /**
814         * Sets the value(s) for <b>definition</b> ()
815         *
816     * <p>
817     * <b>Definition:</b>
818     * Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource
819     * </p> 
820         */
821        public ElementDefinitionDt setDefinition(MarkdownDt theValue) {
822                myDefinition = theValue;
823                return this;
824        }
825        
826        
827
828  
829        /**
830         * Gets the value(s) for <b>comments</b> ().
831         * creating it if it does
832         * not exist. Will not return <code>null</code>.
833         *
834     * <p>
835     * <b>Definition:</b>
836     * Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc.
837     * </p> 
838         */
839        public MarkdownDt getCommentsElement() {  
840                if (myComments == null) {
841                        myComments = new MarkdownDt();
842                }
843                return myComments;
844        }
845
846        
847        /**
848         * Gets the value(s) for <b>comments</b> ().
849         * creating it if it does
850         * not exist. This method may return <code>null</code>.
851         *
852     * <p>
853     * <b>Definition:</b>
854     * Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc.
855     * </p> 
856         */
857        public String getComments() {  
858                return getCommentsElement().getValue();
859        }
860
861        /**
862         * Sets the value(s) for <b>comments</b> ()
863         *
864     * <p>
865     * <b>Definition:</b>
866     * Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc.
867     * </p> 
868         */
869        public ElementDefinitionDt setComments(MarkdownDt theValue) {
870                myComments = theValue;
871                return this;
872        }
873        
874        
875
876  
877        /**
878         * Gets the value(s) for <b>requirements</b> ().
879         * creating it if it does
880         * not exist. Will not return <code>null</code>.
881         *
882     * <p>
883     * <b>Definition:</b>
884     * This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.
885     * </p> 
886         */
887        public MarkdownDt getRequirementsElement() {  
888                if (myRequirements == null) {
889                        myRequirements = new MarkdownDt();
890                }
891                return myRequirements;
892        }
893
894        
895        /**
896         * Gets the value(s) for <b>requirements</b> ().
897         * creating it if it does
898         * not exist. This method may return <code>null</code>.
899         *
900     * <p>
901     * <b>Definition:</b>
902     * This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.
903     * </p> 
904         */
905        public String getRequirements() {  
906                return getRequirementsElement().getValue();
907        }
908
909        /**
910         * Sets the value(s) for <b>requirements</b> ()
911         *
912     * <p>
913     * <b>Definition:</b>
914     * This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.
915     * </p> 
916         */
917        public ElementDefinitionDt setRequirements(MarkdownDt theValue) {
918                myRequirements = theValue;
919                return this;
920        }
921        
922        
923
924  
925        /**
926         * Gets the value(s) for <b>alias</b> ().
927         * creating it if it does
928         * not exist. Will not return <code>null</code>.
929         *
930     * <p>
931     * <b>Definition:</b>
932     * Identifies additional names by which this element might also be known
933     * </p> 
934         */
935        public java.util.List<StringDt> getAlias() {  
936                if (myAlias == null) {
937                        myAlias = new java.util.ArrayList<StringDt>();
938                }
939                return myAlias;
940        }
941
942        /**
943         * Sets the value(s) for <b>alias</b> ()
944         *
945     * <p>
946     * <b>Definition:</b>
947     * Identifies additional names by which this element might also be known
948     * </p> 
949         */
950        public ElementDefinitionDt setAlias(java.util.List<StringDt> theValue) {
951                myAlias = theValue;
952                return this;
953        }
954        
955        
956
957        /**
958         * Adds and returns a new value for <b>alias</b> ()
959         *
960     * <p>
961     * <b>Definition:</b>
962     * Identifies additional names by which this element might also be known
963     * </p> 
964         */
965        public StringDt addAlias() {
966                StringDt newType = new StringDt();
967                getAlias().add(newType);
968                return newType; 
969        }
970
971        /**
972         * Adds a given new value for <b>alias</b> ()
973         *
974         * <p>
975         * <b>Definition:</b>
976         * Identifies additional names by which this element might also be known
977         * </p>
978         * @param theValue The alias to add (must not be <code>null</code>)
979         */
980        public ElementDefinitionDt addAlias(StringDt theValue) {
981                if (theValue == null) {
982                        throw new NullPointerException("theValue must not be null");
983                }
984                getAlias().add(theValue);
985                return this;
986        }
987
988        /**
989         * Gets the first repetition for <b>alias</b> (),
990         * creating it if it does not already exist.
991         *
992     * <p>
993     * <b>Definition:</b>
994     * Identifies additional names by which this element might also be known
995     * </p> 
996         */
997        public StringDt getAliasFirstRep() {
998                if (getAlias().isEmpty()) {
999                        return addAlias();
1000                }
1001                return getAlias().get(0); 
1002        }
1003        /**
1004         * Adds a new value for <b>alias</b> ()
1005         *
1006     * <p>
1007     * <b>Definition:</b>
1008     * Identifies additional names by which this element might also be known
1009     * </p> 
1010     *
1011     * @return Returns a reference to this object, to allow for simple chaining.
1012         */
1013        public ElementDefinitionDt addAlias( String theString) {
1014                if (myAlias == null) {
1015                        myAlias = new java.util.ArrayList<StringDt>();
1016                }
1017                myAlias.add(new StringDt(theString));
1018                return this; 
1019        }
1020
1021 
1022        /**
1023         * Gets the value(s) for <b>min</b> ().
1024         * creating it if it does
1025         * not exist. Will not return <code>null</code>.
1026         *
1027     * <p>
1028     * <b>Definition:</b>
1029     * The minimum number of times this element SHALL appear in the instance
1030     * </p> 
1031         */
1032        public IntegerDt getMinElement() {  
1033                if (myMin == null) {
1034                        myMin = new IntegerDt();
1035                }
1036                return myMin;
1037        }
1038
1039        
1040        /**
1041         * Gets the value(s) for <b>min</b> ().
1042         * creating it if it does
1043         * not exist. This method may return <code>null</code>.
1044         *
1045     * <p>
1046     * <b>Definition:</b>
1047     * The minimum number of times this element SHALL appear in the instance
1048     * </p> 
1049         */
1050        public Integer getMin() {  
1051                return getMinElement().getValue();
1052        }
1053
1054        /**
1055         * Sets the value(s) for <b>min</b> ()
1056         *
1057     * <p>
1058     * <b>Definition:</b>
1059     * The minimum number of times this element SHALL appear in the instance
1060     * </p> 
1061         */
1062        public ElementDefinitionDt setMin(IntegerDt theValue) {
1063                myMin = theValue;
1064                return this;
1065        }
1066        
1067        
1068
1069        /**
1070         * Sets the value for <b>min</b> ()
1071         *
1072     * <p>
1073     * <b>Definition:</b>
1074     * The minimum number of times this element SHALL appear in the instance
1075     * </p> 
1076         */
1077        public ElementDefinitionDt setMin( int theInteger) {
1078                myMin = new IntegerDt(theInteger); 
1079                return this; 
1080        }
1081
1082 
1083        /**
1084         * Gets the value(s) for <b>max</b> ().
1085         * creating it if it does
1086         * not exist. Will not return <code>null</code>.
1087         *
1088     * <p>
1089     * <b>Definition:</b>
1090     * The maximum number of times this element is permitted to appear in the instance
1091     * </p> 
1092         */
1093        public StringDt getMaxElement() {  
1094                if (myMax == null) {
1095                        myMax = new StringDt();
1096                }
1097                return myMax;
1098        }
1099
1100        
1101        /**
1102         * Gets the value(s) for <b>max</b> ().
1103         * creating it if it does
1104         * not exist. This method may return <code>null</code>.
1105         *
1106     * <p>
1107     * <b>Definition:</b>
1108     * The maximum number of times this element is permitted to appear in the instance
1109     * </p> 
1110         */
1111        public String getMax() {  
1112                return getMaxElement().getValue();
1113        }
1114
1115        /**
1116         * Sets the value(s) for <b>max</b> ()
1117         *
1118     * <p>
1119     * <b>Definition:</b>
1120     * The maximum number of times this element is permitted to appear in the instance
1121     * </p> 
1122         */
1123        public ElementDefinitionDt setMax(StringDt theValue) {
1124                myMax = theValue;
1125                return this;
1126        }
1127        
1128        
1129
1130        /**
1131         * Sets the value for <b>max</b> ()
1132         *
1133     * <p>
1134     * <b>Definition:</b>
1135     * The maximum number of times this element is permitted to appear in the instance
1136     * </p> 
1137         */
1138        public ElementDefinitionDt setMax( String theString) {
1139                myMax = new StringDt(theString); 
1140                return this; 
1141        }
1142
1143 
1144        /**
1145         * Gets the value(s) for <b>base</b> ().
1146         * creating it if it does
1147         * not exist. Will not return <code>null</code>.
1148         *
1149     * <p>
1150     * <b>Definition:</b>
1151     * Information about the base definition of the element, provided to make it unncessary for tools to trace the deviation of the element through the derived and related profiles. This information is only provided where the element definition represents a constraint on another element definition, and must be present if there is a base element definition.
1152     * </p> 
1153         */
1154        public Base getBase() {  
1155                if (myBase == null) {
1156                        myBase = new Base();
1157                }
1158                return myBase;
1159        }
1160
1161        /**
1162         * Sets the value(s) for <b>base</b> ()
1163         *
1164     * <p>
1165     * <b>Definition:</b>
1166     * Information about the base definition of the element, provided to make it unncessary for tools to trace the deviation of the element through the derived and related profiles. This information is only provided where the element definition represents a constraint on another element definition, and must be present if there is a base element definition.
1167     * </p> 
1168         */
1169        public ElementDefinitionDt setBase(Base theValue) {
1170                myBase = theValue;
1171                return this;
1172        }
1173        
1174        
1175
1176  
1177        /**
1178         * Gets the value(s) for <b>type</b> ().
1179         * creating it if it does
1180         * not exist. Will not return <code>null</code>.
1181         *
1182     * <p>
1183     * <b>Definition:</b>
1184     * The data type or resource that the value of this element is permitted to be
1185     * </p> 
1186         */
1187        public java.util.List<Type> getType() {  
1188                if (myType == null) {
1189                        myType = new java.util.ArrayList<Type>();
1190                }
1191                return myType;
1192        }
1193
1194        /**
1195         * Sets the value(s) for <b>type</b> ()
1196         *
1197     * <p>
1198     * <b>Definition:</b>
1199     * The data type or resource that the value of this element is permitted to be
1200     * </p> 
1201         */
1202        public ElementDefinitionDt setType(java.util.List<Type> theValue) {
1203                myType = theValue;
1204                return this;
1205        }
1206        
1207        
1208
1209        /**
1210         * Adds and returns a new value for <b>type</b> ()
1211         *
1212     * <p>
1213     * <b>Definition:</b>
1214     * The data type or resource that the value of this element is permitted to be
1215     * </p> 
1216         */
1217        public Type addType() {
1218                Type newType = new Type();
1219                getType().add(newType);
1220                return newType; 
1221        }
1222
1223        /**
1224         * Adds a given new value for <b>type</b> ()
1225         *
1226         * <p>
1227         * <b>Definition:</b>
1228         * The data type or resource that the value of this element is permitted to be
1229         * </p>
1230         * @param theValue The type to add (must not be <code>null</code>)
1231         */
1232        public ElementDefinitionDt addType(Type theValue) {
1233                if (theValue == null) {
1234                        throw new NullPointerException("theValue must not be null");
1235                }
1236                getType().add(theValue);
1237                return this;
1238        }
1239
1240        /**
1241         * Gets the first repetition for <b>type</b> (),
1242         * creating it if it does not already exist.
1243         *
1244     * <p>
1245     * <b>Definition:</b>
1246     * The data type or resource that the value of this element is permitted to be
1247     * </p> 
1248         */
1249        public Type getTypeFirstRep() {
1250                if (getType().isEmpty()) {
1251                        return addType();
1252                }
1253                return getType().get(0); 
1254        }
1255  
1256        /**
1257         * Gets the value(s) for <b>nameReference</b> ().
1258         * creating it if it does
1259         * not exist. Will not return <code>null</code>.
1260         *
1261     * <p>
1262     * <b>Definition:</b>
1263     * Identifies the name of a slice defined elsewhere in the profile whose constraints should be applied to the current element
1264     * </p> 
1265         */
1266        public StringDt getNameReferenceElement() {  
1267                if (myNameReference == null) {
1268                        myNameReference = new StringDt();
1269                }
1270                return myNameReference;
1271        }
1272
1273        
1274        /**
1275         * Gets the value(s) for <b>nameReference</b> ().
1276         * creating it if it does
1277         * not exist. This method may return <code>null</code>.
1278         *
1279     * <p>
1280     * <b>Definition:</b>
1281     * Identifies the name of a slice defined elsewhere in the profile whose constraints should be applied to the current element
1282     * </p> 
1283         */
1284        public String getNameReference() {  
1285                return getNameReferenceElement().getValue();
1286        }
1287
1288        /**
1289         * Sets the value(s) for <b>nameReference</b> ()
1290         *
1291     * <p>
1292     * <b>Definition:</b>
1293     * Identifies the name of a slice defined elsewhere in the profile whose constraints should be applied to the current element
1294     * </p> 
1295         */
1296        public ElementDefinitionDt setNameReference(StringDt theValue) {
1297                myNameReference = theValue;
1298                return this;
1299        }
1300        
1301        
1302
1303        /**
1304         * Sets the value for <b>nameReference</b> ()
1305         *
1306     * <p>
1307     * <b>Definition:</b>
1308     * Identifies the name of a slice defined elsewhere in the profile whose constraints should be applied to the current element
1309     * </p> 
1310         */
1311        public ElementDefinitionDt setNameReference( String theString) {
1312                myNameReference = new StringDt(theString); 
1313                return this; 
1314        }
1315
1316 
1317        /**
1318         * Gets the value(s) for <b>defaultValue[x]</b> ().
1319         * creating it if it does
1320         * not exist. Will not return <code>null</code>.
1321         *
1322     * <p>
1323     * <b>Definition:</b>
1324     * The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false')
1325     * </p> 
1326         */
1327        public IDatatype getDefaultValue() {  
1328                return myDefaultValue;
1329        }
1330
1331        /**
1332         * Sets the value(s) for <b>defaultValue[x]</b> ()
1333         *
1334     * <p>
1335     * <b>Definition:</b>
1336     * The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false')
1337     * </p> 
1338         */
1339        public ElementDefinitionDt setDefaultValue(IDatatype theValue) {
1340                myDefaultValue = theValue;
1341                return this;
1342        }
1343        
1344        
1345
1346  
1347        /**
1348         * Gets the value(s) for <b>meaningWhenMissing</b> ().
1349         * creating it if it does
1350         * not exist. Will not return <code>null</code>.
1351         *
1352     * <p>
1353     * <b>Definition:</b>
1354     * The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing'
1355     * </p> 
1356         */
1357        public MarkdownDt getMeaningWhenMissingElement() {  
1358                if (myMeaningWhenMissing == null) {
1359                        myMeaningWhenMissing = new MarkdownDt();
1360                }
1361                return myMeaningWhenMissing;
1362        }
1363
1364        
1365        /**
1366         * Gets the value(s) for <b>meaningWhenMissing</b> ().
1367         * creating it if it does
1368         * not exist. This method may return <code>null</code>.
1369         *
1370     * <p>
1371     * <b>Definition:</b>
1372     * The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing'
1373     * </p> 
1374         */
1375        public String getMeaningWhenMissing() {  
1376                return getMeaningWhenMissingElement().getValue();
1377        }
1378
1379        /**
1380         * Sets the value(s) for <b>meaningWhenMissing</b> ()
1381         *
1382     * <p>
1383     * <b>Definition:</b>
1384     * The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing'
1385     * </p> 
1386         */
1387        public ElementDefinitionDt setMeaningWhenMissing(MarkdownDt theValue) {
1388                myMeaningWhenMissing = theValue;
1389                return this;
1390        }
1391        
1392        
1393
1394  
1395        /**
1396         * Gets the value(s) for <b>fixed[x]</b> ().
1397         * creating it if it does
1398         * not exist. Will not return <code>null</code>.
1399         *
1400     * <p>
1401     * <b>Definition:</b>
1402     * Specifies a value that SHALL be exactly the value  for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.
1403     * </p> 
1404         */
1405        public IDatatype getFixed() {  
1406                return myFixed;
1407        }
1408
1409        /**
1410         * Sets the value(s) for <b>fixed[x]</b> ()
1411         *
1412     * <p>
1413     * <b>Definition:</b>
1414     * Specifies a value that SHALL be exactly the value  for this element in the instance. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.
1415     * </p> 
1416         */
1417        public ElementDefinitionDt setFixed(IDatatype theValue) {
1418                myFixed = theValue;
1419                return this;
1420        }
1421        
1422        
1423
1424  
1425        /**
1426         * Gets the value(s) for <b>pattern[x]</b> ().
1427         * creating it if it does
1428         * not exist. Will not return <code>null</code>.
1429         *
1430     * <p>
1431     * <b>Definition:</b>
1432     * Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example.  The values of elements present in the pattern must match exactly (case-sensitive, accent-sensitive, etc.).
1433     * </p> 
1434         */
1435        public IDatatype getPattern() {  
1436                return myPattern;
1437        }
1438
1439        /**
1440         * Sets the value(s) for <b>pattern[x]</b> ()
1441         *
1442     * <p>
1443     * <b>Definition:</b>
1444     * Specifies a value that the value in the instance SHALL follow - that is, any value in the pattern must be found in the instance. Other additional values may be found too. This is effectively constraint by example.  The values of elements present in the pattern must match exactly (case-sensitive, accent-sensitive, etc.).
1445     * </p> 
1446         */
1447        public ElementDefinitionDt setPattern(IDatatype theValue) {
1448                myPattern = theValue;
1449                return this;
1450        }
1451        
1452        
1453
1454  
1455        /**
1456         * Gets the value(s) for <b>example[x]</b> ().
1457         * creating it if it does
1458         * not exist. Will not return <code>null</code>.
1459         *
1460     * <p>
1461     * <b>Definition:</b>
1462     * A sample value for this element demonstrating the type of information that would typically be captured.
1463     * </p> 
1464         */
1465        public IDatatype getExample() {  
1466                return myExample;
1467        }
1468
1469        /**
1470         * Sets the value(s) for <b>example[x]</b> ()
1471         *
1472     * <p>
1473     * <b>Definition:</b>
1474     * A sample value for this element demonstrating the type of information that would typically be captured.
1475     * </p> 
1476         */
1477        public ElementDefinitionDt setExample(IDatatype theValue) {
1478                myExample = theValue;
1479                return this;
1480        }
1481        
1482        
1483
1484  
1485        /**
1486         * Gets the value(s) for <b>minValue[x]</b> ().
1487         * creating it if it does
1488         * not exist. Will not return <code>null</code>.
1489         *
1490     * <p>
1491     * <b>Definition:</b>
1492     * The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity
1493     * </p> 
1494         */
1495        public IDatatype getMinValue() {  
1496                return myMinValue;
1497        }
1498
1499        /**
1500         * Sets the value(s) for <b>minValue[x]</b> ()
1501         *
1502     * <p>
1503     * <b>Definition:</b>
1504     * The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity
1505     * </p> 
1506         */
1507        public ElementDefinitionDt setMinValue(IDatatype theValue) {
1508                myMinValue = theValue;
1509                return this;
1510        }
1511        
1512        
1513
1514  
1515        /**
1516         * Gets the value(s) for <b>maxValue[x]</b> ().
1517         * creating it if it does
1518         * not exist. Will not return <code>null</code>.
1519         *
1520     * <p>
1521     * <b>Definition:</b>
1522     * The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity
1523     * </p> 
1524         */
1525        public IDatatype getMaxValue() {  
1526                return myMaxValue;
1527        }
1528
1529        /**
1530         * Sets the value(s) for <b>maxValue[x]</b> ()
1531         *
1532     * <p>
1533     * <b>Definition:</b>
1534     * The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity
1535     * </p> 
1536         */
1537        public ElementDefinitionDt setMaxValue(IDatatype theValue) {
1538                myMaxValue = theValue;
1539                return this;
1540        }
1541        
1542        
1543
1544  
1545        /**
1546         * Gets the value(s) for <b>maxLength</b> ().
1547         * creating it if it does
1548         * not exist. Will not return <code>null</code>.
1549         *
1550     * <p>
1551     * <b>Definition:</b>
1552     * Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element
1553     * </p> 
1554         */
1555        public IntegerDt getMaxLengthElement() {  
1556                if (myMaxLength == null) {
1557                        myMaxLength = new IntegerDt();
1558                }
1559                return myMaxLength;
1560        }
1561
1562        
1563        /**
1564         * Gets the value(s) for <b>maxLength</b> ().
1565         * creating it if it does
1566         * not exist. This method may return <code>null</code>.
1567         *
1568     * <p>
1569     * <b>Definition:</b>
1570     * Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element
1571     * </p> 
1572         */
1573        public Integer getMaxLength() {  
1574                return getMaxLengthElement().getValue();
1575        }
1576
1577        /**
1578         * Sets the value(s) for <b>maxLength</b> ()
1579         *
1580     * <p>
1581     * <b>Definition:</b>
1582     * Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element
1583     * </p> 
1584         */
1585        public ElementDefinitionDt setMaxLength(IntegerDt theValue) {
1586                myMaxLength = theValue;
1587                return this;
1588        }
1589        
1590        
1591
1592        /**
1593         * Sets the value for <b>maxLength</b> ()
1594         *
1595     * <p>
1596     * <b>Definition:</b>
1597     * Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element
1598     * </p> 
1599         */
1600        public ElementDefinitionDt setMaxLength( int theInteger) {
1601                myMaxLength = new IntegerDt(theInteger); 
1602                return this; 
1603        }
1604
1605 
1606        /**
1607         * Gets the value(s) for <b>condition</b> ().
1608         * creating it if it does
1609         * not exist. Will not return <code>null</code>.
1610         *
1611     * <p>
1612     * <b>Definition:</b>
1613     * A reference to an invariant that may make additional statements about the cardinality or value in the instance
1614     * </p> 
1615         */
1616        public java.util.List<IdDt> getCondition() {  
1617                if (myCondition == null) {
1618                        myCondition = new java.util.ArrayList<IdDt>();
1619                }
1620                return myCondition;
1621        }
1622
1623        /**
1624         * Sets the value(s) for <b>condition</b> ()
1625         *
1626     * <p>
1627     * <b>Definition:</b>
1628     * A reference to an invariant that may make additional statements about the cardinality or value in the instance
1629     * </p> 
1630         */
1631        public ElementDefinitionDt setCondition(java.util.List<IdDt> theValue) {
1632                myCondition = theValue;
1633                return this;
1634        }
1635        
1636        
1637
1638        /**
1639         * Adds and returns a new value for <b>condition</b> ()
1640         *
1641     * <p>
1642     * <b>Definition:</b>
1643     * A reference to an invariant that may make additional statements about the cardinality or value in the instance
1644     * </p> 
1645         */
1646        public IdDt addCondition() {
1647                IdDt newType = new IdDt();
1648                getCondition().add(newType);
1649                return newType; 
1650        }
1651
1652        /**
1653         * Adds a given new value for <b>condition</b> ()
1654         *
1655         * <p>
1656         * <b>Definition:</b>
1657         * A reference to an invariant that may make additional statements about the cardinality or value in the instance
1658         * </p>
1659         * @param theValue The condition to add (must not be <code>null</code>)
1660         */
1661        public ElementDefinitionDt addCondition(IdDt theValue) {
1662                if (theValue == null) {
1663                        throw new NullPointerException("theValue must not be null");
1664                }
1665                getCondition().add(theValue);
1666                return this;
1667        }
1668
1669        /**
1670         * Gets the first repetition for <b>condition</b> (),
1671         * creating it if it does not already exist.
1672         *
1673     * <p>
1674     * <b>Definition:</b>
1675     * A reference to an invariant that may make additional statements about the cardinality or value in the instance
1676     * </p> 
1677         */
1678        public IdDt getConditionFirstRep() {
1679                if (getCondition().isEmpty()) {
1680                        return addCondition();
1681                }
1682                return getCondition().get(0); 
1683        }
1684        /**
1685         * Adds a new value for <b>condition</b> ()
1686         *
1687     * <p>
1688     * <b>Definition:</b>
1689     * A reference to an invariant that may make additional statements about the cardinality or value in the instance
1690     * </p> 
1691     *
1692     * @return Returns a reference to this object, to allow for simple chaining.
1693         */
1694        public ElementDefinitionDt addCondition( String theId) {
1695                if (myCondition == null) {
1696                        myCondition = new java.util.ArrayList<IdDt>();
1697                }
1698                myCondition.add(new IdDt(theId));
1699                return this; 
1700        }
1701
1702 
1703        /**
1704         * Gets the value(s) for <b>constraint</b> ().
1705         * creating it if it does
1706         * not exist. Will not return <code>null</code>.
1707         *
1708     * <p>
1709     * <b>Definition:</b>
1710     * Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance
1711     * </p> 
1712         */
1713        public java.util.List<Constraint> getConstraint() {  
1714                if (myConstraint == null) {
1715                        myConstraint = new java.util.ArrayList<Constraint>();
1716                }
1717                return myConstraint;
1718        }
1719
1720        /**
1721         * Sets the value(s) for <b>constraint</b> ()
1722         *
1723     * <p>
1724     * <b>Definition:</b>
1725     * Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance
1726     * </p> 
1727         */
1728        public ElementDefinitionDt setConstraint(java.util.List<Constraint> theValue) {
1729                myConstraint = theValue;
1730                return this;
1731        }
1732        
1733        
1734
1735        /**
1736         * Adds and returns a new value for <b>constraint</b> ()
1737         *
1738     * <p>
1739     * <b>Definition:</b>
1740     * Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance
1741     * </p> 
1742         */
1743        public Constraint addConstraint() {
1744                Constraint newType = new Constraint();
1745                getConstraint().add(newType);
1746                return newType; 
1747        }
1748
1749        /**
1750         * Adds a given new value for <b>constraint</b> ()
1751         *
1752         * <p>
1753         * <b>Definition:</b>
1754         * Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance
1755         * </p>
1756         * @param theValue The constraint to add (must not be <code>null</code>)
1757         */
1758        public ElementDefinitionDt addConstraint(Constraint theValue) {
1759                if (theValue == null) {
1760                        throw new NullPointerException("theValue must not be null");
1761                }
1762                getConstraint().add(theValue);
1763                return this;
1764        }
1765
1766        /**
1767         * Gets the first repetition for <b>constraint</b> (),
1768         * creating it if it does not already exist.
1769         *
1770     * <p>
1771     * <b>Definition:</b>
1772     * Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance
1773     * </p> 
1774         */
1775        public Constraint getConstraintFirstRep() {
1776                if (getConstraint().isEmpty()) {
1777                        return addConstraint();
1778                }
1779                return getConstraint().get(0); 
1780        }
1781  
1782        /**
1783         * Gets the value(s) for <b>mustSupport</b> ().
1784         * creating it if it does
1785         * not exist. Will not return <code>null</code>.
1786         *
1787     * <p>
1788     * <b>Definition:</b>
1789     * If true, implementations that produce or consume resources SHALL provide \&quot;support\&quot; for the element in some meaningful way.  If false, the element may be ignored and not supported
1790     * </p> 
1791         */
1792        public BooleanDt getMustSupportElement() {  
1793                if (myMustSupport == null) {
1794                        myMustSupport = new BooleanDt();
1795                }
1796                return myMustSupport;
1797        }
1798
1799        
1800        /**
1801         * Gets the value(s) for <b>mustSupport</b> ().
1802         * creating it if it does
1803         * not exist. This method may return <code>null</code>.
1804         *
1805     * <p>
1806     * <b>Definition:</b>
1807     * If true, implementations that produce or consume resources SHALL provide \&quot;support\&quot; for the element in some meaningful way.  If false, the element may be ignored and not supported
1808     * </p> 
1809         */
1810        public Boolean getMustSupport() {  
1811                return getMustSupportElement().getValue();
1812        }
1813
1814        /**
1815         * Sets the value(s) for <b>mustSupport</b> ()
1816         *
1817     * <p>
1818     * <b>Definition:</b>
1819     * If true, implementations that produce or consume resources SHALL provide \&quot;support\&quot; for the element in some meaningful way.  If false, the element may be ignored and not supported
1820     * </p> 
1821         */
1822        public ElementDefinitionDt setMustSupport(BooleanDt theValue) {
1823                myMustSupport = theValue;
1824                return this;
1825        }
1826        
1827        
1828
1829        /**
1830         * Sets the value for <b>mustSupport</b> ()
1831         *
1832     * <p>
1833     * <b>Definition:</b>
1834     * If true, implementations that produce or consume resources SHALL provide \&quot;support\&quot; for the element in some meaningful way.  If false, the element may be ignored and not supported
1835     * </p> 
1836         */
1837        public ElementDefinitionDt setMustSupport( boolean theBoolean) {
1838                myMustSupport = new BooleanDt(theBoolean); 
1839                return this; 
1840        }
1841
1842 
1843        /**
1844         * Gets the value(s) for <b>isModifier</b> ().
1845         * creating it if it does
1846         * not exist. Will not return <code>null</code>.
1847         *
1848     * <p>
1849     * <b>Definition:</b>
1850     * If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system.
1851     * </p> 
1852         */
1853        public BooleanDt getIsModifierElement() {  
1854                if (myIsModifier == null) {
1855                        myIsModifier = new BooleanDt();
1856                }
1857                return myIsModifier;
1858        }
1859
1860        
1861        /**
1862         * Gets the value(s) for <b>isModifier</b> ().
1863         * creating it if it does
1864         * not exist. This method may return <code>null</code>.
1865         *
1866     * <p>
1867     * <b>Definition:</b>
1868     * If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system.
1869     * </p> 
1870         */
1871        public Boolean getIsModifier() {  
1872                return getIsModifierElement().getValue();
1873        }
1874
1875        /**
1876         * Sets the value(s) for <b>isModifier</b> ()
1877         *
1878     * <p>
1879     * <b>Definition:</b>
1880     * If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system.
1881     * </p> 
1882         */
1883        public ElementDefinitionDt setIsModifier(BooleanDt theValue) {
1884                myIsModifier = theValue;
1885                return this;
1886        }
1887        
1888        
1889
1890        /**
1891         * Sets the value for <b>isModifier</b> ()
1892         *
1893     * <p>
1894     * <b>Definition:</b>
1895     * If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system.
1896     * </p> 
1897         */
1898        public ElementDefinitionDt setIsModifier( boolean theBoolean) {
1899                myIsModifier = new BooleanDt(theBoolean); 
1900                return this; 
1901        }
1902
1903 
1904        /**
1905         * Gets the value(s) for <b>isSummary</b> ().
1906         * creating it if it does
1907         * not exist. Will not return <code>null</code>.
1908         *
1909     * <p>
1910     * <b>Definition:</b>
1911     * Whether the element should be included if a client requests a search with the parameter _summary=true
1912     * </p> 
1913         */
1914        public BooleanDt getIsSummaryElement() {  
1915                if (myIsSummary == null) {
1916                        myIsSummary = new BooleanDt();
1917                }
1918                return myIsSummary;
1919        }
1920
1921        
1922        /**
1923         * Gets the value(s) for <b>isSummary</b> ().
1924         * creating it if it does
1925         * not exist. This method may return <code>null</code>.
1926         *
1927     * <p>
1928     * <b>Definition:</b>
1929     * Whether the element should be included if a client requests a search with the parameter _summary=true
1930     * </p> 
1931         */
1932        public Boolean getIsSummary() {  
1933                return getIsSummaryElement().getValue();
1934        }
1935
1936        /**
1937         * Sets the value(s) for <b>isSummary</b> ()
1938         *
1939     * <p>
1940     * <b>Definition:</b>
1941     * Whether the element should be included if a client requests a search with the parameter _summary=true
1942     * </p> 
1943         */
1944        public ElementDefinitionDt setIsSummary(BooleanDt theValue) {
1945                myIsSummary = theValue;
1946                return this;
1947        }
1948        
1949        
1950
1951        /**
1952         * Sets the value for <b>isSummary</b> ()
1953         *
1954     * <p>
1955     * <b>Definition:</b>
1956     * Whether the element should be included if a client requests a search with the parameter _summary=true
1957     * </p> 
1958         */
1959        public ElementDefinitionDt setIsSummary( boolean theBoolean) {
1960                myIsSummary = new BooleanDt(theBoolean); 
1961                return this; 
1962        }
1963
1964 
1965        /**
1966         * Gets the value(s) for <b>binding</b> ().
1967         * creating it if it does
1968         * not exist. Will not return <code>null</code>.
1969         *
1970     * <p>
1971     * <b>Definition:</b>
1972     * Binds to a value set if this element is coded (code, Coding, CodeableConcept)
1973     * </p> 
1974         */
1975        public Binding getBinding() {  
1976                if (myBinding == null) {
1977                        myBinding = new Binding();
1978                }
1979                return myBinding;
1980        }
1981
1982        /**
1983         * Sets the value(s) for <b>binding</b> ()
1984         *
1985     * <p>
1986     * <b>Definition:</b>
1987     * Binds to a value set if this element is coded (code, Coding, CodeableConcept)
1988     * </p> 
1989         */
1990        public ElementDefinitionDt setBinding(Binding theValue) {
1991                myBinding = theValue;
1992                return this;
1993        }
1994        
1995        
1996
1997  
1998        /**
1999         * Gets the value(s) for <b>mapping</b> ().
2000         * creating it if it does
2001         * not exist. Will not return <code>null</code>.
2002         *
2003     * <p>
2004     * <b>Definition:</b>
2005     * Identifies a concept from an external specification that roughly corresponds to this element
2006     * </p> 
2007         */
2008        public java.util.List<Mapping> getMapping() {  
2009                if (myMapping == null) {
2010                        myMapping = new java.util.ArrayList<Mapping>();
2011                }
2012                return myMapping;
2013        }
2014
2015        /**
2016         * Sets the value(s) for <b>mapping</b> ()
2017         *
2018     * <p>
2019     * <b>Definition:</b>
2020     * Identifies a concept from an external specification that roughly corresponds to this element
2021     * </p> 
2022         */
2023        public ElementDefinitionDt setMapping(java.util.List<Mapping> theValue) {
2024                myMapping = theValue;
2025                return this;
2026        }
2027        
2028        
2029
2030        /**
2031         * Adds and returns a new value for <b>mapping</b> ()
2032         *
2033     * <p>
2034     * <b>Definition:</b>
2035     * Identifies a concept from an external specification that roughly corresponds to this element
2036     * </p> 
2037         */
2038        public Mapping addMapping() {
2039                Mapping newType = new Mapping();
2040                getMapping().add(newType);
2041                return newType; 
2042        }
2043
2044        /**
2045         * Adds a given new value for <b>mapping</b> ()
2046         *
2047         * <p>
2048         * <b>Definition:</b>
2049         * Identifies a concept from an external specification that roughly corresponds to this element
2050         * </p>
2051         * @param theValue The mapping to add (must not be <code>null</code>)
2052         */
2053        public ElementDefinitionDt addMapping(Mapping theValue) {
2054                if (theValue == null) {
2055                        throw new NullPointerException("theValue must not be null");
2056                }
2057                getMapping().add(theValue);
2058                return this;
2059        }
2060
2061        /**
2062         * Gets the first repetition for <b>mapping</b> (),
2063         * creating it if it does not already exist.
2064         *
2065     * <p>
2066     * <b>Definition:</b>
2067     * Identifies a concept from an external specification that roughly corresponds to this element
2068     * </p> 
2069         */
2070        public Mapping getMappingFirstRep() {
2071                if (getMapping().isEmpty()) {
2072                        return addMapping();
2073                }
2074                return getMapping().get(0); 
2075        }
2076  
2077        /**
2078         * Block class for child element: <b>ElementDefinition.slicing</b> ()
2079         *
2080     * <p>
2081     * <b>Definition:</b>
2082     * Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set)
2083     * </p> 
2084         */
2085        @Block()        
2086        public static class Slicing 
2087            extends  BaseIdentifiableElement        implements IResourceBlock {
2088        
2089        @Child(name="discriminator", type=StringDt.class, order=0, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false)        
2090        @Description(
2091                shortDefinition="",
2092                formalDefinition="Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices"
2093        )
2094        private java.util.List<StringDt> myDiscriminator;
2095        
2096        @Child(name="description", type=StringDt.class, order=1, min=0, max=1, summary=true, modifier=false)    
2097        @Description(
2098                shortDefinition="",
2099                formalDefinition="A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated"
2100        )
2101        private StringDt myDescription;
2102        
2103        @Child(name="ordered", type=BooleanDt.class, order=2, min=0, max=1, summary=true, modifier=false)       
2104        @Description(
2105                shortDefinition="",
2106                formalDefinition="If the matching elements have to occur in the same order as defined in the profile"
2107        )
2108        private BooleanDt myOrdered;
2109        
2110        @Child(name="rules", type=CodeDt.class, order=3, min=1, max=1, summary=true, modifier=false)    
2111        @Description(
2112                shortDefinition="",
2113                formalDefinition="Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end"
2114        )
2115        @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/resource-slicing-rules")
2116        private BoundCodeDt<SlicingRulesEnum> myRules;
2117        
2118
2119        @Override
2120        public boolean isEmpty() {
2121                return super.isBaseEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(  myDiscriminator,  myDescription,  myOrdered,  myRules);
2122        }
2123        
2124        @Override
2125        public <T extends IElement> List<T> getAllPopulatedChildElementsOfType(Class<T> theType) {
2126                return ca.uhn.fhir.util.ElementUtil.allPopulatedChildElements(theType, myDiscriminator, myDescription, myOrdered, myRules);
2127        }
2128
2129        /**
2130         * Gets the value(s) for <b>discriminator</b> ().
2131         * creating it if it does
2132         * not exist. Will not return <code>null</code>.
2133         *
2134     * <p>
2135     * <b>Definition:</b>
2136     * Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices
2137     * </p> 
2138         */
2139        public java.util.List<StringDt> getDiscriminator() {  
2140                if (myDiscriminator == null) {
2141                        myDiscriminator = new java.util.ArrayList<StringDt>();
2142                }
2143                return myDiscriminator;
2144        }
2145
2146        /**
2147         * Sets the value(s) for <b>discriminator</b> ()
2148         *
2149     * <p>
2150     * <b>Definition:</b>
2151     * Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices
2152     * </p> 
2153         */
2154        public Slicing setDiscriminator(java.util.List<StringDt> theValue) {
2155                myDiscriminator = theValue;
2156                return this;
2157        }
2158        
2159        
2160
2161        /**
2162         * Adds and returns a new value for <b>discriminator</b> ()
2163         *
2164     * <p>
2165     * <b>Definition:</b>
2166     * Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices
2167     * </p> 
2168         */
2169        public StringDt addDiscriminator() {
2170                StringDt newType = new StringDt();
2171                getDiscriminator().add(newType);
2172                return newType; 
2173        }
2174
2175        /**
2176         * Adds a given new value for <b>discriminator</b> ()
2177         *
2178         * <p>
2179         * <b>Definition:</b>
2180         * Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices
2181         * </p>
2182         * @param theValue The discriminator to add (must not be <code>null</code>)
2183         */
2184        public Slicing addDiscriminator(StringDt theValue) {
2185                if (theValue == null) {
2186                        throw new NullPointerException("theValue must not be null");
2187                }
2188                getDiscriminator().add(theValue);
2189                return this;
2190        }
2191
2192        /**
2193         * Gets the first repetition for <b>discriminator</b> (),
2194         * creating it if it does not already exist.
2195         *
2196     * <p>
2197     * <b>Definition:</b>
2198     * Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices
2199     * </p> 
2200         */
2201        public StringDt getDiscriminatorFirstRep() {
2202                if (getDiscriminator().isEmpty()) {
2203                        return addDiscriminator();
2204                }
2205                return getDiscriminator().get(0); 
2206        }
2207        /**
2208         * Adds a new value for <b>discriminator</b> ()
2209         *
2210     * <p>
2211     * <b>Definition:</b>
2212     * Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices
2213     * </p> 
2214     *
2215     * @return Returns a reference to this object, to allow for simple chaining.
2216         */
2217        public Slicing addDiscriminator( String theString) {
2218                if (myDiscriminator == null) {
2219                        myDiscriminator = new java.util.ArrayList<StringDt>();
2220                }
2221                myDiscriminator.add(new StringDt(theString));
2222                return this; 
2223        }
2224
2225 
2226        /**
2227         * Gets the value(s) for <b>description</b> ().
2228         * creating it if it does
2229         * not exist. Will not return <code>null</code>.
2230         *
2231     * <p>
2232     * <b>Definition:</b>
2233     * A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated
2234     * </p> 
2235         */
2236        public StringDt getDescriptionElement() {  
2237                if (myDescription == null) {
2238                        myDescription = new StringDt();
2239                }
2240                return myDescription;
2241        }
2242
2243        
2244        /**
2245         * Gets the value(s) for <b>description</b> ().
2246         * creating it if it does
2247         * not exist. This method may return <code>null</code>.
2248         *
2249     * <p>
2250     * <b>Definition:</b>
2251     * A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated
2252     * </p> 
2253         */
2254        public String getDescription() {  
2255                return getDescriptionElement().getValue();
2256        }
2257
2258        /**
2259         * Sets the value(s) for <b>description</b> ()
2260         *
2261     * <p>
2262     * <b>Definition:</b>
2263     * A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated
2264     * </p> 
2265         */
2266        public Slicing setDescription(StringDt theValue) {
2267                myDescription = theValue;
2268                return this;
2269        }
2270        
2271        
2272
2273        /**
2274         * Sets the value for <b>description</b> ()
2275         *
2276     * <p>
2277     * <b>Definition:</b>
2278     * A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated
2279     * </p> 
2280         */
2281        public Slicing setDescription( String theString) {
2282                myDescription = new StringDt(theString); 
2283                return this; 
2284        }
2285
2286 
2287        /**
2288         * Gets the value(s) for <b>ordered</b> ().
2289         * creating it if it does
2290         * not exist. Will not return <code>null</code>.
2291         *
2292     * <p>
2293     * <b>Definition:</b>
2294     * If the matching elements have to occur in the same order as defined in the profile
2295     * </p> 
2296         */
2297        public BooleanDt getOrderedElement() {  
2298                if (myOrdered == null) {
2299                        myOrdered = new BooleanDt();
2300                }
2301                return myOrdered;
2302        }
2303
2304        
2305        /**
2306         * Gets the value(s) for <b>ordered</b> ().
2307         * creating it if it does
2308         * not exist. This method may return <code>null</code>.
2309         *
2310     * <p>
2311     * <b>Definition:</b>
2312     * If the matching elements have to occur in the same order as defined in the profile
2313     * </p> 
2314         */
2315        public Boolean getOrdered() {  
2316                return getOrderedElement().getValue();
2317        }
2318
2319        /**
2320         * Sets the value(s) for <b>ordered</b> ()
2321         *
2322     * <p>
2323     * <b>Definition:</b>
2324     * If the matching elements have to occur in the same order as defined in the profile
2325     * </p> 
2326         */
2327        public Slicing setOrdered(BooleanDt theValue) {
2328                myOrdered = theValue;
2329                return this;
2330        }
2331        
2332        
2333
2334        /**
2335         * Sets the value for <b>ordered</b> ()
2336         *
2337     * <p>
2338     * <b>Definition:</b>
2339     * If the matching elements have to occur in the same order as defined in the profile
2340     * </p> 
2341         */
2342        public Slicing setOrdered( boolean theBoolean) {
2343                myOrdered = new BooleanDt(theBoolean); 
2344                return this; 
2345        }
2346
2347 
2348        /**
2349         * Gets the value(s) for <b>rules</b> ().
2350         * creating it if it does
2351         * not exist. Will not return <code>null</code>.
2352         *
2353     * <p>
2354     * <b>Definition:</b>
2355     * Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end
2356     * </p> 
2357         */
2358        public BoundCodeDt<SlicingRulesEnum> getRulesElement() {  
2359                if (myRules == null) {
2360                        myRules = new BoundCodeDt<SlicingRulesEnum>(SlicingRulesEnum.VALUESET_BINDER);
2361                }
2362                return myRules;
2363        }
2364
2365        
2366        /**
2367         * Gets the value(s) for <b>rules</b> ().
2368         * creating it if it does
2369         * not exist. This method may return <code>null</code>.
2370         *
2371     * <p>
2372     * <b>Definition:</b>
2373     * Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end
2374     * </p> 
2375         */
2376        public String getRules() {  
2377                return getRulesElement().getValue();
2378        }
2379
2380        /**
2381         * Sets the value(s) for <b>rules</b> ()
2382         *
2383     * <p>
2384     * <b>Definition:</b>
2385     * Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end
2386     * </p> 
2387         */
2388        public Slicing setRules(BoundCodeDt<SlicingRulesEnum> theValue) {
2389                myRules = theValue;
2390                return this;
2391        }
2392        
2393        
2394
2395        /**
2396         * Sets the value(s) for <b>rules</b> ()
2397         *
2398     * <p>
2399     * <b>Definition:</b>
2400     * Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end
2401     * </p> 
2402         */
2403        public Slicing setRules(SlicingRulesEnum theValue) {
2404                setRules(new BoundCodeDt<SlicingRulesEnum>(SlicingRulesEnum.VALUESET_BINDER, theValue));
2405                
2406/*
2407                getRulesElement().setValueAsEnum(theValue);
2408*/
2409                return this;
2410        }
2411
2412  
2413
2414
2415        }
2416
2417
2418        /**
2419         * Block class for child element: <b>ElementDefinition.base</b> ()
2420         *
2421     * <p>
2422     * <b>Definition:</b>
2423     * Information about the base definition of the element, provided to make it unncessary for tools to trace the deviation of the element through the derived and related profiles. This information is only provided where the element definition represents a constraint on another element definition, and must be present if there is a base element definition.
2424     * </p> 
2425         */
2426        @Block()        
2427        public static class Base 
2428            extends  BaseIdentifiableElement        implements IResourceBlock {
2429        
2430        @Child(name="path", type=StringDt.class, order=0, min=1, max=1, summary=true, modifier=false)   
2431        @Description(
2432                shortDefinition="",
2433                formalDefinition="The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [[[StructureDefinition]]] without a StructureDefinition.base"
2434        )
2435        private StringDt myPath;
2436        
2437        @Child(name="min", type=IntegerDt.class, order=1, min=1, max=1, summary=true, modifier=false)   
2438        @Description(
2439                shortDefinition="",
2440                formalDefinition="Minimum cardinality of the base element identified by the path"
2441        )
2442        private IntegerDt myMin;
2443        
2444        @Child(name="max", type=StringDt.class, order=2, min=1, max=1, summary=true, modifier=false)    
2445        @Description(
2446                shortDefinition="",
2447                formalDefinition="Maximum cardinality of the base element identified by the path"
2448        )
2449        private StringDt myMax;
2450        
2451
2452        @Override
2453        public boolean isEmpty() {
2454                return super.isBaseEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(  myPath,  myMin,  myMax);
2455        }
2456        
2457        @Override
2458        public <T extends IElement> List<T> getAllPopulatedChildElementsOfType(Class<T> theType) {
2459                return ca.uhn.fhir.util.ElementUtil.allPopulatedChildElements(theType, myPath, myMin, myMax);
2460        }
2461
2462        /**
2463         * Gets the value(s) for <b>path</b> ().
2464         * creating it if it does
2465         * not exist. Will not return <code>null</code>.
2466         *
2467     * <p>
2468     * <b>Definition:</b>
2469     * The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [[[StructureDefinition]]] without a StructureDefinition.base
2470     * </p> 
2471         */
2472        public StringDt getPathElement() {  
2473                if (myPath == null) {
2474                        myPath = new StringDt();
2475                }
2476                return myPath;
2477        }
2478
2479        
2480        /**
2481         * Gets the value(s) for <b>path</b> ().
2482         * creating it if it does
2483         * not exist. This method may return <code>null</code>.
2484         *
2485     * <p>
2486     * <b>Definition:</b>
2487     * The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [[[StructureDefinition]]] without a StructureDefinition.base
2488     * </p> 
2489         */
2490        public String getPath() {  
2491                return getPathElement().getValue();
2492        }
2493
2494        /**
2495         * Sets the value(s) for <b>path</b> ()
2496         *
2497     * <p>
2498     * <b>Definition:</b>
2499     * The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [[[StructureDefinition]]] without a StructureDefinition.base
2500     * </p> 
2501         */
2502        public Base setPath(StringDt theValue) {
2503                myPath = theValue;
2504                return this;
2505        }
2506        
2507        
2508
2509        /**
2510         * Sets the value for <b>path</b> ()
2511         *
2512     * <p>
2513     * <b>Definition:</b>
2514     * The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [[[StructureDefinition]]] without a StructureDefinition.base
2515     * </p> 
2516         */
2517        public Base setPath( String theString) {
2518                myPath = new StringDt(theString); 
2519                return this; 
2520        }
2521
2522 
2523        /**
2524         * Gets the value(s) for <b>min</b> ().
2525         * creating it if it does
2526         * not exist. Will not return <code>null</code>.
2527         *
2528     * <p>
2529     * <b>Definition:</b>
2530     * Minimum cardinality of the base element identified by the path
2531     * </p> 
2532         */
2533        public IntegerDt getMinElement() {  
2534                if (myMin == null) {
2535                        myMin = new IntegerDt();
2536                }
2537                return myMin;
2538        }
2539
2540        
2541        /**
2542         * Gets the value(s) for <b>min</b> ().
2543         * creating it if it does
2544         * not exist. This method may return <code>null</code>.
2545         *
2546     * <p>
2547     * <b>Definition:</b>
2548     * Minimum cardinality of the base element identified by the path
2549     * </p> 
2550         */
2551        public Integer getMin() {  
2552                return getMinElement().getValue();
2553        }
2554
2555        /**
2556         * Sets the value(s) for <b>min</b> ()
2557         *
2558     * <p>
2559     * <b>Definition:</b>
2560     * Minimum cardinality of the base element identified by the path
2561     * </p> 
2562         */
2563        public Base setMin(IntegerDt theValue) {
2564                myMin = theValue;
2565                return this;
2566        }
2567        
2568        
2569
2570        /**
2571         * Sets the value for <b>min</b> ()
2572         *
2573     * <p>
2574     * <b>Definition:</b>
2575     * Minimum cardinality of the base element identified by the path
2576     * </p> 
2577         */
2578        public Base setMin( int theInteger) {
2579                myMin = new IntegerDt(theInteger); 
2580                return this; 
2581        }
2582
2583 
2584        /**
2585         * Gets the value(s) for <b>max</b> ().
2586         * creating it if it does
2587         * not exist. Will not return <code>null</code>.
2588         *
2589     * <p>
2590     * <b>Definition:</b>
2591     * Maximum cardinality of the base element identified by the path
2592     * </p> 
2593         */
2594        public StringDt getMaxElement() {  
2595                if (myMax == null) {
2596                        myMax = new StringDt();
2597                }
2598                return myMax;
2599        }
2600
2601        
2602        /**
2603         * Gets the value(s) for <b>max</b> ().
2604         * creating it if it does
2605         * not exist. This method may return <code>null</code>.
2606         *
2607     * <p>
2608     * <b>Definition:</b>
2609     * Maximum cardinality of the base element identified by the path
2610     * </p> 
2611         */
2612        public String getMax() {  
2613                return getMaxElement().getValue();
2614        }
2615
2616        /**
2617         * Sets the value(s) for <b>max</b> ()
2618         *
2619     * <p>
2620     * <b>Definition:</b>
2621     * Maximum cardinality of the base element identified by the path
2622     * </p> 
2623         */
2624        public Base setMax(StringDt theValue) {
2625                myMax = theValue;
2626                return this;
2627        }
2628        
2629        
2630
2631        /**
2632         * Sets the value for <b>max</b> ()
2633         *
2634     * <p>
2635     * <b>Definition:</b>
2636     * Maximum cardinality of the base element identified by the path
2637     * </p> 
2638         */
2639        public Base setMax( String theString) {
2640                myMax = new StringDt(theString); 
2641                return this; 
2642        }
2643
2644 
2645
2646
2647        }
2648
2649
2650        /**
2651         * Block class for child element: <b>ElementDefinition.type</b> ()
2652         *
2653     * <p>
2654     * <b>Definition:</b>
2655     * The data type or resource that the value of this element is permitted to be
2656     * </p> 
2657         */
2658        @Block()        
2659        public static class Type 
2660            extends  BaseIdentifiableElement        implements IResourceBlock {
2661        
2662        @Child(name="code", type=CodeDt.class, order=0, min=1, max=1, summary=true, modifier=false)     
2663        @Description(
2664                shortDefinition="",
2665                formalDefinition="Name of Data type or Resource that is a(or the) type used for this element"
2666        )
2667        @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/defined-types")
2668        private CodeDt myCode;
2669        
2670        @Child(name="profile", type=UriDt.class, order=1, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false) 
2671        @Description(
2672                shortDefinition="",
2673                formalDefinition="Identifies a profile structure or implementation Guide that SHALL hold for resources or datatypes referenced as the type of this element. Can be a local reference - to another structure in this profile, or a reference to a structure in another profile. When more than one profile is specified, the content must conform to all of them. When an implementation guide is specified, the resource SHALL conform to at least one profile defined in the implementation guide"
2674        )
2675        private java.util.List<UriDt> myProfile;
2676        
2677        @Child(name="aggregation", type=CodeDt.class, order=2, min=0, max=Child.MAX_UNLIMITED, summary=true, modifier=false)    
2678        @Description(
2679                shortDefinition="",
2680                formalDefinition="If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle."
2681        )
2682        @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/resource-aggregation-mode")
2683        private java.util.List<BoundCodeDt<AggregationModeEnum>> myAggregation;
2684        
2685
2686        @Override
2687        public boolean isEmpty() {
2688                return super.isBaseEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(  myCode,  myProfile,  myAggregation);
2689        }
2690        
2691        @Override
2692        public <T extends IElement> List<T> getAllPopulatedChildElementsOfType(Class<T> theType) {
2693                return ca.uhn.fhir.util.ElementUtil.allPopulatedChildElements(theType, myCode, myProfile, myAggregation);
2694        }
2695
2696        /**
2697         * Gets the value(s) for <b>code</b> ().
2698         * creating it if it does
2699         * not exist. Will not return <code>null</code>.
2700         *
2701     * <p>
2702     * <b>Definition:</b>
2703     * Name of Data type or Resource that is a(or the) type used for this element
2704     * </p> 
2705         */
2706        public CodeDt getCodeElement() {  
2707                if (myCode == null) {
2708                        myCode = new CodeDt();
2709                }
2710                return myCode;
2711        }
2712
2713        
2714        /**
2715         * Gets the value(s) for <b>code</b> ().
2716         * creating it if it does
2717         * not exist. This method may return <code>null</code>.
2718         *
2719     * <p>
2720     * <b>Definition:</b>
2721     * Name of Data type or Resource that is a(or the) type used for this element
2722     * </p> 
2723         */
2724        public String getCode() {  
2725                return getCodeElement().getValue();
2726        }
2727
2728        /**
2729         * Sets the value(s) for <b>code</b> ()
2730         *
2731     * <p>
2732     * <b>Definition:</b>
2733     * Name of Data type or Resource that is a(or the) type used for this element
2734     * </p> 
2735         */
2736        public Type setCode(CodeDt theValue) {
2737                myCode = theValue;
2738                return this;
2739        }
2740        
2741        
2742
2743        /**
2744         * Sets the value for <b>code</b> ()
2745         *
2746     * <p>
2747     * <b>Definition:</b>
2748     * Name of Data type or Resource that is a(or the) type used for this element
2749     * </p> 
2750         */
2751        public Type setCode( String theCode) {
2752                myCode = new CodeDt(theCode); 
2753                return this; 
2754        }
2755
2756 
2757        /**
2758         * Gets the value(s) for <b>profile</b> ().
2759         * creating it if it does
2760         * not exist. Will not return <code>null</code>.
2761         *
2762     * <p>
2763     * <b>Definition:</b>
2764     * Identifies a profile structure or implementation Guide that SHALL hold for resources or datatypes referenced as the type of this element. Can be a local reference - to another structure in this profile, or a reference to a structure in another profile. When more than one profile is specified, the content must conform to all of them. When an implementation guide is specified, the resource SHALL conform to at least one profile defined in the implementation guide
2765     * </p> 
2766         */
2767        public java.util.List<UriDt> getProfile() {  
2768                if (myProfile == null) {
2769                        myProfile = new java.util.ArrayList<UriDt>();
2770                }
2771                return myProfile;
2772        }
2773
2774        /**
2775         * Sets the value(s) for <b>profile</b> ()
2776         *
2777     * <p>
2778     * <b>Definition:</b>
2779     * Identifies a profile structure or implementation Guide that SHALL hold for resources or datatypes referenced as the type of this element. Can be a local reference - to another structure in this profile, or a reference to a structure in another profile. When more than one profile is specified, the content must conform to all of them. When an implementation guide is specified, the resource SHALL conform to at least one profile defined in the implementation guide
2780     * </p> 
2781         */
2782        public Type setProfile(java.util.List<UriDt> theValue) {
2783                myProfile = theValue;
2784                return this;
2785        }
2786        
2787        
2788
2789        /**
2790         * Adds and returns a new value for <b>profile</b> ()
2791         *
2792     * <p>
2793     * <b>Definition:</b>
2794     * Identifies a profile structure or implementation Guide that SHALL hold for resources or datatypes referenced as the type of this element. Can be a local reference - to another structure in this profile, or a reference to a structure in another profile. When more than one profile is specified, the content must conform to all of them. When an implementation guide is specified, the resource SHALL conform to at least one profile defined in the implementation guide
2795     * </p> 
2796         */
2797        public UriDt addProfile() {
2798                UriDt newType = new UriDt();
2799                getProfile().add(newType);
2800                return newType; 
2801        }
2802
2803        /**
2804         * Adds a given new value for <b>profile</b> ()
2805         *
2806         * <p>
2807         * <b>Definition:</b>
2808         * Identifies a profile structure or implementation Guide that SHALL hold for resources or datatypes referenced as the type of this element. Can be a local reference - to another structure in this profile, or a reference to a structure in another profile. When more than one profile is specified, the content must conform to all of them. When an implementation guide is specified, the resource SHALL conform to at least one profile defined in the implementation guide
2809         * </p>
2810         * @param theValue The profile to add (must not be <code>null</code>)
2811         */
2812        public Type addProfile(UriDt theValue) {
2813                if (theValue == null) {
2814                        throw new NullPointerException("theValue must not be null");
2815                }
2816                getProfile().add(theValue);
2817                return this;
2818        }
2819
2820        /**
2821         * Gets the first repetition for <b>profile</b> (),
2822         * creating it if it does not already exist.
2823         *
2824     * <p>
2825     * <b>Definition:</b>
2826     * Identifies a profile structure or implementation Guide that SHALL hold for resources or datatypes referenced as the type of this element. Can be a local reference - to another structure in this profile, or a reference to a structure in another profile. When more than one profile is specified, the content must conform to all of them. When an implementation guide is specified, the resource SHALL conform to at least one profile defined in the implementation guide
2827     * </p> 
2828         */
2829        public UriDt getProfileFirstRep() {
2830                if (getProfile().isEmpty()) {
2831                        return addProfile();
2832                }
2833                return getProfile().get(0); 
2834        }
2835        /**
2836         * Adds a new value for <b>profile</b> ()
2837         *
2838     * <p>
2839     * <b>Definition:</b>
2840     * Identifies a profile structure or implementation Guide that SHALL hold for resources or datatypes referenced as the type of this element. Can be a local reference - to another structure in this profile, or a reference to a structure in another profile. When more than one profile is specified, the content must conform to all of them. When an implementation guide is specified, the resource SHALL conform to at least one profile defined in the implementation guide
2841     * </p> 
2842     *
2843     * @return Returns a reference to this object, to allow for simple chaining.
2844         */
2845        public Type addProfile( String theUri) {
2846                if (myProfile == null) {
2847                        myProfile = new java.util.ArrayList<UriDt>();
2848                }
2849                myProfile.add(new UriDt(theUri));
2850                return this; 
2851        }
2852
2853 
2854        /**
2855         * Gets the value(s) for <b>aggregation</b> ().
2856         * creating it if it does
2857         * not exist. Will not return <code>null</code>.
2858         *
2859     * <p>
2860     * <b>Definition:</b>
2861     * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.
2862     * </p> 
2863         */
2864        public java.util.List<BoundCodeDt<AggregationModeEnum>> getAggregation() {  
2865                if (myAggregation == null) {
2866                        myAggregation = new java.util.ArrayList<BoundCodeDt<AggregationModeEnum>>();
2867                }
2868                return myAggregation;
2869        }
2870
2871        /**
2872         * Sets the value(s) for <b>aggregation</b> ()
2873         *
2874     * <p>
2875     * <b>Definition:</b>
2876     * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.
2877     * </p> 
2878         */
2879        public Type setAggregation(java.util.List<BoundCodeDt<AggregationModeEnum>> theValue) {
2880                myAggregation = theValue;
2881                return this;
2882        }
2883        
2884        
2885
2886        /**
2887         * Add a value for <b>aggregation</b> () using an enumerated type. This
2888         * is intended as a convenience method for situations where the FHIR defined ValueSets are mandatory
2889         * or contain the desirable codes. If you wish to use codes other than those which are built-in, 
2890         * you may also use the {@link #addAggregation()} method.
2891         *
2892     * <p>
2893     * <b>Definition:</b>
2894     * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.
2895     * </p> 
2896         */
2897        public BoundCodeDt<AggregationModeEnum> addAggregation(AggregationModeEnum theValue) {
2898                BoundCodeDt<AggregationModeEnum> retVal = new BoundCodeDt<AggregationModeEnum>(AggregationModeEnum.VALUESET_BINDER, theValue);
2899                getAggregation().add(retVal);
2900                return retVal;
2901        }
2902
2903        /**
2904         * Gets the first repetition for <b>aggregation</b> (),
2905         * creating it if it does not already exist.
2906         *
2907     * <p>
2908     * <b>Definition:</b>
2909     * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.
2910     * </p> 
2911         */
2912        public BoundCodeDt<AggregationModeEnum> getAggregationFirstRep() {
2913                if (getAggregation().size() == 0) {
2914                        addAggregation();
2915                }
2916                return getAggregation().get(0);
2917        }
2918
2919        /**
2920         * Add a value for <b>aggregation</b> ()
2921         *
2922     * <p>
2923     * <b>Definition:</b>
2924     * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.
2925     * </p> 
2926         */
2927        public BoundCodeDt<AggregationModeEnum> addAggregation() {
2928                BoundCodeDt<AggregationModeEnum> retVal = new BoundCodeDt<AggregationModeEnum>(AggregationModeEnum.VALUESET_BINDER);
2929                getAggregation().add(retVal);
2930                return retVal;
2931        }
2932
2933        /**
2934         * Sets the value(s), and clears any existing value(s) for <b>aggregation</b> ()
2935         *
2936     * <p>
2937     * <b>Definition:</b>
2938     * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.
2939     * </p> 
2940         */
2941        public Type setAggregation(AggregationModeEnum theValue) {
2942                getAggregation().clear();
2943                addAggregation(theValue);
2944                return this;
2945        }
2946
2947  
2948
2949
2950        }
2951
2952
2953        /**
2954         * Block class for child element: <b>ElementDefinition.constraint</b> ()
2955         *
2956     * <p>
2957     * <b>Definition:</b>
2958     * Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance
2959     * </p> 
2960         */
2961        @Block()        
2962        public static class Constraint 
2963            extends  BaseIdentifiableElement        implements IResourceBlock {
2964        
2965        @Child(name="key", type=IdDt.class, order=0, min=1, max=1, summary=true, modifier=false)        
2966        @Description(
2967                shortDefinition="",
2968                formalDefinition="Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality"
2969        )
2970        private IdDt myKey;
2971        
2972        @Child(name="requirements", type=StringDt.class, order=1, min=0, max=1, summary=true, modifier=false)   
2973        @Description(
2974                shortDefinition="",
2975                formalDefinition="Description of why this constraint is necessary or appropriate"
2976        )
2977        private StringDt myRequirements;
2978        
2979        @Child(name="severity", type=CodeDt.class, order=2, min=1, max=1, summary=true, modifier=false) 
2980        @Description(
2981                shortDefinition="",
2982                formalDefinition="Identifies the impact constraint violation has on the conformance of the instance"
2983        )
2984        @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/constraint-severity")
2985        private BoundCodeDt<ConstraintSeverityEnum> mySeverity;
2986        
2987        @Child(name="human", type=StringDt.class, order=3, min=1, max=1, summary=true, modifier=false)  
2988        @Description(
2989                shortDefinition="",
2990                formalDefinition="Text that can be used to describe the constraint in messages identifying that the constraint has been violated"
2991        )
2992        private StringDt myHuman;
2993        
2994        @Child(name="xpath", type=StringDt.class, order=4, min=1, max=1, summary=true, modifier=false)  
2995        @Description(
2996                shortDefinition="",
2997                formalDefinition="An XPath expression of constraint that can be executed to see if this constraint is met"
2998        )
2999        private StringDt myXpath;
3000        
3001
3002        @Override
3003        public boolean isEmpty() {
3004                return super.isBaseEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(  myKey,  myRequirements,  mySeverity,  myHuman,  myXpath);
3005        }
3006        
3007        @Override
3008        public <T extends IElement> List<T> getAllPopulatedChildElementsOfType(Class<T> theType) {
3009                return ca.uhn.fhir.util.ElementUtil.allPopulatedChildElements(theType, myKey, myRequirements, mySeverity, myHuman, myXpath);
3010        }
3011
3012        /**
3013         * Gets the value(s) for <b>key</b> ().
3014         * creating it if it does
3015         * not exist. Will not return <code>null</code>.
3016         *
3017     * <p>
3018     * <b>Definition:</b>
3019     * Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality
3020     * </p> 
3021         */
3022        public IdDt getKeyElement() {  
3023                if (myKey == null) {
3024                        myKey = new IdDt();
3025                }
3026                return myKey;
3027        }
3028
3029        
3030        /**
3031         * Gets the value(s) for <b>key</b> ().
3032         * creating it if it does
3033         * not exist. This method may return <code>null</code>.
3034         *
3035     * <p>
3036     * <b>Definition:</b>
3037     * Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality
3038     * </p> 
3039         */
3040        public String getKey() {  
3041                return getKeyElement().getValue();
3042        }
3043
3044        /**
3045         * Sets the value(s) for <b>key</b> ()
3046         *
3047     * <p>
3048     * <b>Definition:</b>
3049     * Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality
3050     * </p> 
3051         */
3052        public Constraint setKey(IdDt theValue) {
3053                myKey = theValue;
3054                return this;
3055        }
3056        
3057        
3058
3059        /**
3060         * Sets the value for <b>key</b> ()
3061         *
3062     * <p>
3063     * <b>Definition:</b>
3064     * Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality
3065     * </p> 
3066         */
3067        public Constraint setKey( String theId) {
3068                myKey = new IdDt(theId); 
3069                return this; 
3070        }
3071
3072 
3073        /**
3074         * Gets the value(s) for <b>requirements</b> ().
3075         * creating it if it does
3076         * not exist. Will not return <code>null</code>.
3077         *
3078     * <p>
3079     * <b>Definition:</b>
3080     * Description of why this constraint is necessary or appropriate
3081     * </p> 
3082         */
3083        public StringDt getRequirementsElement() {  
3084                if (myRequirements == null) {
3085                        myRequirements = new StringDt();
3086                }
3087                return myRequirements;
3088        }
3089
3090        
3091        /**
3092         * Gets the value(s) for <b>requirements</b> ().
3093         * creating it if it does
3094         * not exist. This method may return <code>null</code>.
3095         *
3096     * <p>
3097     * <b>Definition:</b>
3098     * Description of why this constraint is necessary or appropriate
3099     * </p> 
3100         */
3101        public String getRequirements() {  
3102                return getRequirementsElement().getValue();
3103        }
3104
3105        /**
3106         * Sets the value(s) for <b>requirements</b> ()
3107         *
3108     * <p>
3109     * <b>Definition:</b>
3110     * Description of why this constraint is necessary or appropriate
3111     * </p> 
3112         */
3113        public Constraint setRequirements(StringDt theValue) {
3114                myRequirements = theValue;
3115                return this;
3116        }
3117        
3118        
3119
3120        /**
3121         * Sets the value for <b>requirements</b> ()
3122         *
3123     * <p>
3124     * <b>Definition:</b>
3125     * Description of why this constraint is necessary or appropriate
3126     * </p> 
3127         */
3128        public Constraint setRequirements( String theString) {
3129                myRequirements = new StringDt(theString); 
3130                return this; 
3131        }
3132
3133 
3134        /**
3135         * Gets the value(s) for <b>severity</b> ().
3136         * creating it if it does
3137         * not exist. Will not return <code>null</code>.
3138         *
3139     * <p>
3140     * <b>Definition:</b>
3141     * Identifies the impact constraint violation has on the conformance of the instance
3142     * </p> 
3143         */
3144        public BoundCodeDt<ConstraintSeverityEnum> getSeverityElement() {  
3145                if (mySeverity == null) {
3146                        mySeverity = new BoundCodeDt<ConstraintSeverityEnum>(ConstraintSeverityEnum.VALUESET_BINDER);
3147                }
3148                return mySeverity;
3149        }
3150
3151        
3152        /**
3153         * Gets the value(s) for <b>severity</b> ().
3154         * creating it if it does
3155         * not exist. This method may return <code>null</code>.
3156         *
3157     * <p>
3158     * <b>Definition:</b>
3159     * Identifies the impact constraint violation has on the conformance of the instance
3160     * </p> 
3161         */
3162        public String getSeverity() {  
3163                return getSeverityElement().getValue();
3164        }
3165
3166        /**
3167         * Sets the value(s) for <b>severity</b> ()
3168         *
3169     * <p>
3170     * <b>Definition:</b>
3171     * Identifies the impact constraint violation has on the conformance of the instance
3172     * </p> 
3173         */
3174        public Constraint setSeverity(BoundCodeDt<ConstraintSeverityEnum> theValue) {
3175                mySeverity = theValue;
3176                return this;
3177        }
3178        
3179        
3180
3181        /**
3182         * Sets the value(s) for <b>severity</b> ()
3183         *
3184     * <p>
3185     * <b>Definition:</b>
3186     * Identifies the impact constraint violation has on the conformance of the instance
3187     * </p> 
3188         */
3189        public Constraint setSeverity(ConstraintSeverityEnum theValue) {
3190                setSeverity(new BoundCodeDt<ConstraintSeverityEnum>(ConstraintSeverityEnum.VALUESET_BINDER, theValue));
3191                
3192/*
3193                getSeverityElement().setValueAsEnum(theValue);
3194*/
3195                return this;
3196        }
3197
3198  
3199        /**
3200         * Gets the value(s) for <b>human</b> ().
3201         * creating it if it does
3202         * not exist. Will not return <code>null</code>.
3203         *
3204     * <p>
3205     * <b>Definition:</b>
3206     * Text that can be used to describe the constraint in messages identifying that the constraint has been violated
3207     * </p> 
3208         */
3209        public StringDt getHumanElement() {  
3210                if (myHuman == null) {
3211                        myHuman = new StringDt();
3212                }
3213                return myHuman;
3214        }
3215
3216        
3217        /**
3218         * Gets the value(s) for <b>human</b> ().
3219         * creating it if it does
3220         * not exist. This method may return <code>null</code>.
3221         *
3222     * <p>
3223     * <b>Definition:</b>
3224     * Text that can be used to describe the constraint in messages identifying that the constraint has been violated
3225     * </p> 
3226         */
3227        public String getHuman() {  
3228                return getHumanElement().getValue();
3229        }
3230
3231        /**
3232         * Sets the value(s) for <b>human</b> ()
3233         *
3234     * <p>
3235     * <b>Definition:</b>
3236     * Text that can be used to describe the constraint in messages identifying that the constraint has been violated
3237     * </p> 
3238         */
3239        public Constraint setHuman(StringDt theValue) {
3240                myHuman = theValue;
3241                return this;
3242        }
3243        
3244        
3245
3246        /**
3247         * Sets the value for <b>human</b> ()
3248         *
3249     * <p>
3250     * <b>Definition:</b>
3251     * Text that can be used to describe the constraint in messages identifying that the constraint has been violated
3252     * </p> 
3253         */
3254        public Constraint setHuman( String theString) {
3255                myHuman = new StringDt(theString); 
3256                return this; 
3257        }
3258
3259 
3260        /**
3261         * Gets the value(s) for <b>xpath</b> ().
3262         * creating it if it does
3263         * not exist. Will not return <code>null</code>.
3264         *
3265     * <p>
3266     * <b>Definition:</b>
3267     * An XPath expression of constraint that can be executed to see if this constraint is met
3268     * </p> 
3269         */
3270        public StringDt getXpathElement() {  
3271                if (myXpath == null) {
3272                        myXpath = new StringDt();
3273                }
3274                return myXpath;
3275        }
3276
3277        
3278        /**
3279         * Gets the value(s) for <b>xpath</b> ().
3280         * creating it if it does
3281         * not exist. This method may return <code>null</code>.
3282         *
3283     * <p>
3284     * <b>Definition:</b>
3285     * An XPath expression of constraint that can be executed to see if this constraint is met
3286     * </p> 
3287         */
3288        public String getXpath() {  
3289                return getXpathElement().getValue();
3290        }
3291
3292        /**
3293         * Sets the value(s) for <b>xpath</b> ()
3294         *
3295     * <p>
3296     * <b>Definition:</b>
3297     * An XPath expression of constraint that can be executed to see if this constraint is met
3298     * </p> 
3299         */
3300        public Constraint setXpath(StringDt theValue) {
3301                myXpath = theValue;
3302                return this;
3303        }
3304        
3305        
3306
3307        /**
3308         * Sets the value for <b>xpath</b> ()
3309         *
3310     * <p>
3311     * <b>Definition:</b>
3312     * An XPath expression of constraint that can be executed to see if this constraint is met
3313     * </p> 
3314         */
3315        public Constraint setXpath( String theString) {
3316                myXpath = new StringDt(theString); 
3317                return this; 
3318        }
3319
3320 
3321
3322
3323        }
3324
3325
3326        /**
3327         * Block class for child element: <b>ElementDefinition.binding</b> ()
3328         *
3329     * <p>
3330     * <b>Definition:</b>
3331     * Binds to a value set if this element is coded (code, Coding, CodeableConcept)
3332     * </p> 
3333         */
3334        @Block()        
3335        public static class Binding 
3336            extends  BaseIdentifiableElement        implements IResourceBlock {
3337        
3338        @Child(name="strength", type=CodeDt.class, order=0, min=1, max=1, summary=true, modifier=false) 
3339        @Description(
3340                shortDefinition="",
3341                formalDefinition="Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances"
3342        )
3343        @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/binding-strength")
3344        private BoundCodeDt<BindingStrengthEnum> myStrength;
3345        
3346        @Child(name="description", type=StringDt.class, order=1, min=0, max=1, summary=true, modifier=false)    
3347        @Description(
3348                shortDefinition="",
3349                formalDefinition="Describes the intended use of this particular set of codes"
3350        )
3351        private StringDt myDescription;
3352        
3353        @Child(name="valueSet", order=2, min=0, max=1, summary=true, modifier=false, type={
3354                UriDt.class,            ValueSet.class  })
3355        @Description(
3356                shortDefinition="",
3357                formalDefinition="Points to the value set or external definition (e.g. implicit value set) that identifies the set of codes to be used"
3358        )
3359        private IDatatype myValueSet;
3360        
3361
3362        @Override
3363        public boolean isEmpty() {
3364                return super.isBaseEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(  myStrength,  myDescription,  myValueSet);
3365        }
3366        
3367        @Override
3368        public <T extends IElement> List<T> getAllPopulatedChildElementsOfType(Class<T> theType) {
3369                return ca.uhn.fhir.util.ElementUtil.allPopulatedChildElements(theType, myStrength, myDescription, myValueSet);
3370        }
3371
3372        /**
3373         * Gets the value(s) for <b>strength</b> ().
3374         * creating it if it does
3375         * not exist. Will not return <code>null</code>.
3376         *
3377     * <p>
3378     * <b>Definition:</b>
3379     * Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances
3380     * </p> 
3381         */
3382        public BoundCodeDt<BindingStrengthEnum> getStrengthElement() {  
3383                if (myStrength == null) {
3384                        myStrength = new BoundCodeDt<BindingStrengthEnum>(BindingStrengthEnum.VALUESET_BINDER);
3385                }
3386                return myStrength;
3387        }
3388
3389        
3390        /**
3391         * Gets the value(s) for <b>strength</b> ().
3392         * creating it if it does
3393         * not exist. This method may return <code>null</code>.
3394         *
3395     * <p>
3396     * <b>Definition:</b>
3397     * Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances
3398     * </p> 
3399         */
3400        public String getStrength() {  
3401                return getStrengthElement().getValue();
3402        }
3403
3404        /**
3405         * Sets the value(s) for <b>strength</b> ()
3406         *
3407     * <p>
3408     * <b>Definition:</b>
3409     * Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances
3410     * </p> 
3411         */
3412        public Binding setStrength(BoundCodeDt<BindingStrengthEnum> theValue) {
3413                myStrength = theValue;
3414                return this;
3415        }
3416        
3417        
3418
3419        /**
3420         * Sets the value(s) for <b>strength</b> ()
3421         *
3422     * <p>
3423     * <b>Definition:</b>
3424     * Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances
3425     * </p> 
3426         */
3427        public Binding setStrength(BindingStrengthEnum theValue) {
3428                setStrength(new BoundCodeDt<BindingStrengthEnum>(BindingStrengthEnum.VALUESET_BINDER, theValue));
3429                
3430/*
3431                getStrengthElement().setValueAsEnum(theValue);
3432*/
3433                return this;
3434        }
3435
3436  
3437        /**
3438         * Gets the value(s) for <b>description</b> ().
3439         * creating it if it does
3440         * not exist. Will not return <code>null</code>.
3441         *
3442     * <p>
3443     * <b>Definition:</b>
3444     * Describes the intended use of this particular set of codes
3445     * </p> 
3446         */
3447        public StringDt getDescriptionElement() {  
3448                if (myDescription == null) {
3449                        myDescription = new StringDt();
3450                }
3451                return myDescription;
3452        }
3453
3454        
3455        /**
3456         * Gets the value(s) for <b>description</b> ().
3457         * creating it if it does
3458         * not exist. This method may return <code>null</code>.
3459         *
3460     * <p>
3461     * <b>Definition:</b>
3462     * Describes the intended use of this particular set of codes
3463     * </p> 
3464         */
3465        public String getDescription() {  
3466                return getDescriptionElement().getValue();
3467        }
3468
3469        /**
3470         * Sets the value(s) for <b>description</b> ()
3471         *
3472     * <p>
3473     * <b>Definition:</b>
3474     * Describes the intended use of this particular set of codes
3475     * </p> 
3476         */
3477        public Binding setDescription(StringDt theValue) {
3478                myDescription = theValue;
3479                return this;
3480        }
3481        
3482        
3483
3484        /**
3485         * Sets the value for <b>description</b> ()
3486         *
3487     * <p>
3488     * <b>Definition:</b>
3489     * Describes the intended use of this particular set of codes
3490     * </p> 
3491         */
3492        public Binding setDescription( String theString) {
3493                myDescription = new StringDt(theString); 
3494                return this; 
3495        }
3496
3497 
3498        /**
3499         * Gets the value(s) for <b>valueSet[x]</b> ().
3500         * creating it if it does
3501         * not exist. Will not return <code>null</code>.
3502         *
3503     * <p>
3504     * <b>Definition:</b>
3505     * Points to the value set or external definition (e.g. implicit value set) that identifies the set of codes to be used
3506     * </p> 
3507         */
3508        public IDatatype getValueSet() {  
3509                return myValueSet;
3510        }
3511
3512        /**
3513         * Sets the value(s) for <b>valueSet[x]</b> ()
3514         *
3515     * <p>
3516     * <b>Definition:</b>
3517     * Points to the value set or external definition (e.g. implicit value set) that identifies the set of codes to be used
3518     * </p> 
3519         */
3520        public Binding setValueSet(IDatatype theValue) {
3521                myValueSet = theValue;
3522                return this;
3523        }
3524        
3525        
3526
3527  
3528
3529
3530        }
3531
3532
3533        /**
3534         * Block class for child element: <b>ElementDefinition.mapping</b> ()
3535         *
3536     * <p>
3537     * <b>Definition:</b>
3538     * Identifies a concept from an external specification that roughly corresponds to this element
3539     * </p> 
3540         */
3541        @Block()        
3542        public static class Mapping 
3543            extends  BaseIdentifiableElement        implements IResourceBlock {
3544        
3545        @Child(name="identity", type=IdDt.class, order=0, min=1, max=1, summary=true, modifier=false)   
3546        @Description(
3547                shortDefinition="",
3548                formalDefinition="An internal reference to the definition of a mapping"
3549        )
3550        private IdDt myIdentity;
3551        
3552        @Child(name="language", type=CodeDt.class, order=1, min=0, max=1, summary=true, modifier=false) 
3553        @Description(
3554                shortDefinition="",
3555                formalDefinition="Identifies the computable language in which mapping.map is expressed."
3556        )
3557        private CodeDt myLanguage;
3558        
3559        @Child(name="map", type=StringDt.class, order=2, min=1, max=1, summary=true, modifier=false)    
3560        @Description(
3561                shortDefinition="",
3562                formalDefinition="Expresses what part of the target specification corresponds to this element"
3563        )
3564        private StringDt myMap;
3565        
3566
3567        @Override
3568        public boolean isEmpty() {
3569                return super.isBaseEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(  myIdentity,  myLanguage,  myMap);
3570        }
3571        
3572        @Override
3573        public <T extends IElement> List<T> getAllPopulatedChildElementsOfType(Class<T> theType) {
3574                return ca.uhn.fhir.util.ElementUtil.allPopulatedChildElements(theType, myIdentity, myLanguage, myMap);
3575        }
3576
3577        /**
3578         * Gets the value(s) for <b>identity</b> ().
3579         * creating it if it does
3580         * not exist. Will not return <code>null</code>.
3581         *
3582     * <p>
3583     * <b>Definition:</b>
3584     * An internal reference to the definition of a mapping
3585     * </p> 
3586         */
3587        public IdDt getIdentityElement() {  
3588                if (myIdentity == null) {
3589                        myIdentity = new IdDt();
3590                }
3591                return myIdentity;
3592        }
3593
3594        
3595        /**
3596         * Gets the value(s) for <b>identity</b> ().
3597         * creating it if it does
3598         * not exist. This method may return <code>null</code>.
3599         *
3600     * <p>
3601     * <b>Definition:</b>
3602     * An internal reference to the definition of a mapping
3603     * </p> 
3604         */
3605        public String getIdentity() {  
3606                return getIdentityElement().getValue();
3607        }
3608
3609        /**
3610         * Sets the value(s) for <b>identity</b> ()
3611         *
3612     * <p>
3613     * <b>Definition:</b>
3614     * An internal reference to the definition of a mapping
3615     * </p> 
3616         */
3617        public Mapping setIdentity(IdDt theValue) {
3618                myIdentity = theValue;
3619                return this;
3620        }
3621        
3622        
3623
3624        /**
3625         * Sets the value for <b>identity</b> ()
3626         *
3627     * <p>
3628     * <b>Definition:</b>
3629     * An internal reference to the definition of a mapping
3630     * </p> 
3631         */
3632        public Mapping setIdentity( String theId) {
3633                myIdentity = new IdDt(theId); 
3634                return this; 
3635        }
3636
3637 
3638        /**
3639         * Gets the value(s) for <b>language</b> ().
3640         * creating it if it does
3641         * not exist. Will not return <code>null</code>.
3642         *
3643     * <p>
3644     * <b>Definition:</b>
3645     * Identifies the computable language in which mapping.map is expressed.
3646     * </p> 
3647         */
3648        public CodeDt getLanguageElement() {  
3649                if (myLanguage == null) {
3650                        myLanguage = new CodeDt();
3651                }
3652                return myLanguage;
3653        }
3654
3655        
3656        /**
3657         * Gets the value(s) for <b>language</b> ().
3658         * creating it if it does
3659         * not exist. This method may return <code>null</code>.
3660         *
3661     * <p>
3662     * <b>Definition:</b>
3663     * Identifies the computable language in which mapping.map is expressed.
3664     * </p> 
3665         */
3666        public String getLanguage() {  
3667                return getLanguageElement().getValue();
3668        }
3669
3670        /**
3671         * Sets the value(s) for <b>language</b> ()
3672         *
3673     * <p>
3674     * <b>Definition:</b>
3675     * Identifies the computable language in which mapping.map is expressed.
3676     * </p> 
3677         */
3678        public Mapping setLanguage(CodeDt theValue) {
3679                myLanguage = theValue;
3680                return this;
3681        }
3682        
3683        
3684
3685        /**
3686         * Sets the value for <b>language</b> ()
3687         *
3688     * <p>
3689     * <b>Definition:</b>
3690     * Identifies the computable language in which mapping.map is expressed.
3691     * </p> 
3692         */
3693        public Mapping setLanguage( String theCode) {
3694                myLanguage = new CodeDt(theCode); 
3695                return this; 
3696        }
3697
3698 
3699        /**
3700         * Gets the value(s) for <b>map</b> ().
3701         * creating it if it does
3702         * not exist. Will not return <code>null</code>.
3703         *
3704     * <p>
3705     * <b>Definition:</b>
3706     * Expresses what part of the target specification corresponds to this element
3707     * </p> 
3708         */
3709        public StringDt getMapElement() {  
3710                if (myMap == null) {
3711                        myMap = new StringDt();
3712                }
3713                return myMap;
3714        }
3715
3716        
3717        /**
3718         * Gets the value(s) for <b>map</b> ().
3719         * creating it if it does
3720         * not exist. This method may return <code>null</code>.
3721         *
3722     * <p>
3723     * <b>Definition:</b>
3724     * Expresses what part of the target specification corresponds to this element
3725     * </p> 
3726         */
3727        public String getMap() {  
3728                return getMapElement().getValue();
3729        }
3730
3731        /**
3732         * Sets the value(s) for <b>map</b> ()
3733         *
3734     * <p>
3735     * <b>Definition:</b>
3736     * Expresses what part of the target specification corresponds to this element
3737     * </p> 
3738         */
3739        public Mapping setMap(StringDt theValue) {
3740                myMap = theValue;
3741                return this;
3742        }
3743        
3744        
3745
3746        /**
3747         * Sets the value for <b>map</b> ()
3748         *
3749     * <p>
3750     * <b>Definition:</b>
3751     * Expresses what part of the target specification corresponds to this element
3752     * </p> 
3753         */
3754        public Mapping setMap( String theString) {
3755                myMap = new StringDt(theString); 
3756                return this; 
3757        }
3758
3759 
3760
3761
3762        }
3763
3764
3765
3766
3767}