001package org.hl7.fhir.dstu3.formats;
002
003
004
005
006/*
007  Copyright (c) 2011+, HL7, Inc.
008  All rights reserved.
009  
010  Redistribution and use in source and binary forms, with or without modification, 
011  are permitted provided that the following conditions are met:
012  
013   * Redistributions of source code must retain the above copyright notice, this 
014     list of conditions and the following disclaimer.
015   * Redistributions in binary form must reproduce the above copyright notice, 
016     this list of conditions and the following disclaimer in the documentation 
017     and/or other materials provided with the distribution.
018   * Neither the name of HL7 nor the names of its contributors may be used to 
019     endorse or promote products derived from this software without specific 
020     prior written permission.
021  
022  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
023  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
024  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
025  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
026  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
027  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
028  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
029  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
030  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
031  POSSIBILITY OF SUCH DAMAGE.
032  
033*/
034
035// Generated on Mon, Apr 17, 2017 08:38+1000 for FHIR v3.0.x
036import org.hl7.fhir.dstu3.model.*;
037import org.hl7.fhir.dstu3.utils.formats.Turtle.Complex;
038import org.hl7.fhir.utilities.Utilities;
039
040public class RdfParser extends RdfParserBase {
041
042  public RdfParser() {
043    super();
044  }
045
046  public RdfParser(boolean allowUnknownContent) {
047    super();
048    setAllowUnknownContent(allowUnknownContent);
049  }
050
051
052  protected void composeElement(Complex t, String parentType, String name, Element element, int index) {
053    if (element == null) 
054      return;
055    if (index > -1)
056      t.predicate("fhir:index", Integer.toString(index));
057    if (element.hasIdElement())
058      composeString(t, "Element", "id", element.getIdElement(), -1);
059    for (int i = 0; i < element.getExtension().size(); i++)
060      composeExtension(t, "Element", "extension", element.getExtension().get(i), i);
061  }
062
063  protected void composeBackboneElement(Complex t, String tType, String name, BackboneElement element, int index) {
064    composeElement(t, tType, name, element, index);
065    for (int i = 0; i < element.getModifierExtension().size(); i++)
066      composeExtension(t, "Element", "modifierExtension", element.getModifierExtension().get(i), i);
067  }
068
069  private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) {
070    if (value == null)
071      return;
072    Complex t = parent.predicate("fhir:"+parentType+"."+name);
073    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
074    composeElement(t, parentType, name, value, index);
075    decorateCode(t, value);
076  }
077
078
079  protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) {
080    if (value == null)
081      return;
082    Complex t = parent.predicate("fhir:"+parentType+"."+name);
083    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
084    composeElement(t, parentType, name, value, index);
085  }
086
087  protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) {
088    if (value == null)
089      return;
090    Complex t = parent.predicate("fhir:"+parentType+"."+name);
091    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
092    composeElement(t, parentType, name, value, index);
093  }
094
095  protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) {
096    if (value == null)
097      return;
098    Complex t = parent.predicate("fhir:"+parentType+"."+name);
099    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
100    composeElement(t, parentType, name, value, index);
101    decorateCode(t, value);
102  }
103
104  protected void composeString(Complex parent, String parentType, String name, StringType value, int index) {
105    if (value == null)
106      return;
107    Complex t = parent.predicate("fhir:"+parentType+"."+name);
108    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
109    composeElement(t, parentType, name, value, index);
110  }
111
112  protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) {
113    if (value == null)
114      return;
115    Complex t = parent.predicate("fhir:"+parentType+"."+name);
116    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
117    composeElement(t, parentType, name, value, index);
118  }
119
120  protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) {
121    if (value == null)
122      return;
123    Complex t = parent.predicate("fhir:"+parentType+"."+name);
124    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
125    composeElement(t, parentType, name, value, index);
126  }
127
128  protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) {
129    if (value == null)
130      return;
131    Complex t = parent.predicate("fhir:"+parentType+"."+name);
132    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
133    composeElement(t, parentType, name, value, index);
134  }
135
136  protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) {
137    if (value == null)
138      return;
139    Complex t = parent.predicate("fhir:"+parentType+"."+name);
140    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
141    composeElement(t, parentType, name, value, index);
142  }
143
144  protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) {
145    if (value == null)
146      return;
147    Complex t = parent.predicate("fhir:"+parentType+"."+name);
148    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
149    composeElement(t, parentType, name, value, index);
150  }
151
152  protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) {
153    if (value == null)
154      return;
155    Complex t = parent.predicate("fhir:"+parentType+"."+name);
156    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
157    composeElement(t, parentType, name, value, index);
158  }
159
160  protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) {
161    if (value == null)
162      return;
163    Complex t = parent.predicate("fhir:"+parentType+"."+name);
164    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
165    composeElement(t, parentType, name, value, index);
166  }
167
168  protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) {
169    if (value == null)
170      return;
171    Complex t = parent.predicate("fhir:"+parentType+"."+name);
172    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
173    composeElement(t, parentType, name, value, index);
174  }
175
176  protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) {
177    if (value == null)
178      return;
179    Complex t = parent.predicate("fhir:"+parentType+"."+name);
180    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
181    composeElement(t, parentType, name, value, index);
182  }
183
184  protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) {
185    if (value == null)
186      return;
187    Complex t = parent.predicate("fhir:"+parentType+"."+name);
188    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
189    composeElement(t, parentType, name, value, index);
190  }
191
192  protected void composeId(Complex parent, String parentType, String name, IdType value, int index) {
193    if (value == null)
194      return;
195    Complex t = parent.predicate("fhir:"+parentType+"."+name);
196    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
197    composeElement(t, parentType, name, value, index);
198  }
199
200  protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) {
201    if (value == null)
202      return;
203    Complex t = parent.predicate("fhir:"+parentType+"."+name);
204    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
205    composeElement(t, parentType, name, value, index);
206  }
207
208  protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) {
209    if (value == null)
210      return;
211    Complex t = parent.predicate("fhir:"+parentType+"."+name);
212    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
213    composeElement(t, parentType, name, value, index);
214  }
215
216  protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) {
217    if (element == null) 
218      return;
219    Complex t;
220    if (Utilities.noString(parentType))
221      t = parent;
222    else {
223      t = parent.predicate("fhir:"+parentType+'.'+name);
224    }
225    composeElement(t, "Extension", name, element, index);
226    if (element.hasUrlElement())
227      composeUri(t, "Extension", "url", element.getUrlElement(), -1);
228    if (element.hasValue())
229      composeType(t, "Extension", "value", element.getValue(), -1);
230  }
231
232  protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) {
233    if (element == null) 
234      return;
235    Complex t;
236    if (Utilities.noString(parentType))
237      t = parent;
238    else {
239      t = parent.predicate("fhir:"+parentType+'.'+name);
240    }
241    composeElement(t, "Narrative", name, element, index);
242    if (element.hasStatusElement())
243      composeEnum(t, "Narrative", "status", element.getStatusElement(), -1);
244    if (element.hasDiv())
245      composeXhtml(t, "Narrative", "div", element.getDiv(), -1);
246  }
247
248  protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) {
249    if (element == null) 
250      return;
251    Complex t;
252    if (Utilities.noString(parentType))
253      t = parent;
254    else {
255      t = parent.predicate("fhir:"+parentType+'.'+name);
256    }
257    composeElement(t, "Reference", name, element, index);
258    if (element.hasReferenceElement())
259      composeString(t, "Reference", "reference", element.getReferenceElement_(), -1);
260    if (element.hasIdentifier())
261      composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1);
262    if (element.hasDisplayElement())
263      composeString(t, "Reference", "display", element.getDisplayElement(), -1);
264  }
265
266  protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) {
267    if (element == null) 
268      return;
269    Complex t;
270    if (Utilities.noString(parentType))
271      t = parent;
272    else {
273      t = parent.predicate("fhir:"+parentType+'.'+name);
274    }
275    composeElement(t, "Quantity", name, element, index);
276    if (element.hasValueElement())
277      composeDecimal(t, "Quantity", "value", element.getValueElement(), -1);
278    if (element.hasComparatorElement())
279      composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1);
280    if (element.hasUnitElement())
281      composeString(t, "Quantity", "unit", element.getUnitElement(), -1);
282    if (element.hasSystemElement())
283      composeUri(t, "Quantity", "system", element.getSystemElement(), -1);
284    if (element.hasCodeElement())
285      composeCode(t, "Quantity", "code", element.getCodeElement(), -1);
286  }
287
288  protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) {
289    if (element == null) 
290      return;
291    Complex t;
292    if (Utilities.noString(parentType))
293      t = parent;
294    else {
295      t = parent.predicate("fhir:"+parentType+'.'+name);
296    }
297    composeElement(t, "Period", name, element, index);
298    if (element.hasStartElement())
299      composeDateTime(t, "Period", "start", element.getStartElement(), -1);
300    if (element.hasEndElement())
301      composeDateTime(t, "Period", "end", element.getEndElement(), -1);
302  }
303
304  protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) {
305    if (element == null) 
306      return;
307    Complex t;
308    if (Utilities.noString(parentType))
309      t = parent;
310    else {
311      t = parent.predicate("fhir:"+parentType+'.'+name);
312    }
313    composeElement(t, "Attachment", name, element, index);
314    if (element.hasContentTypeElement())
315      composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1);
316    if (element.hasLanguageElement())
317      composeCode(t, "Attachment", "language", element.getLanguageElement(), -1);
318    if (element.hasDataElement())
319      composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1);
320    if (element.hasUrlElement())
321      composeUri(t, "Attachment", "url", element.getUrlElement(), -1);
322    if (element.hasSizeElement())
323      composeUnsignedInt(t, "Attachment", "size", element.getSizeElement(), -1);
324    if (element.hasHashElement())
325      composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1);
326    if (element.hasTitleElement())
327      composeString(t, "Attachment", "title", element.getTitleElement(), -1);
328    if (element.hasCreationElement())
329      composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1);
330  }
331
332  protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) {
333    if (element == null) 
334      return;
335    Complex t;
336    if (Utilities.noString(parentType))
337      t = parent;
338    else {
339      t = parent.predicate("fhir:"+parentType+'.'+name);
340    }
341    composeElement(t, "Duration", name, element, index);
342  }
343
344  protected void composeCount(Complex parent, String parentType, String name, Count element, int index) {
345    if (element == null) 
346      return;
347    Complex t;
348    if (Utilities.noString(parentType))
349      t = parent;
350    else {
351      t = parent.predicate("fhir:"+parentType+'.'+name);
352    }
353    composeElement(t, "Count", name, element, index);
354  }
355
356  protected void composeRange(Complex parent, String parentType, String name, Range element, int index) {
357    if (element == null) 
358      return;
359    Complex t;
360    if (Utilities.noString(parentType))
361      t = parent;
362    else {
363      t = parent.predicate("fhir:"+parentType+'.'+name);
364    }
365    composeElement(t, "Range", name, element, index);
366    if (element.hasLow())
367      composeQuantity(t, "Range", "low", element.getLow(), -1);
368    if (element.hasHigh())
369      composeQuantity(t, "Range", "high", element.getHigh(), -1);
370  }
371
372  protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) {
373    if (element == null) 
374      return;
375    Complex t;
376    if (Utilities.noString(parentType))
377      t = parent;
378    else {
379      t = parent.predicate("fhir:"+parentType+'.'+name);
380    }
381    composeElement(t, "Annotation", name, element, index);
382    if (element.hasAuthor())
383      composeType(t, "Annotation", "author", element.getAuthor(), -1);
384    if (element.hasTimeElement())
385      composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1);
386    if (element.hasTextElement())
387      composeString(t, "Annotation", "text", element.getTextElement(), -1);
388  }
389
390  protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) {
391    if (element == null) 
392      return;
393    Complex t;
394    if (Utilities.noString(parentType))
395      t = parent;
396    else {
397      t = parent.predicate("fhir:"+parentType+'.'+name);
398    }
399    composeElement(t, "Money", name, element, index);
400  }
401
402  protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) {
403    if (element == null) 
404      return;
405    Complex t;
406    if (Utilities.noString(parentType))
407      t = parent;
408    else {
409      t = parent.predicate("fhir:"+parentType+'.'+name);
410    }
411    composeElement(t, "Identifier", name, element, index);
412    if (element.hasUseElement())
413      composeEnum(t, "Identifier", "use", element.getUseElement(), -1);
414    if (element.hasType())
415      composeCodeableConcept(t, "Identifier", "type", element.getType(), -1);
416    if (element.hasSystemElement())
417      composeUri(t, "Identifier", "system", element.getSystemElement(), -1);
418    if (element.hasValueElement())
419      composeString(t, "Identifier", "value", element.getValueElement(), -1);
420    if (element.hasPeriod())
421      composePeriod(t, "Identifier", "period", element.getPeriod(), -1);
422    if (element.hasAssigner())
423      composeReference(t, "Identifier", "assigner", element.getAssigner(), -1);
424  }
425
426  protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) {
427    if (element == null) 
428      return;
429    Complex t;
430    if (Utilities.noString(parentType))
431      t = parent;
432    else {
433      t = parent.predicate("fhir:"+parentType+'.'+name);
434    }
435    composeElement(t, "Coding", name, element, index);
436    decorateCoding(t, element);
437    if (element.hasSystemElement())
438      composeUri(t, "Coding", "system", element.getSystemElement(), -1);
439    if (element.hasVersionElement())
440      composeString(t, "Coding", "version", element.getVersionElement(), -1);
441    if (element.hasCodeElement())
442      composeCode(t, "Coding", "code", element.getCodeElement(), -1);
443    if (element.hasDisplayElement())
444      composeString(t, "Coding", "display", element.getDisplayElement(), -1);
445    if (element.hasUserSelectedElement())
446      composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1);
447  }
448
449  protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) {
450    if (element == null) 
451      return;
452    Complex t;
453    if (Utilities.noString(parentType))
454      t = parent;
455    else {
456      t = parent.predicate("fhir:"+parentType+'.'+name);
457    }
458    composeElement(t, "Signature", name, element, index);
459    for (int i = 0; i < element.getType().size(); i++)
460      composeCoding(t, "Signature", "type", element.getType().get(i), i);
461    if (element.hasWhenElement())
462      composeInstant(t, "Signature", "when", element.getWhenElement(), -1);
463    if (element.hasWho())
464      composeType(t, "Signature", "who", element.getWho(), -1);
465    if (element.hasOnBehalfOf())
466      composeType(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1);
467    if (element.hasContentTypeElement())
468      composeCode(t, "Signature", "contentType", element.getContentTypeElement(), -1);
469    if (element.hasBlobElement())
470      composeBase64Binary(t, "Signature", "blob", element.getBlobElement(), -1);
471  }
472
473  protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) {
474    if (element == null) 
475      return;
476    Complex t;
477    if (Utilities.noString(parentType))
478      t = parent;
479    else {
480      t = parent.predicate("fhir:"+parentType+'.'+name);
481    }
482    composeElement(t, "SampledData", name, element, index);
483    if (element.hasOrigin())
484      composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1);
485    if (element.hasPeriodElement())
486      composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1);
487    if (element.hasFactorElement())
488      composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1);
489    if (element.hasLowerLimitElement())
490      composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1);
491    if (element.hasUpperLimitElement())
492      composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1);
493    if (element.hasDimensionsElement())
494      composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1);
495    if (element.hasDataElement())
496      composeString(t, "SampledData", "data", element.getDataElement(), -1);
497  }
498
499  protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) {
500    if (element == null) 
501      return;
502    Complex t;
503    if (Utilities.noString(parentType))
504      t = parent;
505    else {
506      t = parent.predicate("fhir:"+parentType+'.'+name);
507    }
508    composeElement(t, "Ratio", name, element, index);
509    if (element.hasNumerator())
510      composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1);
511    if (element.hasDenominator())
512      composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1);
513  }
514
515  protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) {
516    if (element == null) 
517      return;
518    Complex t;
519    if (Utilities.noString(parentType))
520      t = parent;
521    else {
522      t = parent.predicate("fhir:"+parentType+'.'+name);
523    }
524    composeElement(t, "Distance", name, element, index);
525  }
526
527  protected void composeAge(Complex parent, String parentType, String name, Age element, int index) {
528    if (element == null) 
529      return;
530    Complex t;
531    if (Utilities.noString(parentType))
532      t = parent;
533    else {
534      t = parent.predicate("fhir:"+parentType+'.'+name);
535    }
536    composeElement(t, "Age", name, element, index);
537  }
538
539  protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) {
540    if (element == null) 
541      return;
542    Complex t;
543    if (Utilities.noString(parentType))
544      t = parent;
545    else {
546      t = parent.predicate("fhir:"+parentType+'.'+name);
547    }
548    composeElement(t, "CodeableConcept", name, element, index);
549    decorateCodeableConcept(t, element);
550    for (int i = 0; i < element.getCoding().size(); i++)
551      composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i);
552    if (element.hasTextElement())
553      composeString(t, "CodeableConcept", "text", element.getTextElement(), -1);
554  }
555
556  protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) {
557    if (element == null) 
558      return;
559    Complex t;
560    if (Utilities.noString(parentType))
561      t = parent;
562    else {
563      t = parent.predicate("fhir:"+parentType+'.'+name);
564    }
565    composeElement(t, "Meta", name, element, index);
566    if (element.hasVersionIdElement())
567      composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1);
568    if (element.hasLastUpdatedElement())
569      composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1);
570    for (int i = 0; i < element.getProfile().size(); i++)
571      composeUri(t, "Meta", "profile", element.getProfile().get(i), i);
572    for (int i = 0; i < element.getSecurity().size(); i++)
573      composeCoding(t, "Meta", "security", element.getSecurity().get(i), i);
574    for (int i = 0; i < element.getTag().size(); i++)
575      composeCoding(t, "Meta", "tag", element.getTag().get(i), i);
576  }
577
578  protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) {
579    if (element == null) 
580      return;
581    Complex t;
582    if (Utilities.noString(parentType))
583      t = parent;
584    else {
585      t = parent.predicate("fhir:"+parentType+'.'+name);
586    }
587    composeElement(t, "Address", name, element, index);
588    if (element.hasUseElement())
589      composeEnum(t, "Address", "use", element.getUseElement(), -1);
590    if (element.hasTypeElement())
591      composeEnum(t, "Address", "type", element.getTypeElement(), -1);
592    if (element.hasTextElement())
593      composeString(t, "Address", "text", element.getTextElement(), -1);
594    for (int i = 0; i < element.getLine().size(); i++)
595      composeString(t, "Address", "line", element.getLine().get(i), i);
596    if (element.hasCityElement())
597      composeString(t, "Address", "city", element.getCityElement(), -1);
598    if (element.hasDistrictElement())
599      composeString(t, "Address", "district", element.getDistrictElement(), -1);
600    if (element.hasStateElement())
601      composeString(t, "Address", "state", element.getStateElement(), -1);
602    if (element.hasPostalCodeElement())
603      composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1);
604    if (element.hasCountryElement())
605      composeString(t, "Address", "country", element.getCountryElement(), -1);
606    if (element.hasPeriod())
607      composePeriod(t, "Address", "period", element.getPeriod(), -1);
608  }
609
610  protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) {
611    if (element == null) 
612      return;
613    Complex t;
614    if (Utilities.noString(parentType))
615      t = parent;
616    else {
617      t = parent.predicate("fhir:"+parentType+'.'+name);
618    }
619    composeElement(t, "TriggerDefinition", name, element, index);
620    if (element.hasTypeElement())
621      composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1);
622    if (element.hasEventNameElement())
623      composeString(t, "TriggerDefinition", "eventName", element.getEventNameElement(), -1);
624    if (element.hasEventTiming())
625      composeType(t, "TriggerDefinition", "eventTiming", element.getEventTiming(), -1);
626    if (element.hasEventData())
627      composeDataRequirement(t, "TriggerDefinition", "eventData", element.getEventData(), -1);
628  }
629
630  protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) {
631    if (element == null) 
632      return;
633    Complex t;
634    if (Utilities.noString(parentType))
635      t = parent;
636    else {
637      t = parent.predicate("fhir:"+parentType+'.'+name);
638    }
639    composeElement(t, "Contributor", name, element, index);
640    if (element.hasTypeElement())
641      composeEnum(t, "Contributor", "type", element.getTypeElement(), -1);
642    if (element.hasNameElement())
643      composeString(t, "Contributor", "name", element.getNameElement(), -1);
644    for (int i = 0; i < element.getContact().size(); i++)
645      composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i);
646  }
647
648  protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) {
649    if (element == null) 
650      return;
651    Complex t;
652    if (Utilities.noString(parentType))
653      t = parent;
654    else {
655      t = parent.predicate("fhir:"+parentType+'.'+name);
656    }
657    composeElement(t, "DataRequirement", name, element, index);
658    if (element.hasTypeElement())
659      composeCode(t, "DataRequirement", "type", element.getTypeElement(), -1);
660    for (int i = 0; i < element.getProfile().size(); i++)
661      composeUri(t, "DataRequirement", "profile", element.getProfile().get(i), i);
662    for (int i = 0; i < element.getMustSupport().size(); i++)
663      composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i);
664    for (int i = 0; i < element.getCodeFilter().size(); i++)
665      composeDataRequirementDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i);
666    for (int i = 0; i < element.getDateFilter().size(); i++)
667      composeDataRequirementDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i);
668  }
669
670  protected void composeDataRequirementDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) {
671    if (element == null) 
672      return;
673    Complex t;
674    if (Utilities.noString(parentType))
675      t = parent;
676    else {
677      t = parent.predicate("fhir:"+parentType+'.'+name);
678    }
679    composeElement(t, "codeFilter", name, element, index);
680    if (element.hasPathElement())
681      composeString(t, "DataRequirement", "path", element.getPathElement(), -1);
682    if (element.hasValueSet())
683      composeType(t, "DataRequirement", "valueSet", element.getValueSet(), -1);
684    for (int i = 0; i < element.getValueCode().size(); i++)
685      composeCode(t, "DataRequirement", "valueCode", element.getValueCode().get(i), i);
686    for (int i = 0; i < element.getValueCoding().size(); i++)
687      composeCoding(t, "DataRequirement", "valueCoding", element.getValueCoding().get(i), i);
688    for (int i = 0; i < element.getValueCodeableConcept().size(); i++)
689      composeCodeableConcept(t, "DataRequirement", "valueCodeableConcept", element.getValueCodeableConcept().get(i), i);
690  }
691
692  protected void composeDataRequirementDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) {
693    if (element == null) 
694      return;
695    Complex t;
696    if (Utilities.noString(parentType))
697      t = parent;
698    else {
699      t = parent.predicate("fhir:"+parentType+'.'+name);
700    }
701    composeElement(t, "dateFilter", name, element, index);
702    if (element.hasPathElement())
703      composeString(t, "DataRequirement", "path", element.getPathElement(), -1);
704    if (element.hasValue())
705      composeType(t, "DataRequirement", "value", element.getValue(), -1);
706  }
707
708  protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) {
709    if (element == null) 
710      return;
711    Complex t;
712    if (Utilities.noString(parentType))
713      t = parent;
714    else {
715      t = parent.predicate("fhir:"+parentType+'.'+name);
716    }
717    composeElement(t, "Dosage", name, element, index);
718    if (element.hasSequenceElement())
719      composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1);
720    if (element.hasTextElement())
721      composeString(t, "Dosage", "text", element.getTextElement(), -1);
722    for (int i = 0; i < element.getAdditionalInstruction().size(); i++)
723      composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i);
724    if (element.hasPatientInstructionElement())
725      composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1);
726    if (element.hasTiming())
727      composeTiming(t, "Dosage", "timing", element.getTiming(), -1);
728    if (element.hasAsNeeded())
729      composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1);
730    if (element.hasSite())
731      composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1);
732    if (element.hasRoute())
733      composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1);
734    if (element.hasMethod())
735      composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1);
736    if (element.hasDose())
737      composeType(t, "Dosage", "dose", element.getDose(), -1);
738    if (element.hasMaxDosePerPeriod())
739      composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1);
740    if (element.hasMaxDosePerAdministration())
741      composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1);
742    if (element.hasMaxDosePerLifetime())
743      composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1);
744    if (element.hasRate())
745      composeType(t, "Dosage", "rate", element.getRate(), -1);
746  }
747
748  protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) {
749    if (element == null) 
750      return;
751    Complex t;
752    if (Utilities.noString(parentType))
753      t = parent;
754    else {
755      t = parent.predicate("fhir:"+parentType+'.'+name);
756    }
757    composeElement(t, "RelatedArtifact", name, element, index);
758    if (element.hasTypeElement())
759      composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1);
760    if (element.hasDisplayElement())
761      composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1);
762    if (element.hasCitationElement())
763      composeString(t, "RelatedArtifact", "citation", element.getCitationElement(), -1);
764    if (element.hasUrlElement())
765      composeUri(t, "RelatedArtifact", "url", element.getUrlElement(), -1);
766    if (element.hasDocument())
767      composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1);
768    if (element.hasResource())
769      composeReference(t, "RelatedArtifact", "resource", element.getResource(), -1);
770  }
771
772  protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) {
773    if (element == null) 
774      return;
775    Complex t;
776    if (Utilities.noString(parentType))
777      t = parent;
778    else {
779      t = parent.predicate("fhir:"+parentType+'.'+name);
780    }
781    composeElement(t, "ContactDetail", name, element, index);
782    if (element.hasNameElement())
783      composeString(t, "ContactDetail", "name", element.getNameElement(), -1);
784    for (int i = 0; i < element.getTelecom().size(); i++)
785      composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i);
786  }
787
788  protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) {
789    if (element == null) 
790      return;
791    Complex t;
792    if (Utilities.noString(parentType))
793      t = parent;
794    else {
795      t = parent.predicate("fhir:"+parentType+'.'+name);
796    }
797    composeElement(t, "HumanName", name, element, index);
798    if (element.hasUseElement())
799      composeEnum(t, "HumanName", "use", element.getUseElement(), -1);
800    if (element.hasTextElement())
801      composeString(t, "HumanName", "text", element.getTextElement(), -1);
802    if (element.hasFamilyElement())
803      composeString(t, "HumanName", "family", element.getFamilyElement(), -1);
804    for (int i = 0; i < element.getGiven().size(); i++)
805      composeString(t, "HumanName", "given", element.getGiven().get(i), i);
806    for (int i = 0; i < element.getPrefix().size(); i++)
807      composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i);
808    for (int i = 0; i < element.getSuffix().size(); i++)
809      composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i);
810    if (element.hasPeriod())
811      composePeriod(t, "HumanName", "period", element.getPeriod(), -1);
812  }
813
814  protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) {
815    if (element == null) 
816      return;
817    Complex t;
818    if (Utilities.noString(parentType))
819      t = parent;
820    else {
821      t = parent.predicate("fhir:"+parentType+'.'+name);
822    }
823    composeElement(t, "ContactPoint", name, element, index);
824    if (element.hasSystemElement())
825      composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1);
826    if (element.hasValueElement())
827      composeString(t, "ContactPoint", "value", element.getValueElement(), -1);
828    if (element.hasUseElement())
829      composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1);
830    if (element.hasRankElement())
831      composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1);
832    if (element.hasPeriod())
833      composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1);
834  }
835
836  protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) {
837    if (element == null) 
838      return;
839    Complex t;
840    if (Utilities.noString(parentType))
841      t = parent;
842    else {
843      t = parent.predicate("fhir:"+parentType+'.'+name);
844    }
845    composeElement(t, "UsageContext", name, element, index);
846    if (element.hasCode())
847      composeCoding(t, "UsageContext", "code", element.getCode(), -1);
848    if (element.hasValue())
849      composeType(t, "UsageContext", "value", element.getValue(), -1);
850  }
851
852  protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) {
853    if (element == null) 
854      return;
855    Complex t;
856    if (Utilities.noString(parentType))
857      t = parent;
858    else {
859      t = parent.predicate("fhir:"+parentType+'.'+name);
860    }
861    composeElement(t, "Timing", name, element, index);
862    for (int i = 0; i < element.getEvent().size(); i++)
863      composeDateTime(t, "Timing", "event", element.getEvent().get(i), i);
864    if (element.hasRepeat())
865      composeTimingTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1);
866    if (element.hasCode())
867      composeCodeableConcept(t, "Timing", "code", element.getCode(), -1);
868  }
869
870  protected void composeTimingTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) {
871    if (element == null) 
872      return;
873    Complex t;
874    if (Utilities.noString(parentType))
875      t = parent;
876    else {
877      t = parent.predicate("fhir:"+parentType+'.'+name);
878    }
879    composeElement(t, "repeat", name, element, index);
880    if (element.hasBounds())
881      composeType(t, "Timing", "bounds", element.getBounds(), -1);
882    if (element.hasCountElement())
883      composeInteger(t, "Timing", "count", element.getCountElement(), -1);
884    if (element.hasCountMaxElement())
885      composeInteger(t, "Timing", "countMax", element.getCountMaxElement(), -1);
886    if (element.hasDurationElement())
887      composeDecimal(t, "Timing", "duration", element.getDurationElement(), -1);
888    if (element.hasDurationMaxElement())
889      composeDecimal(t, "Timing", "durationMax", element.getDurationMaxElement(), -1);
890    if (element.hasDurationUnitElement())
891      composeEnum(t, "Timing", "durationUnit", element.getDurationUnitElement(), -1);
892    if (element.hasFrequencyElement())
893      composeInteger(t, "Timing", "frequency", element.getFrequencyElement(), -1);
894    if (element.hasFrequencyMaxElement())
895      composeInteger(t, "Timing", "frequencyMax", element.getFrequencyMaxElement(), -1);
896    if (element.hasPeriodElement())
897      composeDecimal(t, "Timing", "period", element.getPeriodElement(), -1);
898    if (element.hasPeriodMaxElement())
899      composeDecimal(t, "Timing", "periodMax", element.getPeriodMaxElement(), -1);
900    if (element.hasPeriodUnitElement())
901      composeEnum(t, "Timing", "periodUnit", element.getPeriodUnitElement(), -1);
902    for (int i = 0; i < element.getDayOfWeek().size(); i++)
903      composeEnum(t, "Timing", "dayOfWeek", element.getDayOfWeek().get(i), i);
904    for (int i = 0; i < element.getTimeOfDay().size(); i++)
905      composeTime(t, "Timing", "timeOfDay", element.getTimeOfDay().get(i), i);
906    for (int i = 0; i < element.getWhen().size(); i++)
907      composeEnum(t, "Timing", "when", element.getWhen().get(i), i);
908    if (element.hasOffsetElement())
909      composeUnsignedInt(t, "Timing", "offset", element.getOffsetElement(), -1);
910  }
911
912  protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) {
913    if (element == null) 
914      return;
915    Complex t;
916    if (Utilities.noString(parentType))
917      t = parent;
918    else {
919      t = parent.predicate("fhir:"+parentType+'.'+name);
920    }
921    composeElement(t, "ElementDefinition", name, element, index);
922    if (element.hasPathElement())
923      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
924    for (int i = 0; i < element.getRepresentation().size(); i++)
925      composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i);
926    if (element.hasSliceNameElement())
927      composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1);
928    if (element.hasLabelElement())
929      composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1);
930    for (int i = 0; i < element.getCode().size(); i++)
931      composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i);
932    if (element.hasSlicing())
933      composeElementDefinitionElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1);
934    if (element.hasShortElement())
935      composeString(t, "ElementDefinition", "short", element.getShortElement(), -1);
936    if (element.hasDefinitionElement())
937      composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1);
938    if (element.hasCommentElement())
939      composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1);
940    if (element.hasRequirementsElement())
941      composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1);
942    for (int i = 0; i < element.getAlias().size(); i++)
943      composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i);
944    if (element.hasMinElement())
945      composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1);
946    if (element.hasMaxElement())
947      composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1);
948    if (element.hasBase())
949      composeElementDefinitionElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1);
950    if (element.hasContentReferenceElement())
951      composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1);
952    for (int i = 0; i < element.getType().size(); i++)
953      composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i);
954    if (element.hasDefaultValue())
955      composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1);
956    if (element.hasMeaningWhenMissingElement())
957      composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1);
958    if (element.hasOrderMeaningElement())
959      composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1);
960    if (element.hasFixed())
961      composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1);
962    if (element.hasPattern())
963      composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1);
964    for (int i = 0; i < element.getExample().size(); i++)
965      composeElementDefinitionElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i);
966    if (element.hasMinValue())
967      composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1);
968    if (element.hasMaxValue())
969      composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1);
970    if (element.hasMaxLengthElement())
971      composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1);
972    for (int i = 0; i < element.getCondition().size(); i++)
973      composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i);
974    for (int i = 0; i < element.getConstraint().size(); i++)
975      composeElementDefinitionElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i);
976    if (element.hasMustSupportElement())
977      composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1);
978    if (element.hasIsModifierElement())
979      composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1);
980    if (element.hasIsSummaryElement())
981      composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1);
982    if (element.hasBinding())
983      composeElementDefinitionElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1);
984    for (int i = 0; i < element.getMapping().size(); i++)
985      composeElementDefinitionElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i);
986  }
987
988  protected void composeElementDefinitionElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) {
989    if (element == null) 
990      return;
991    Complex t;
992    if (Utilities.noString(parentType))
993      t = parent;
994    else {
995      t = parent.predicate("fhir:"+parentType+'.'+name);
996    }
997    composeElement(t, "slicing", name, element, index);
998    for (int i = 0; i < element.getDiscriminator().size(); i++)
999      composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinition", "discriminator", element.getDiscriminator().get(i), i);
1000    if (element.hasDescriptionElement())
1001      composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1);
1002    if (element.hasOrderedElement())
1003      composeBoolean(t, "ElementDefinition", "ordered", element.getOrderedElement(), -1);
1004    if (element.hasRulesElement())
1005      composeEnum(t, "ElementDefinition", "rules", element.getRulesElement(), -1);
1006  }
1007
1008  protected void composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) {
1009    if (element == null) 
1010      return;
1011    Complex t;
1012    if (Utilities.noString(parentType))
1013      t = parent;
1014    else {
1015      t = parent.predicate("fhir:"+parentType+'.'+name);
1016    }
1017    composeElement(t, "discriminator", name, element, index);
1018    if (element.hasTypeElement())
1019      composeEnum(t, "ElementDefinition", "type", element.getTypeElement(), -1);
1020    if (element.hasPathElement())
1021      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
1022  }
1023
1024  protected void composeElementDefinitionElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) {
1025    if (element == null) 
1026      return;
1027    Complex t;
1028    if (Utilities.noString(parentType))
1029      t = parent;
1030    else {
1031      t = parent.predicate("fhir:"+parentType+'.'+name);
1032    }
1033    composeElement(t, "base", name, element, index);
1034    if (element.hasPathElement())
1035      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
1036    if (element.hasMinElement())
1037      composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1);
1038    if (element.hasMaxElement())
1039      composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1);
1040  }
1041
1042  protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) {
1043    if (element == null) 
1044      return;
1045    Complex t;
1046    if (Utilities.noString(parentType))
1047      t = parent;
1048    else {
1049      t = parent.predicate("fhir:"+parentType+'.'+name);
1050    }
1051    composeElement(t, "type", name, element, index);
1052    if (element.hasCodeElement())
1053      composeUri(t, "ElementDefinition", "code", element.getCodeElement(), -1);
1054    if (element.hasProfileElement())
1055      composeUri(t, "ElementDefinition", "profile", element.getProfileElement(), -1);
1056    if (element.hasTargetProfileElement())
1057      composeUri(t, "ElementDefinition", "targetProfile", element.getTargetProfileElement(), -1);
1058    for (int i = 0; i < element.getAggregation().size(); i++)
1059      composeEnum(t, "ElementDefinition", "aggregation", element.getAggregation().get(i), i);
1060    if (element.hasVersioningElement())
1061      composeEnum(t, "ElementDefinition", "versioning", element.getVersioningElement(), -1);
1062  }
1063
1064  protected void composeElementDefinitionElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) {
1065    if (element == null) 
1066      return;
1067    Complex t;
1068    if (Utilities.noString(parentType))
1069      t = parent;
1070    else {
1071      t = parent.predicate("fhir:"+parentType+'.'+name);
1072    }
1073    composeElement(t, "example", name, element, index);
1074    if (element.hasLabelElement())
1075      composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1);
1076    if (element.hasValue())
1077      composeType(t, "ElementDefinition", "value", element.getValue(), -1);
1078  }
1079
1080  protected void composeElementDefinitionElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) {
1081    if (element == null) 
1082      return;
1083    Complex t;
1084    if (Utilities.noString(parentType))
1085      t = parent;
1086    else {
1087      t = parent.predicate("fhir:"+parentType+'.'+name);
1088    }
1089    composeElement(t, "constraint", name, element, index);
1090    if (element.hasKeyElement())
1091      composeId(t, "ElementDefinition", "key", element.getKeyElement(), -1);
1092    if (element.hasRequirementsElement())
1093      composeString(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1);
1094    if (element.hasSeverityElement())
1095      composeEnum(t, "ElementDefinition", "severity", element.getSeverityElement(), -1);
1096    if (element.hasHumanElement())
1097      composeString(t, "ElementDefinition", "human", element.getHumanElement(), -1);
1098    if (element.hasExpressionElement())
1099      composeString(t, "ElementDefinition", "expression", element.getExpressionElement(), -1);
1100    if (element.hasXpathElement())
1101      composeString(t, "ElementDefinition", "xpath", element.getXpathElement(), -1);
1102    if (element.hasSourceElement())
1103      composeUri(t, "ElementDefinition", "source", element.getSourceElement(), -1);
1104  }
1105
1106  protected void composeElementDefinitionElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) {
1107    if (element == null) 
1108      return;
1109    Complex t;
1110    if (Utilities.noString(parentType))
1111      t = parent;
1112    else {
1113      t = parent.predicate("fhir:"+parentType+'.'+name);
1114    }
1115    composeElement(t, "binding", name, element, index);
1116    if (element.hasStrengthElement())
1117      composeEnum(t, "ElementDefinition", "strength", element.getStrengthElement(), -1);
1118    if (element.hasDescriptionElement())
1119      composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1);
1120    if (element.hasValueSet())
1121      composeType(t, "ElementDefinition", "valueSet", element.getValueSet(), -1);
1122  }
1123
1124  protected void composeElementDefinitionElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) {
1125    if (element == null) 
1126      return;
1127    Complex t;
1128    if (Utilities.noString(parentType))
1129      t = parent;
1130    else {
1131      t = parent.predicate("fhir:"+parentType+'.'+name);
1132    }
1133    composeElement(t, "mapping", name, element, index);
1134    if (element.hasIdentityElement())
1135      composeId(t, "ElementDefinition", "identity", element.getIdentityElement(), -1);
1136    if (element.hasLanguageElement())
1137      composeCode(t, "ElementDefinition", "language", element.getLanguageElement(), -1);
1138    if (element.hasMapElement())
1139      composeString(t, "ElementDefinition", "map", element.getMapElement(), -1);
1140    if (element.hasCommentElement())
1141      composeString(t, "ElementDefinition", "comment", element.getCommentElement(), -1);
1142  }
1143
1144  protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) {
1145    if (element == null) 
1146      return;
1147    Complex t;
1148    if (Utilities.noString(parentType))
1149      t = parent;
1150    else {
1151      t = parent.predicate("fhir:"+parentType+'.'+name);
1152    }
1153    composeElement(t, "ParameterDefinition", name, element, index);
1154    if (element.hasNameElement())
1155      composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1);
1156    if (element.hasUseElement())
1157      composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1);
1158    if (element.hasMinElement())
1159      composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1);
1160    if (element.hasMaxElement())
1161      composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1);
1162    if (element.hasDocumentationElement())
1163      composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1);
1164    if (element.hasTypeElement())
1165      composeCode(t, "ParameterDefinition", "type", element.getTypeElement(), -1);
1166    if (element.hasProfile())
1167      composeReference(t, "ParameterDefinition", "profile", element.getProfile(), -1);
1168  }
1169
1170  protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) {
1171    composeResource(t, parentType, name, element, index);
1172    if (element.hasText())
1173      composeNarrative(t, "DomainResource", "text", element.getText(), -1);
1174    for (int i = 0; i < element.getContained().size(); i++)
1175      composeResource(t, "DomainResource", "contained", element.getContained().get(i), i);
1176    for (int i = 0; i < element.getExtension().size(); i++)
1177      composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i);
1178    for (int i = 0; i < element.getModifierExtension().size(); i++)
1179      composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i);
1180  }
1181
1182  protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) {
1183    if (element == null) 
1184      return;
1185    Complex t;
1186    if (Utilities.noString(parentType))
1187      t = parent;
1188    else {
1189      t = parent.predicate("fhir:"+parentType+'.'+name);
1190    }
1191    composeResource(t, "Parameters", name, element, index);
1192    for (int i = 0; i < element.getParameter().size(); i++)
1193      composeParametersParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i);
1194  }
1195
1196  protected void composeParametersParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) {
1197    if (element == null) 
1198      return;
1199    Complex t;
1200    if (Utilities.noString(parentType))
1201      t = parent;
1202    else {
1203      t = parent.predicate("fhir:"+parentType+'.'+name);
1204    }
1205    composeBackboneElement(t, "parameter", name, element, index);
1206    if (element.hasNameElement())
1207      composeString(t, "Parameters", "name", element.getNameElement(), -1);
1208    if (element.hasValue())
1209      composeType(t, "Parameters", "value", element.getValue(), -1);
1210    if (element.hasResource())
1211      composeResource(t, "Parameters", "resource", element.getResource(), -1);
1212    for (int i = 0; i < element.getPart().size(); i++)
1213      composeParametersParametersParameterComponent(t, "Parameters", "part", element.getPart().get(i), i);
1214  }
1215
1216  protected void composeResource(Complex t, String parentType, String name, Resource element, int index) {
1217    if (element.hasIdElement())
1218      composeId(t, "Resource", "id", element.getIdElement(), -1);
1219    if (element.hasMeta())
1220      composeMeta(t, "Resource", "meta", element.getMeta(), -1);
1221    if (element.hasImplicitRulesElement())
1222      composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1);
1223    if (element.hasLanguageElement())
1224      composeCode(t, "Resource", "language", element.getLanguageElement(), -1);
1225  }
1226
1227  protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) {
1228    if (element == null) 
1229      return;
1230    Complex t;
1231    if (Utilities.noString(parentType))
1232      t = parent;
1233    else {
1234      t = parent.predicate("fhir:"+parentType+'.'+name);
1235    }
1236    composeDomainResource(t, "Account", name, element, index);
1237    for (int i = 0; i < element.getIdentifier().size(); i++)
1238      composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i);
1239    if (element.hasStatusElement())
1240      composeEnum(t, "Account", "status", element.getStatusElement(), -1);
1241    if (element.hasType())
1242      composeCodeableConcept(t, "Account", "type", element.getType(), -1);
1243    if (element.hasNameElement())
1244      composeString(t, "Account", "name", element.getNameElement(), -1);
1245    if (element.hasSubject())
1246      composeReference(t, "Account", "subject", element.getSubject(), -1);
1247    if (element.hasPeriod())
1248      composePeriod(t, "Account", "period", element.getPeriod(), -1);
1249    if (element.hasActive())
1250      composePeriod(t, "Account", "active", element.getActive(), -1);
1251    if (element.hasBalance())
1252      composeMoney(t, "Account", "balance", element.getBalance(), -1);
1253    for (int i = 0; i < element.getCoverage().size(); i++)
1254      composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i);
1255    if (element.hasOwner())
1256      composeReference(t, "Account", "owner", element.getOwner(), -1);
1257    if (element.hasDescriptionElement())
1258      composeString(t, "Account", "description", element.getDescriptionElement(), -1);
1259    for (int i = 0; i < element.getGuarantor().size(); i++)
1260      composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i);
1261  }
1262
1263  protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) {
1264    if (element == null) 
1265      return;
1266    Complex t;
1267    if (Utilities.noString(parentType))
1268      t = parent;
1269    else {
1270      t = parent.predicate("fhir:"+parentType+'.'+name);
1271    }
1272    composeBackboneElement(t, "coverage", name, element, index);
1273    if (element.hasCoverage())
1274      composeReference(t, "Account", "coverage", element.getCoverage(), -1);
1275    if (element.hasPriorityElement())
1276      composePositiveInt(t, "Account", "priority", element.getPriorityElement(), -1);
1277  }
1278
1279  protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) {
1280    if (element == null) 
1281      return;
1282    Complex t;
1283    if (Utilities.noString(parentType))
1284      t = parent;
1285    else {
1286      t = parent.predicate("fhir:"+parentType+'.'+name);
1287    }
1288    composeBackboneElement(t, "guarantor", name, element, index);
1289    if (element.hasParty())
1290      composeReference(t, "Account", "party", element.getParty(), -1);
1291    if (element.hasOnHoldElement())
1292      composeBoolean(t, "Account", "onHold", element.getOnHoldElement(), -1);
1293    if (element.hasPeriod())
1294      composePeriod(t, "Account", "period", element.getPeriod(), -1);
1295  }
1296
1297  protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) {
1298    if (element == null) 
1299      return;
1300    Complex t;
1301    if (Utilities.noString(parentType))
1302      t = parent;
1303    else {
1304      t = parent.predicate("fhir:"+parentType+'.'+name);
1305    }
1306    composeDomainResource(t, "ActivityDefinition", name, element, index);
1307    if (element.hasUrlElement())
1308      composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1);
1309    for (int i = 0; i < element.getIdentifier().size(); i++)
1310      composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i);
1311    if (element.hasVersionElement())
1312      composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1);
1313    if (element.hasNameElement())
1314      composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1);
1315    if (element.hasTitleElement())
1316      composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1);
1317    if (element.hasStatusElement())
1318      composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1);
1319    if (element.hasExperimentalElement())
1320      composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1);
1321    if (element.hasDateElement())
1322      composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1);
1323    if (element.hasPublisherElement())
1324      composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1);
1325    if (element.hasDescriptionElement())
1326      composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1);
1327    if (element.hasPurposeElement())
1328      composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1);
1329    if (element.hasUsageElement())
1330      composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1);
1331    if (element.hasApprovalDateElement())
1332      composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1);
1333    if (element.hasLastReviewDateElement())
1334      composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
1335    if (element.hasEffectivePeriod())
1336      composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
1337    for (int i = 0; i < element.getUseContext().size(); i++)
1338      composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i);
1339    for (int i = 0; i < element.getJurisdiction().size(); i++)
1340      composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
1341    for (int i = 0; i < element.getTopic().size(); i++)
1342      composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i);
1343    for (int i = 0; i < element.getContributor().size(); i++)
1344      composeContributor(t, "ActivityDefinition", "contributor", element.getContributor().get(i), i);
1345    for (int i = 0; i < element.getContact().size(); i++)
1346      composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i);
1347    if (element.hasCopyrightElement())
1348      composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1);
1349    for (int i = 0; i < element.getRelatedArtifact().size(); i++)
1350      composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
1351    for (int i = 0; i < element.getLibrary().size(); i++)
1352      composeReference(t, "ActivityDefinition", "library", element.getLibrary().get(i), i);
1353    if (element.hasKindElement())
1354      composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1);
1355    if (element.hasCode())
1356      composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1);
1357    if (element.hasTiming())
1358      composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1);
1359    if (element.hasLocation())
1360      composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1);
1361    for (int i = 0; i < element.getParticipant().size(); i++)
1362      composeActivityDefinitionActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i);
1363    if (element.hasProduct())
1364      composeType(t, "ActivityDefinition", "product", element.getProduct(), -1);
1365    if (element.hasQuantity())
1366      composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1);
1367    for (int i = 0; i < element.getDosage().size(); i++)
1368      composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i);
1369    for (int i = 0; i < element.getBodySite().size(); i++)
1370      composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i);
1371    if (element.hasTransform())
1372      composeReference(t, "ActivityDefinition", "transform", element.getTransform(), -1);
1373    for (int i = 0; i < element.getDynamicValue().size(); i++)
1374      composeActivityDefinitionActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i);
1375  }
1376
1377  protected void composeActivityDefinitionActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) {
1378    if (element == null) 
1379      return;
1380    Complex t;
1381    if (Utilities.noString(parentType))
1382      t = parent;
1383    else {
1384      t = parent.predicate("fhir:"+parentType+'.'+name);
1385    }
1386    composeBackboneElement(t, "participant", name, element, index);
1387    if (element.hasTypeElement())
1388      composeEnum(t, "ActivityDefinition", "type", element.getTypeElement(), -1);
1389    if (element.hasRole())
1390      composeCodeableConcept(t, "ActivityDefinition", "role", element.getRole(), -1);
1391  }
1392
1393  protected void composeActivityDefinitionActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) {
1394    if (element == null) 
1395      return;
1396    Complex t;
1397    if (Utilities.noString(parentType))
1398      t = parent;
1399    else {
1400      t = parent.predicate("fhir:"+parentType+'.'+name);
1401    }
1402    composeBackboneElement(t, "dynamicValue", name, element, index);
1403    if (element.hasDescriptionElement())
1404      composeString(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1);
1405    if (element.hasPathElement())
1406      composeString(t, "ActivityDefinition", "path", element.getPathElement(), -1);
1407    if (element.hasLanguageElement())
1408      composeString(t, "ActivityDefinition", "language", element.getLanguageElement(), -1);
1409    if (element.hasExpressionElement())
1410      composeString(t, "ActivityDefinition", "expression", element.getExpressionElement(), -1);
1411  }
1412
1413  protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) {
1414    if (element == null) 
1415      return;
1416    Complex t;
1417    if (Utilities.noString(parentType))
1418      t = parent;
1419    else {
1420      t = parent.predicate("fhir:"+parentType+'.'+name);
1421    }
1422    composeDomainResource(t, "AdverseEvent", name, element, index);
1423    if (element.hasIdentifier())
1424      composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier(), -1);
1425    if (element.hasCategoryElement())
1426      composeEnum(t, "AdverseEvent", "category", element.getCategoryElement(), -1);
1427    if (element.hasType())
1428      composeCodeableConcept(t, "AdverseEvent", "type", element.getType(), -1);
1429    if (element.hasSubject())
1430      composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1);
1431    if (element.hasDateElement())
1432      composeDateTime(t, "AdverseEvent", "date", element.getDateElement(), -1);
1433    for (int i = 0; i < element.getReaction().size(); i++)
1434      composeReference(t, "AdverseEvent", "reaction", element.getReaction().get(i), i);
1435    if (element.hasLocation())
1436      composeReference(t, "AdverseEvent", "location", element.getLocation(), -1);
1437    if (element.hasSeriousness())
1438      composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1);
1439    if (element.hasOutcome())
1440      composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1);
1441    if (element.hasRecorder())
1442      composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1);
1443    if (element.hasEventParticipant())
1444      composeReference(t, "AdverseEvent", "eventParticipant", element.getEventParticipant(), -1);
1445    if (element.hasDescriptionElement())
1446      composeString(t, "AdverseEvent", "description", element.getDescriptionElement(), -1);
1447    for (int i = 0; i < element.getSuspectEntity().size(); i++)
1448      composeAdverseEventAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i);
1449    for (int i = 0; i < element.getSubjectMedicalHistory().size(); i++)
1450      composeReference(t, "AdverseEvent", "subjectMedicalHistory", element.getSubjectMedicalHistory().get(i), i);
1451    for (int i = 0; i < element.getReferenceDocument().size(); i++)
1452      composeReference(t, "AdverseEvent", "referenceDocument", element.getReferenceDocument().get(i), i);
1453    for (int i = 0; i < element.getStudy().size(); i++)
1454      composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i);
1455  }
1456
1457  protected void composeAdverseEventAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) {
1458    if (element == null) 
1459      return;
1460    Complex t;
1461    if (Utilities.noString(parentType))
1462      t = parent;
1463    else {
1464      t = parent.predicate("fhir:"+parentType+'.'+name);
1465    }
1466    composeBackboneElement(t, "suspectEntity", name, element, index);
1467    if (element.hasInstance())
1468      composeReference(t, "AdverseEvent", "instance", element.getInstance(), -1);
1469    if (element.hasCausalityElement())
1470      composeEnum(t, "AdverseEvent", "causality", element.getCausalityElement(), -1);
1471    if (element.hasCausalityAssessment())
1472      composeCodeableConcept(t, "AdverseEvent", "causalityAssessment", element.getCausalityAssessment(), -1);
1473    if (element.hasCausalityProductRelatednessElement())
1474      composeString(t, "AdverseEvent", "causalityProductRelatedness", element.getCausalityProductRelatednessElement(), -1);
1475    if (element.hasCausalityMethod())
1476      composeCodeableConcept(t, "AdverseEvent", "causalityMethod", element.getCausalityMethod(), -1);
1477    if (element.hasCausalityAuthor())
1478      composeReference(t, "AdverseEvent", "causalityAuthor", element.getCausalityAuthor(), -1);
1479    if (element.hasCausalityResult())
1480      composeCodeableConcept(t, "AdverseEvent", "causalityResult", element.getCausalityResult(), -1);
1481  }
1482
1483  protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) {
1484    if (element == null) 
1485      return;
1486    Complex t;
1487    if (Utilities.noString(parentType))
1488      t = parent;
1489    else {
1490      t = parent.predicate("fhir:"+parentType+'.'+name);
1491    }
1492    composeDomainResource(t, "AllergyIntolerance", name, element, index);
1493    for (int i = 0; i < element.getIdentifier().size(); i++)
1494      composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i);
1495    if (element.hasClinicalStatusElement())
1496      composeEnum(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatusElement(), -1);
1497    if (element.hasVerificationStatusElement())
1498      composeEnum(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatusElement(), -1);
1499    if (element.hasTypeElement())
1500      composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1);
1501    for (int i = 0; i < element.getCategory().size(); i++)
1502      composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i);
1503    if (element.hasCriticalityElement())
1504      composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1);
1505    if (element.hasCode())
1506      composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1);
1507    if (element.hasPatient())
1508      composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1);
1509    if (element.hasOnset())
1510      composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1);
1511    if (element.hasAssertedDateElement())
1512      composeDateTime(t, "AllergyIntolerance", "assertedDate", element.getAssertedDateElement(), -1);
1513    if (element.hasRecorder())
1514      composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1);
1515    if (element.hasAsserter())
1516      composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1);
1517    if (element.hasLastOccurrenceElement())
1518      composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1);
1519    for (int i = 0; i < element.getNote().size(); i++)
1520      composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i);
1521    for (int i = 0; i < element.getReaction().size(); i++)
1522      composeAllergyIntoleranceAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i);
1523  }
1524
1525  protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) {
1526    if (element == null) 
1527      return;
1528    Complex t;
1529    if (Utilities.noString(parentType))
1530      t = parent;
1531    else {
1532      t = parent.predicate("fhir:"+parentType+'.'+name);
1533    }
1534    composeBackboneElement(t, "reaction", name, element, index);
1535    if (element.hasSubstance())
1536      composeCodeableConcept(t, "AllergyIntolerance", "substance", element.getSubstance(), -1);
1537    for (int i = 0; i < element.getManifestation().size(); i++)
1538      composeCodeableConcept(t, "AllergyIntolerance", "manifestation", element.getManifestation().get(i), i);
1539    if (element.hasDescriptionElement())
1540      composeString(t, "AllergyIntolerance", "description", element.getDescriptionElement(), -1);
1541    if (element.hasOnsetElement())
1542      composeDateTime(t, "AllergyIntolerance", "onset", element.getOnsetElement(), -1);
1543    if (element.hasSeverityElement())
1544      composeEnum(t, "AllergyIntolerance", "severity", element.getSeverityElement(), -1);
1545    if (element.hasExposureRoute())
1546      composeCodeableConcept(t, "AllergyIntolerance", "exposureRoute", element.getExposureRoute(), -1);
1547    for (int i = 0; i < element.getNote().size(); i++)
1548      composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i);
1549  }
1550
1551  protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) {
1552    if (element == null) 
1553      return;
1554    Complex t;
1555    if (Utilities.noString(parentType))
1556      t = parent;
1557    else {
1558      t = parent.predicate("fhir:"+parentType+'.'+name);
1559    }
1560    composeDomainResource(t, "Appointment", name, element, index);
1561    for (int i = 0; i < element.getIdentifier().size(); i++)
1562      composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i);
1563    if (element.hasStatusElement())
1564      composeEnum(t, "Appointment", "status", element.getStatusElement(), -1);
1565    if (element.hasServiceCategory())
1566      composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory(), -1);
1567    for (int i = 0; i < element.getServiceType().size(); i++)
1568      composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i);
1569    for (int i = 0; i < element.getSpecialty().size(); i++)
1570      composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i);
1571    if (element.hasAppointmentType())
1572      composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1);
1573    for (int i = 0; i < element.getReason().size(); i++)
1574      composeCodeableConcept(t, "Appointment", "reason", element.getReason().get(i), i);
1575    for (int i = 0; i < element.getIndication().size(); i++)
1576      composeReference(t, "Appointment", "indication", element.getIndication().get(i), i);
1577    if (element.hasPriorityElement())
1578      composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1);
1579    if (element.hasDescriptionElement())
1580      composeString(t, "Appointment", "description", element.getDescriptionElement(), -1);
1581    for (int i = 0; i < element.getSupportingInformation().size(); i++)
1582      composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i);
1583    if (element.hasStartElement())
1584      composeInstant(t, "Appointment", "start", element.getStartElement(), -1);
1585    if (element.hasEndElement())
1586      composeInstant(t, "Appointment", "end", element.getEndElement(), -1);
1587    if (element.hasMinutesDurationElement())
1588      composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1);
1589    for (int i = 0; i < element.getSlot().size(); i++)
1590      composeReference(t, "Appointment", "slot", element.getSlot().get(i), i);
1591    if (element.hasCreatedElement())
1592      composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1);
1593    if (element.hasCommentElement())
1594      composeString(t, "Appointment", "comment", element.getCommentElement(), -1);
1595    for (int i = 0; i < element.getIncomingReferral().size(); i++)
1596      composeReference(t, "Appointment", "incomingReferral", element.getIncomingReferral().get(i), i);
1597    for (int i = 0; i < element.getParticipant().size(); i++)
1598      composeAppointmentAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i);
1599    for (int i = 0; i < element.getRequestedPeriod().size(); i++)
1600      composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i);
1601  }
1602
1603  protected void composeAppointmentAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) {
1604    if (element == null) 
1605      return;
1606    Complex t;
1607    if (Utilities.noString(parentType))
1608      t = parent;
1609    else {
1610      t = parent.predicate("fhir:"+parentType+'.'+name);
1611    }
1612    composeBackboneElement(t, "participant", name, element, index);
1613    for (int i = 0; i < element.getType().size(); i++)
1614      composeCodeableConcept(t, "Appointment", "type", element.getType().get(i), i);
1615    if (element.hasActor())
1616      composeReference(t, "Appointment", "actor", element.getActor(), -1);
1617    if (element.hasRequiredElement())
1618      composeEnum(t, "Appointment", "required", element.getRequiredElement(), -1);
1619    if (element.hasStatusElement())
1620      composeEnum(t, "Appointment", "status", element.getStatusElement(), -1);
1621  }
1622
1623  protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) {
1624    if (element == null) 
1625      return;
1626    Complex t;
1627    if (Utilities.noString(parentType))
1628      t = parent;
1629    else {
1630      t = parent.predicate("fhir:"+parentType+'.'+name);
1631    }
1632    composeDomainResource(t, "AppointmentResponse", name, element, index);
1633    for (int i = 0; i < element.getIdentifier().size(); i++)
1634      composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i);
1635    if (element.hasAppointment())
1636      composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1);
1637    if (element.hasStartElement())
1638      composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1);
1639    if (element.hasEndElement())
1640      composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1);
1641    for (int i = 0; i < element.getParticipantType().size(); i++)
1642      composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i);
1643    if (element.hasActor())
1644      composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1);
1645    if (element.hasParticipantStatusElement())
1646      composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1);
1647    if (element.hasCommentElement())
1648      composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1);
1649  }
1650
1651  protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) {
1652    if (element == null) 
1653      return;
1654    Complex t;
1655    if (Utilities.noString(parentType))
1656      t = parent;
1657    else {
1658      t = parent.predicate("fhir:"+parentType+'.'+name);
1659    }
1660    composeDomainResource(t, "AuditEvent", name, element, index);
1661    if (element.hasType())
1662      composeCoding(t, "AuditEvent", "type", element.getType(), -1);
1663    for (int i = 0; i < element.getSubtype().size(); i++)
1664      composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i);
1665    if (element.hasActionElement())
1666      composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1);
1667    if (element.hasRecordedElement())
1668      composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1);
1669    if (element.hasOutcomeElement())
1670      composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1);
1671    if (element.hasOutcomeDescElement())
1672      composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1);
1673    for (int i = 0; i < element.getPurposeOfEvent().size(); i++)
1674      composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i);
1675    for (int i = 0; i < element.getAgent().size(); i++)
1676      composeAuditEventAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i);
1677    if (element.hasSource())
1678      composeAuditEventAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1);
1679    for (int i = 0; i < element.getEntity().size(); i++)
1680      composeAuditEventAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i);
1681  }
1682
1683  protected void composeAuditEventAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) {
1684    if (element == null) 
1685      return;
1686    Complex t;
1687    if (Utilities.noString(parentType))
1688      t = parent;
1689    else {
1690      t = parent.predicate("fhir:"+parentType+'.'+name);
1691    }
1692    composeBackboneElement(t, "agent", name, element, index);
1693    for (int i = 0; i < element.getRole().size(); i++)
1694      composeCodeableConcept(t, "AuditEvent", "role", element.getRole().get(i), i);
1695    if (element.hasReference())
1696      composeReference(t, "AuditEvent", "reference", element.getReference(), -1);
1697    if (element.hasUserId())
1698      composeIdentifier(t, "AuditEvent", "userId", element.getUserId(), -1);
1699    if (element.hasAltIdElement())
1700      composeString(t, "AuditEvent", "altId", element.getAltIdElement(), -1);
1701    if (element.hasNameElement())
1702      composeString(t, "AuditEvent", "name", element.getNameElement(), -1);
1703    if (element.hasRequestorElement())
1704      composeBoolean(t, "AuditEvent", "requestor", element.getRequestorElement(), -1);
1705    if (element.hasLocation())
1706      composeReference(t, "AuditEvent", "location", element.getLocation(), -1);
1707    for (int i = 0; i < element.getPolicy().size(); i++)
1708      composeUri(t, "AuditEvent", "policy", element.getPolicy().get(i), i);
1709    if (element.hasMedia())
1710      composeCoding(t, "AuditEvent", "media", element.getMedia(), -1);
1711    if (element.hasNetwork())
1712      composeAuditEventAuditEventAgentNetworkComponent(t, "AuditEvent", "network", element.getNetwork(), -1);
1713    for (int i = 0; i < element.getPurposeOfUse().size(); i++)
1714      composeCodeableConcept(t, "AuditEvent", "purposeOfUse", element.getPurposeOfUse().get(i), i);
1715  }
1716
1717  protected void composeAuditEventAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) {
1718    if (element == null) 
1719      return;
1720    Complex t;
1721    if (Utilities.noString(parentType))
1722      t = parent;
1723    else {
1724      t = parent.predicate("fhir:"+parentType+'.'+name);
1725    }
1726    composeBackboneElement(t, "network", name, element, index);
1727    if (element.hasAddressElement())
1728      composeString(t, "AuditEvent", "address", element.getAddressElement(), -1);
1729    if (element.hasTypeElement())
1730      composeEnum(t, "AuditEvent", "type", element.getTypeElement(), -1);
1731  }
1732
1733  protected void composeAuditEventAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) {
1734    if (element == null) 
1735      return;
1736    Complex t;
1737    if (Utilities.noString(parentType))
1738      t = parent;
1739    else {
1740      t = parent.predicate("fhir:"+parentType+'.'+name);
1741    }
1742    composeBackboneElement(t, "source", name, element, index);
1743    if (element.hasSiteElement())
1744      composeString(t, "AuditEvent", "site", element.getSiteElement(), -1);
1745    if (element.hasIdentifier())
1746      composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1);
1747    for (int i = 0; i < element.getType().size(); i++)
1748      composeCoding(t, "AuditEvent", "type", element.getType().get(i), i);
1749  }
1750
1751  protected void composeAuditEventAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) {
1752    if (element == null) 
1753      return;
1754    Complex t;
1755    if (Utilities.noString(parentType))
1756      t = parent;
1757    else {
1758      t = parent.predicate("fhir:"+parentType+'.'+name);
1759    }
1760    composeBackboneElement(t, "entity", name, element, index);
1761    if (element.hasIdentifier())
1762      composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1);
1763    if (element.hasReference())
1764      composeReference(t, "AuditEvent", "reference", element.getReference(), -1);
1765    if (element.hasType())
1766      composeCoding(t, "AuditEvent", "type", element.getType(), -1);
1767    if (element.hasRole())
1768      composeCoding(t, "AuditEvent", "role", element.getRole(), -1);
1769    if (element.hasLifecycle())
1770      composeCoding(t, "AuditEvent", "lifecycle", element.getLifecycle(), -1);
1771    for (int i = 0; i < element.getSecurityLabel().size(); i++)
1772      composeCoding(t, "AuditEvent", "securityLabel", element.getSecurityLabel().get(i), i);
1773    if (element.hasNameElement())
1774      composeString(t, "AuditEvent", "name", element.getNameElement(), -1);
1775    if (element.hasDescriptionElement())
1776      composeString(t, "AuditEvent", "description", element.getDescriptionElement(), -1);
1777    if (element.hasQueryElement())
1778      composeBase64Binary(t, "AuditEvent", "query", element.getQueryElement(), -1);
1779    for (int i = 0; i < element.getDetail().size(); i++)
1780      composeAuditEventAuditEventEntityDetailComponent(t, "AuditEvent", "detail", element.getDetail().get(i), i);
1781  }
1782
1783  protected void composeAuditEventAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) {
1784    if (element == null) 
1785      return;
1786    Complex t;
1787    if (Utilities.noString(parentType))
1788      t = parent;
1789    else {
1790      t = parent.predicate("fhir:"+parentType+'.'+name);
1791    }
1792    composeBackboneElement(t, "detail", name, element, index);
1793    if (element.hasTypeElement())
1794      composeString(t, "AuditEvent", "type", element.getTypeElement(), -1);
1795    if (element.hasValueElement())
1796      composeBase64Binary(t, "AuditEvent", "value", element.getValueElement(), -1);
1797  }
1798
1799  protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) {
1800    if (element == null) 
1801      return;
1802    Complex t;
1803    if (Utilities.noString(parentType))
1804      t = parent;
1805    else {
1806      t = parent.predicate("fhir:"+parentType+'.'+name);
1807    }
1808    composeDomainResource(t, "Basic", name, element, index);
1809    for (int i = 0; i < element.getIdentifier().size(); i++)
1810      composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i);
1811    if (element.hasCode())
1812      composeCodeableConcept(t, "Basic", "code", element.getCode(), -1);
1813    if (element.hasSubject())
1814      composeReference(t, "Basic", "subject", element.getSubject(), -1);
1815    if (element.hasCreatedElement())
1816      composeDate(t, "Basic", "created", element.getCreatedElement(), -1);
1817    if (element.hasAuthor())
1818      composeReference(t, "Basic", "author", element.getAuthor(), -1);
1819  }
1820
1821  protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) {
1822    if (element == null) 
1823      return;
1824    Complex t;
1825    if (Utilities.noString(parentType))
1826      t = parent;
1827    else {
1828      t = parent.predicate("fhir:"+parentType+'.'+name);
1829    }
1830    composeResource(t, "Binary", name, element, index);
1831    if (element.hasContentTypeElement())
1832      composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1);
1833    if (element.hasSecurityContext())
1834      composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1);
1835    if (element.hasContentElement())
1836      composeBase64Binary(t, "Binary", "content", element.getContentElement(), -1);
1837  }
1838
1839  protected void composeBodySite(Complex parent, String parentType, String name, BodySite element, int index) {
1840    if (element == null) 
1841      return;
1842    Complex t;
1843    if (Utilities.noString(parentType))
1844      t = parent;
1845    else {
1846      t = parent.predicate("fhir:"+parentType+'.'+name);
1847    }
1848    composeDomainResource(t, "BodySite", name, element, index);
1849    for (int i = 0; i < element.getIdentifier().size(); i++)
1850      composeIdentifier(t, "BodySite", "identifier", element.getIdentifier().get(i), i);
1851    if (element.hasActiveElement())
1852      composeBoolean(t, "BodySite", "active", element.getActiveElement(), -1);
1853    if (element.hasCode())
1854      composeCodeableConcept(t, "BodySite", "code", element.getCode(), -1);
1855    for (int i = 0; i < element.getQualifier().size(); i++)
1856      composeCodeableConcept(t, "BodySite", "qualifier", element.getQualifier().get(i), i);
1857    if (element.hasDescriptionElement())
1858      composeString(t, "BodySite", "description", element.getDescriptionElement(), -1);
1859    for (int i = 0; i < element.getImage().size(); i++)
1860      composeAttachment(t, "BodySite", "image", element.getImage().get(i), i);
1861    if (element.hasPatient())
1862      composeReference(t, "BodySite", "patient", element.getPatient(), -1);
1863  }
1864
1865  protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) {
1866    if (element == null) 
1867      return;
1868    Complex t;
1869    if (Utilities.noString(parentType))
1870      t = parent;
1871    else {
1872      t = parent.predicate("fhir:"+parentType+'.'+name);
1873    }
1874    composeResource(t, "Bundle", name, element, index);
1875    if (element.hasIdentifier())
1876      composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1);
1877    if (element.hasTypeElement())
1878      composeEnum(t, "Bundle", "type", element.getTypeElement(), -1);
1879    if (element.hasTotalElement())
1880      composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1);
1881    for (int i = 0; i < element.getLink().size(); i++)
1882      composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i);
1883    for (int i = 0; i < element.getEntry().size(); i++)
1884      composeBundleBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i);
1885    if (element.hasSignature())
1886      composeSignature(t, "Bundle", "signature", element.getSignature(), -1);
1887  }
1888
1889  protected void composeBundleBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) {
1890    if (element == null) 
1891      return;
1892    Complex t;
1893    if (Utilities.noString(parentType))
1894      t = parent;
1895    else {
1896      t = parent.predicate("fhir:"+parentType+'.'+name);
1897    }
1898    composeBackboneElement(t, "link", name, element, index);
1899    if (element.hasRelationElement())
1900      composeString(t, "Bundle", "relation", element.getRelationElement(), -1);
1901    if (element.hasUrlElement())
1902      composeUri(t, "Bundle", "url", element.getUrlElement(), -1);
1903  }
1904
1905  protected void composeBundleBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) {
1906    if (element == null) 
1907      return;
1908    Complex t;
1909    if (Utilities.noString(parentType))
1910      t = parent;
1911    else {
1912      t = parent.predicate("fhir:"+parentType+'.'+name);
1913    }
1914    composeBackboneElement(t, "entry", name, element, index);
1915    for (int i = 0; i < element.getLink().size(); i++)
1916      composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i);
1917    if (element.hasFullUrlElement())
1918      composeUri(t, "Bundle", "fullUrl", element.getFullUrlElement(), -1);
1919    if (element.hasResource())
1920      composeResource(t, "Bundle", "resource", element.getResource(), -1);
1921    if (element.hasSearch())
1922      composeBundleBundleEntrySearchComponent(t, "Bundle", "search", element.getSearch(), -1);
1923    if (element.hasRequest())
1924      composeBundleBundleEntryRequestComponent(t, "Bundle", "request", element.getRequest(), -1);
1925    if (element.hasResponse())
1926      composeBundleBundleEntryResponseComponent(t, "Bundle", "response", element.getResponse(), -1);
1927  }
1928
1929  protected void composeBundleBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) {
1930    if (element == null) 
1931      return;
1932    Complex t;
1933    if (Utilities.noString(parentType))
1934      t = parent;
1935    else {
1936      t = parent.predicate("fhir:"+parentType+'.'+name);
1937    }
1938    composeBackboneElement(t, "search", name, element, index);
1939    if (element.hasModeElement())
1940      composeEnum(t, "Bundle", "mode", element.getModeElement(), -1);
1941    if (element.hasScoreElement())
1942      composeDecimal(t, "Bundle", "score", element.getScoreElement(), -1);
1943  }
1944
1945  protected void composeBundleBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) {
1946    if (element == null) 
1947      return;
1948    Complex t;
1949    if (Utilities.noString(parentType))
1950      t = parent;
1951    else {
1952      t = parent.predicate("fhir:"+parentType+'.'+name);
1953    }
1954    composeBackboneElement(t, "request", name, element, index);
1955    if (element.hasMethodElement())
1956      composeEnum(t, "Bundle", "method", element.getMethodElement(), -1);
1957    if (element.hasUrlElement())
1958      composeUri(t, "Bundle", "url", element.getUrlElement(), -1);
1959    if (element.hasIfNoneMatchElement())
1960      composeString(t, "Bundle", "ifNoneMatch", element.getIfNoneMatchElement(), -1);
1961    if (element.hasIfModifiedSinceElement())
1962      composeInstant(t, "Bundle", "ifModifiedSince", element.getIfModifiedSinceElement(), -1);
1963    if (element.hasIfMatchElement())
1964      composeString(t, "Bundle", "ifMatch", element.getIfMatchElement(), -1);
1965    if (element.hasIfNoneExistElement())
1966      composeString(t, "Bundle", "ifNoneExist", element.getIfNoneExistElement(), -1);
1967  }
1968
1969  protected void composeBundleBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) {
1970    if (element == null) 
1971      return;
1972    Complex t;
1973    if (Utilities.noString(parentType))
1974      t = parent;
1975    else {
1976      t = parent.predicate("fhir:"+parentType+'.'+name);
1977    }
1978    composeBackboneElement(t, "response", name, element, index);
1979    if (element.hasStatusElement())
1980      composeString(t, "Bundle", "status", element.getStatusElement(), -1);
1981    if (element.hasLocationElement())
1982      composeUri(t, "Bundle", "location", element.getLocationElement(), -1);
1983    if (element.hasEtagElement())
1984      composeString(t, "Bundle", "etag", element.getEtagElement(), -1);
1985    if (element.hasLastModifiedElement())
1986      composeInstant(t, "Bundle", "lastModified", element.getLastModifiedElement(), -1);
1987    if (element.hasOutcome())
1988      composeResource(t, "Bundle", "outcome", element.getOutcome(), -1);
1989  }
1990
1991  protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) {
1992    if (element == null) 
1993      return;
1994    Complex t;
1995    if (Utilities.noString(parentType))
1996      t = parent;
1997    else {
1998      t = parent.predicate("fhir:"+parentType+'.'+name);
1999    }
2000    composeDomainResource(t, "CapabilityStatement", name, element, index);
2001    if (element.hasUrlElement())
2002      composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1);
2003    if (element.hasVersionElement())
2004      composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1);
2005    if (element.hasNameElement())
2006      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
2007    if (element.hasTitleElement())
2008      composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1);
2009    if (element.hasStatusElement())
2010      composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1);
2011    if (element.hasExperimentalElement())
2012      composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1);
2013    if (element.hasDateElement())
2014      composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1);
2015    if (element.hasPublisherElement())
2016      composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1);
2017    for (int i = 0; i < element.getContact().size(); i++)
2018      composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i);
2019    if (element.hasDescriptionElement())
2020      composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
2021    for (int i = 0; i < element.getUseContext().size(); i++)
2022      composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i);
2023    for (int i = 0; i < element.getJurisdiction().size(); i++)
2024      composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i);
2025    if (element.hasPurposeElement())
2026      composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1);
2027    if (element.hasCopyrightElement())
2028      composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1);
2029    if (element.hasKindElement())
2030      composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1);
2031    for (int i = 0; i < element.getInstantiates().size(); i++)
2032      composeUri(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i);
2033    if (element.hasSoftware())
2034      composeCapabilityStatementCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1);
2035    if (element.hasImplementation())
2036      composeCapabilityStatementCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1);
2037    if (element.hasFhirVersionElement())
2038      composeId(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1);
2039    if (element.hasAcceptUnknownElement())
2040      composeEnum(t, "CapabilityStatement", "acceptUnknown", element.getAcceptUnknownElement(), -1);
2041    for (int i = 0; i < element.getFormat().size(); i++)
2042      composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i);
2043    for (int i = 0; i < element.getPatchFormat().size(); i++)
2044      composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i);
2045    for (int i = 0; i < element.getImplementationGuide().size(); i++)
2046      composeUri(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i);
2047    for (int i = 0; i < element.getProfile().size(); i++)
2048      composeReference(t, "CapabilityStatement", "profile", element.getProfile().get(i), i);
2049    for (int i = 0; i < element.getRest().size(); i++)
2050      composeCapabilityStatementCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i);
2051    for (int i = 0; i < element.getMessaging().size(); i++)
2052      composeCapabilityStatementCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i);
2053    for (int i = 0; i < element.getDocument().size(); i++)
2054      composeCapabilityStatementCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i);
2055  }
2056
2057  protected void composeCapabilityStatementCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) {
2058    if (element == null) 
2059      return;
2060    Complex t;
2061    if (Utilities.noString(parentType))
2062      t = parent;
2063    else {
2064      t = parent.predicate("fhir:"+parentType+'.'+name);
2065    }
2066    composeBackboneElement(t, "software", name, element, index);
2067    if (element.hasNameElement())
2068      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
2069    if (element.hasVersionElement())
2070      composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1);
2071    if (element.hasReleaseDateElement())
2072      composeDateTime(t, "CapabilityStatement", "releaseDate", element.getReleaseDateElement(), -1);
2073  }
2074
2075  protected void composeCapabilityStatementCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) {
2076    if (element == null) 
2077      return;
2078    Complex t;
2079    if (Utilities.noString(parentType))
2080      t = parent;
2081    else {
2082      t = parent.predicate("fhir:"+parentType+'.'+name);
2083    }
2084    composeBackboneElement(t, "implementation", name, element, index);
2085    if (element.hasDescriptionElement())
2086      composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
2087    if (element.hasUrlElement())
2088      composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1);
2089  }
2090
2091  protected void composeCapabilityStatementCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) {
2092    if (element == null) 
2093      return;
2094    Complex t;
2095    if (Utilities.noString(parentType))
2096      t = parent;
2097    else {
2098      t = parent.predicate("fhir:"+parentType+'.'+name);
2099    }
2100    composeBackboneElement(t, "rest", name, element, index);
2101    if (element.hasModeElement())
2102      composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1);
2103    if (element.hasDocumentationElement())
2104      composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2105    if (element.hasSecurity())
2106      composeCapabilityStatementCapabilityStatementRestSecurityComponent(t, "CapabilityStatement", "security", element.getSecurity(), -1);
2107    for (int i = 0; i < element.getResource().size(); i++)
2108      composeCapabilityStatementCapabilityStatementRestResourceComponent(t, "CapabilityStatement", "resource", element.getResource().get(i), i);
2109    for (int i = 0; i < element.getInteraction().size(); i++)
2110      composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i);
2111    for (int i = 0; i < element.getSearchParam().size(); i++)
2112      composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i);
2113    for (int i = 0; i < element.getOperation().size(); i++)
2114      composeCapabilityStatementCapabilityStatementRestOperationComponent(t, "CapabilityStatement", "operation", element.getOperation().get(i), i);
2115    for (int i = 0; i < element.getCompartment().size(); i++)
2116      composeUri(t, "CapabilityStatement", "compartment", element.getCompartment().get(i), i);
2117  }
2118
2119  protected void composeCapabilityStatementCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) {
2120    if (element == null) 
2121      return;
2122    Complex t;
2123    if (Utilities.noString(parentType))
2124      t = parent;
2125    else {
2126      t = parent.predicate("fhir:"+parentType+'.'+name);
2127    }
2128    composeBackboneElement(t, "security", name, element, index);
2129    if (element.hasCorsElement())
2130      composeBoolean(t, "CapabilityStatement", "cors", element.getCorsElement(), -1);
2131    for (int i = 0; i < element.getService().size(); i++)
2132      composeCodeableConcept(t, "CapabilityStatement", "service", element.getService().get(i), i);
2133    if (element.hasDescriptionElement())
2134      composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
2135    for (int i = 0; i < element.getCertificate().size(); i++)
2136      composeCapabilityStatementCapabilityStatementRestSecurityCertificateComponent(t, "CapabilityStatement", "certificate", element.getCertificate().get(i), i);
2137  }
2138
2139  protected void composeCapabilityStatementCapabilityStatementRestSecurityCertificateComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityCertificateComponent element, int index) {
2140    if (element == null) 
2141      return;
2142    Complex t;
2143    if (Utilities.noString(parentType))
2144      t = parent;
2145    else {
2146      t = parent.predicate("fhir:"+parentType+'.'+name);
2147    }
2148    composeBackboneElement(t, "certificate", name, element, index);
2149    if (element.hasTypeElement())
2150      composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1);
2151    if (element.hasBlobElement())
2152      composeBase64Binary(t, "CapabilityStatement", "blob", element.getBlobElement(), -1);
2153  }
2154
2155  protected void composeCapabilityStatementCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) {
2156    if (element == null) 
2157      return;
2158    Complex t;
2159    if (Utilities.noString(parentType))
2160      t = parent;
2161    else {
2162      t = parent.predicate("fhir:"+parentType+'.'+name);
2163    }
2164    composeBackboneElement(t, "resource", name, element, index);
2165    if (element.hasTypeElement())
2166      composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1);
2167    if (element.hasProfile())
2168      composeReference(t, "CapabilityStatement", "profile", element.getProfile(), -1);
2169    if (element.hasDocumentationElement())
2170      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2171    for (int i = 0; i < element.getInteraction().size(); i++)
2172      composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i);
2173    if (element.hasVersioningElement())
2174      composeEnum(t, "CapabilityStatement", "versioning", element.getVersioningElement(), -1);
2175    if (element.hasReadHistoryElement())
2176      composeBoolean(t, "CapabilityStatement", "readHistory", element.getReadHistoryElement(), -1);
2177    if (element.hasUpdateCreateElement())
2178      composeBoolean(t, "CapabilityStatement", "updateCreate", element.getUpdateCreateElement(), -1);
2179    if (element.hasConditionalCreateElement())
2180      composeBoolean(t, "CapabilityStatement", "conditionalCreate", element.getConditionalCreateElement(), -1);
2181    if (element.hasConditionalReadElement())
2182      composeEnum(t, "CapabilityStatement", "conditionalRead", element.getConditionalReadElement(), -1);
2183    if (element.hasConditionalUpdateElement())
2184      composeBoolean(t, "CapabilityStatement", "conditionalUpdate", element.getConditionalUpdateElement(), -1);
2185    if (element.hasConditionalDeleteElement())
2186      composeEnum(t, "CapabilityStatement", "conditionalDelete", element.getConditionalDeleteElement(), -1);
2187    for (int i = 0; i < element.getReferencePolicy().size(); i++)
2188      composeEnum(t, "CapabilityStatement", "referencePolicy", element.getReferencePolicy().get(i), i);
2189    for (int i = 0; i < element.getSearchInclude().size(); i++)
2190      composeString(t, "CapabilityStatement", "searchInclude", element.getSearchInclude().get(i), i);
2191    for (int i = 0; i < element.getSearchRevInclude().size(); i++)
2192      composeString(t, "CapabilityStatement", "searchRevInclude", element.getSearchRevInclude().get(i), i);
2193    for (int i = 0; i < element.getSearchParam().size(); i++)
2194      composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i);
2195  }
2196
2197  protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) {
2198    if (element == null) 
2199      return;
2200    Complex t;
2201    if (Utilities.noString(parentType))
2202      t = parent;
2203    else {
2204      t = parent.predicate("fhir:"+parentType+'.'+name);
2205    }
2206    composeBackboneElement(t, "interaction", name, element, index);
2207    if (element.hasCodeElement())
2208      composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1);
2209    if (element.hasDocumentationElement())
2210      composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2211  }
2212
2213  protected void composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) {
2214    if (element == null) 
2215      return;
2216    Complex t;
2217    if (Utilities.noString(parentType))
2218      t = parent;
2219    else {
2220      t = parent.predicate("fhir:"+parentType+'.'+name);
2221    }
2222    composeBackboneElement(t, "searchParam", name, element, index);
2223    if (element.hasNameElement())
2224      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
2225    if (element.hasDefinitionElement())
2226      composeUri(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1);
2227    if (element.hasTypeElement())
2228      composeEnum(t, "CapabilityStatement", "type", element.getTypeElement(), -1);
2229    if (element.hasDocumentationElement())
2230      composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2231  }
2232
2233  protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) {
2234    if (element == null) 
2235      return;
2236    Complex t;
2237    if (Utilities.noString(parentType))
2238      t = parent;
2239    else {
2240      t = parent.predicate("fhir:"+parentType+'.'+name);
2241    }
2242    composeBackboneElement(t, "interaction", name, element, index);
2243    if (element.hasCodeElement())
2244      composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1);
2245    if (element.hasDocumentationElement())
2246      composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2247  }
2248
2249  protected void composeCapabilityStatementCapabilityStatementRestOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestOperationComponent element, int index) {
2250    if (element == null) 
2251      return;
2252    Complex t;
2253    if (Utilities.noString(parentType))
2254      t = parent;
2255    else {
2256      t = parent.predicate("fhir:"+parentType+'.'+name);
2257    }
2258    composeBackboneElement(t, "operation", name, element, index);
2259    if (element.hasNameElement())
2260      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
2261    if (element.hasDefinition())
2262      composeReference(t, "CapabilityStatement", "definition", element.getDefinition(), -1);
2263  }
2264
2265  protected void composeCapabilityStatementCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) {
2266    if (element == null) 
2267      return;
2268    Complex t;
2269    if (Utilities.noString(parentType))
2270      t = parent;
2271    else {
2272      t = parent.predicate("fhir:"+parentType+'.'+name);
2273    }
2274    composeBackboneElement(t, "messaging", name, element, index);
2275    for (int i = 0; i < element.getEndpoint().size(); i++)
2276      composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatement", "endpoint", element.getEndpoint().get(i), i);
2277    if (element.hasReliableCacheElement())
2278      composeUnsignedInt(t, "CapabilityStatement", "reliableCache", element.getReliableCacheElement(), -1);
2279    if (element.hasDocumentationElement())
2280      composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2281    for (int i = 0; i < element.getSupportedMessage().size(); i++)
2282      composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatement", "supportedMessage", element.getSupportedMessage().get(i), i);
2283    for (int i = 0; i < element.getEvent().size(); i++)
2284      composeCapabilityStatementCapabilityStatementMessagingEventComponent(t, "CapabilityStatement", "event", element.getEvent().get(i), i);
2285  }
2286
2287  protected void composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) {
2288    if (element == null) 
2289      return;
2290    Complex t;
2291    if (Utilities.noString(parentType))
2292      t = parent;
2293    else {
2294      t = parent.predicate("fhir:"+parentType+'.'+name);
2295    }
2296    composeBackboneElement(t, "endpoint", name, element, index);
2297    if (element.hasProtocol())
2298      composeCoding(t, "CapabilityStatement", "protocol", element.getProtocol(), -1);
2299    if (element.hasAddressElement())
2300      composeUri(t, "CapabilityStatement", "address", element.getAddressElement(), -1);
2301  }
2302
2303  protected void composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) {
2304    if (element == null) 
2305      return;
2306    Complex t;
2307    if (Utilities.noString(parentType))
2308      t = parent;
2309    else {
2310      t = parent.predicate("fhir:"+parentType+'.'+name);
2311    }
2312    composeBackboneElement(t, "supportedMessage", name, element, index);
2313    if (element.hasModeElement())
2314      composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1);
2315    if (element.hasDefinition())
2316      composeReference(t, "CapabilityStatement", "definition", element.getDefinition(), -1);
2317  }
2318
2319  protected void composeCapabilityStatementCapabilityStatementMessagingEventComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEventComponent element, int index) {
2320    if (element == null) 
2321      return;
2322    Complex t;
2323    if (Utilities.noString(parentType))
2324      t = parent;
2325    else {
2326      t = parent.predicate("fhir:"+parentType+'.'+name);
2327    }
2328    composeBackboneElement(t, "event", name, element, index);
2329    if (element.hasCode())
2330      composeCoding(t, "CapabilityStatement", "code", element.getCode(), -1);
2331    if (element.hasCategoryElement())
2332      composeEnum(t, "CapabilityStatement", "category", element.getCategoryElement(), -1);
2333    if (element.hasModeElement())
2334      composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1);
2335    if (element.hasFocusElement())
2336      composeCode(t, "CapabilityStatement", "focus", element.getFocusElement(), -1);
2337    if (element.hasRequest())
2338      composeReference(t, "CapabilityStatement", "request", element.getRequest(), -1);
2339    if (element.hasResponse())
2340      composeReference(t, "CapabilityStatement", "response", element.getResponse(), -1);
2341    if (element.hasDocumentationElement())
2342      composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2343  }
2344
2345  protected void composeCapabilityStatementCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) {
2346    if (element == null) 
2347      return;
2348    Complex t;
2349    if (Utilities.noString(parentType))
2350      t = parent;
2351    else {
2352      t = parent.predicate("fhir:"+parentType+'.'+name);
2353    }
2354    composeBackboneElement(t, "document", name, element, index);
2355    if (element.hasModeElement())
2356      composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1);
2357    if (element.hasDocumentationElement())
2358      composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2359    if (element.hasProfile())
2360      composeReference(t, "CapabilityStatement", "profile", element.getProfile(), -1);
2361  }
2362
2363  protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) {
2364    if (element == null) 
2365      return;
2366    Complex t;
2367    if (Utilities.noString(parentType))
2368      t = parent;
2369    else {
2370      t = parent.predicate("fhir:"+parentType+'.'+name);
2371    }
2372    composeDomainResource(t, "CarePlan", name, element, index);
2373    for (int i = 0; i < element.getIdentifier().size(); i++)
2374      composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i);
2375    for (int i = 0; i < element.getDefinition().size(); i++)
2376      composeReference(t, "CarePlan", "definition", element.getDefinition().get(i), i);
2377    for (int i = 0; i < element.getBasedOn().size(); i++)
2378      composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i);
2379    for (int i = 0; i < element.getReplaces().size(); i++)
2380      composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i);
2381    for (int i = 0; i < element.getPartOf().size(); i++)
2382      composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i);
2383    if (element.hasStatusElement())
2384      composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1);
2385    if (element.hasIntentElement())
2386      composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1);
2387    for (int i = 0; i < element.getCategory().size(); i++)
2388      composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i);
2389    if (element.hasTitleElement())
2390      composeString(t, "CarePlan", "title", element.getTitleElement(), -1);
2391    if (element.hasDescriptionElement())
2392      composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1);
2393    if (element.hasSubject())
2394      composeReference(t, "CarePlan", "subject", element.getSubject(), -1);
2395    if (element.hasContext())
2396      composeReference(t, "CarePlan", "context", element.getContext(), -1);
2397    if (element.hasPeriod())
2398      composePeriod(t, "CarePlan", "period", element.getPeriod(), -1);
2399    for (int i = 0; i < element.getAuthor().size(); i++)
2400      composeReference(t, "CarePlan", "author", element.getAuthor().get(i), i);
2401    for (int i = 0; i < element.getCareTeam().size(); i++)
2402      composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i);
2403    for (int i = 0; i < element.getAddresses().size(); i++)
2404      composeReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i);
2405    for (int i = 0; i < element.getSupportingInfo().size(); i++)
2406      composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i);
2407    for (int i = 0; i < element.getGoal().size(); i++)
2408      composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i);
2409    for (int i = 0; i < element.getActivity().size(); i++)
2410      composeCarePlanCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i);
2411    for (int i = 0; i < element.getNote().size(); i++)
2412      composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i);
2413  }
2414
2415  protected void composeCarePlanCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) {
2416    if (element == null) 
2417      return;
2418    Complex t;
2419    if (Utilities.noString(parentType))
2420      t = parent;
2421    else {
2422      t = parent.predicate("fhir:"+parentType+'.'+name);
2423    }
2424    composeBackboneElement(t, "activity", name, element, index);
2425    for (int i = 0; i < element.getOutcomeCodeableConcept().size(); i++)
2426      composeCodeableConcept(t, "CarePlan", "outcomeCodeableConcept", element.getOutcomeCodeableConcept().get(i), i);
2427    for (int i = 0; i < element.getOutcomeReference().size(); i++)
2428      composeReference(t, "CarePlan", "outcomeReference", element.getOutcomeReference().get(i), i);
2429    for (int i = 0; i < element.getProgress().size(); i++)
2430      composeAnnotation(t, "CarePlan", "progress", element.getProgress().get(i), i);
2431    if (element.hasReference())
2432      composeReference(t, "CarePlan", "reference", element.getReference(), -1);
2433    if (element.hasDetail())
2434      composeCarePlanCarePlanActivityDetailComponent(t, "CarePlan", "detail", element.getDetail(), -1);
2435  }
2436
2437  protected void composeCarePlanCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) {
2438    if (element == null) 
2439      return;
2440    Complex t;
2441    if (Utilities.noString(parentType))
2442      t = parent;
2443    else {
2444      t = parent.predicate("fhir:"+parentType+'.'+name);
2445    }
2446    composeBackboneElement(t, "detail", name, element, index);
2447    if (element.hasCategory())
2448      composeCodeableConcept(t, "CarePlan", "category", element.getCategory(), -1);
2449    if (element.hasDefinition())
2450      composeReference(t, "CarePlan", "definition", element.getDefinition(), -1);
2451    if (element.hasCode())
2452      composeCodeableConcept(t, "CarePlan", "code", element.getCode(), -1);
2453    for (int i = 0; i < element.getReasonCode().size(); i++)
2454      composeCodeableConcept(t, "CarePlan", "reasonCode", element.getReasonCode().get(i), i);
2455    for (int i = 0; i < element.getReasonReference().size(); i++)
2456      composeReference(t, "CarePlan", "reasonReference", element.getReasonReference().get(i), i);
2457    for (int i = 0; i < element.getGoal().size(); i++)
2458      composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i);
2459    if (element.hasStatusElement())
2460      composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1);
2461    if (element.hasStatusReasonElement())
2462      composeString(t, "CarePlan", "statusReason", element.getStatusReasonElement(), -1);
2463    if (element.hasProhibitedElement())
2464      composeBoolean(t, "CarePlan", "prohibited", element.getProhibitedElement(), -1);
2465    if (element.hasScheduled())
2466      composeType(t, "CarePlan", "scheduled", element.getScheduled(), -1);
2467    if (element.hasLocation())
2468      composeReference(t, "CarePlan", "location", element.getLocation(), -1);
2469    for (int i = 0; i < element.getPerformer().size(); i++)
2470      composeReference(t, "CarePlan", "performer", element.getPerformer().get(i), i);
2471    if (element.hasProduct())
2472      composeType(t, "CarePlan", "product", element.getProduct(), -1);
2473    if (element.hasDailyAmount())
2474      composeQuantity(t, "CarePlan", "dailyAmount", element.getDailyAmount(), -1);
2475    if (element.hasQuantity())
2476      composeQuantity(t, "CarePlan", "quantity", element.getQuantity(), -1);
2477    if (element.hasDescriptionElement())
2478      composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1);
2479  }
2480
2481  protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) {
2482    if (element == null) 
2483      return;
2484    Complex t;
2485    if (Utilities.noString(parentType))
2486      t = parent;
2487    else {
2488      t = parent.predicate("fhir:"+parentType+'.'+name);
2489    }
2490    composeDomainResource(t, "CareTeam", name, element, index);
2491    for (int i = 0; i < element.getIdentifier().size(); i++)
2492      composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i);
2493    if (element.hasStatusElement())
2494      composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1);
2495    for (int i = 0; i < element.getCategory().size(); i++)
2496      composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i);
2497    if (element.hasNameElement())
2498      composeString(t, "CareTeam", "name", element.getNameElement(), -1);
2499    if (element.hasSubject())
2500      composeReference(t, "CareTeam", "subject", element.getSubject(), -1);
2501    if (element.hasContext())
2502      composeReference(t, "CareTeam", "context", element.getContext(), -1);
2503    if (element.hasPeriod())
2504      composePeriod(t, "CareTeam", "period", element.getPeriod(), -1);
2505    for (int i = 0; i < element.getParticipant().size(); i++)
2506      composeCareTeamCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i);
2507    for (int i = 0; i < element.getReasonCode().size(); i++)
2508      composeCodeableConcept(t, "CareTeam", "reasonCode", element.getReasonCode().get(i), i);
2509    for (int i = 0; i < element.getReasonReference().size(); i++)
2510      composeReference(t, "CareTeam", "reasonReference", element.getReasonReference().get(i), i);
2511    for (int i = 0; i < element.getManagingOrganization().size(); i++)
2512      composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i);
2513    for (int i = 0; i < element.getNote().size(); i++)
2514      composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i);
2515  }
2516
2517  protected void composeCareTeamCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) {
2518    if (element == null) 
2519      return;
2520    Complex t;
2521    if (Utilities.noString(parentType))
2522      t = parent;
2523    else {
2524      t = parent.predicate("fhir:"+parentType+'.'+name);
2525    }
2526    composeBackboneElement(t, "participant", name, element, index);
2527    if (element.hasRole())
2528      composeCodeableConcept(t, "CareTeam", "role", element.getRole(), -1);
2529    if (element.hasMember())
2530      composeReference(t, "CareTeam", "member", element.getMember(), -1);
2531    if (element.hasOnBehalfOf())
2532      composeReference(t, "CareTeam", "onBehalfOf", element.getOnBehalfOf(), -1);
2533    if (element.hasPeriod())
2534      composePeriod(t, "CareTeam", "period", element.getPeriod(), -1);
2535  }
2536
2537  protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) {
2538    if (element == null) 
2539      return;
2540    Complex t;
2541    if (Utilities.noString(parentType))
2542      t = parent;
2543    else {
2544      t = parent.predicate("fhir:"+parentType+'.'+name);
2545    }
2546    composeDomainResource(t, "ChargeItem", name, element, index);
2547    if (element.hasIdentifier())
2548      composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier(), -1);
2549    for (int i = 0; i < element.getDefinition().size(); i++)
2550      composeUri(t, "ChargeItem", "definition", element.getDefinition().get(i), i);
2551    if (element.hasStatusElement())
2552      composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1);
2553    for (int i = 0; i < element.getPartOf().size(); i++)
2554      composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i);
2555    if (element.hasCode())
2556      composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1);
2557    if (element.hasSubject())
2558      composeReference(t, "ChargeItem", "subject", element.getSubject(), -1);
2559    if (element.hasContext())
2560      composeReference(t, "ChargeItem", "context", element.getContext(), -1);
2561    if (element.hasOccurrence())
2562      composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1);
2563    for (int i = 0; i < element.getParticipant().size(); i++)
2564      composeChargeItemChargeItemParticipantComponent(t, "ChargeItem", "participant", element.getParticipant().get(i), i);
2565    if (element.hasPerformingOrganization())
2566      composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1);
2567    if (element.hasRequestingOrganization())
2568      composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1);
2569    if (element.hasQuantity())
2570      composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1);
2571    for (int i = 0; i < element.getBodysite().size(); i++)
2572      composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i);
2573    if (element.hasFactorOverrideElement())
2574      composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1);
2575    if (element.hasPriceOverride())
2576      composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1);
2577    if (element.hasOverrideReasonElement())
2578      composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1);
2579    if (element.hasEnterer())
2580      composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1);
2581    if (element.hasEnteredDateElement())
2582      composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1);
2583    for (int i = 0; i < element.getReason().size(); i++)
2584      composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i);
2585    for (int i = 0; i < element.getService().size(); i++)
2586      composeReference(t, "ChargeItem", "service", element.getService().get(i), i);
2587    for (int i = 0; i < element.getAccount().size(); i++)
2588      composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i);
2589    for (int i = 0; i < element.getNote().size(); i++)
2590      composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i);
2591    for (int i = 0; i < element.getSupportingInformation().size(); i++)
2592      composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i);
2593  }
2594
2595  protected void composeChargeItemChargeItemParticipantComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemParticipantComponent element, int index) {
2596    if (element == null) 
2597      return;
2598    Complex t;
2599    if (Utilities.noString(parentType))
2600      t = parent;
2601    else {
2602      t = parent.predicate("fhir:"+parentType+'.'+name);
2603    }
2604    composeBackboneElement(t, "participant", name, element, index);
2605    if (element.hasRole())
2606      composeCodeableConcept(t, "ChargeItem", "role", element.getRole(), -1);
2607    if (element.hasActor())
2608      composeReference(t, "ChargeItem", "actor", element.getActor(), -1);
2609  }
2610
2611  protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) {
2612    if (element == null) 
2613      return;
2614    Complex t;
2615    if (Utilities.noString(parentType))
2616      t = parent;
2617    else {
2618      t = parent.predicate("fhir:"+parentType+'.'+name);
2619    }
2620    composeDomainResource(t, "Claim", name, element, index);
2621    for (int i = 0; i < element.getIdentifier().size(); i++)
2622      composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i);
2623    if (element.hasStatusElement())
2624      composeEnum(t, "Claim", "status", element.getStatusElement(), -1);
2625    if (element.hasType())
2626      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
2627    for (int i = 0; i < element.getSubType().size(); i++)
2628      composeCodeableConcept(t, "Claim", "subType", element.getSubType().get(i), i);
2629    if (element.hasUseElement())
2630      composeEnum(t, "Claim", "use", element.getUseElement(), -1);
2631    if (element.hasPatient())
2632      composeReference(t, "Claim", "patient", element.getPatient(), -1);
2633    if (element.hasBillablePeriod())
2634      composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1);
2635    if (element.hasCreatedElement())
2636      composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1);
2637    if (element.hasEnterer())
2638      composeReference(t, "Claim", "enterer", element.getEnterer(), -1);
2639    if (element.hasInsurer())
2640      composeReference(t, "Claim", "insurer", element.getInsurer(), -1);
2641    if (element.hasProvider())
2642      composeReference(t, "Claim", "provider", element.getProvider(), -1);
2643    if (element.hasOrganization())
2644      composeReference(t, "Claim", "organization", element.getOrganization(), -1);
2645    if (element.hasPriority())
2646      composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1);
2647    if (element.hasFundsReserve())
2648      composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1);
2649    for (int i = 0; i < element.getRelated().size(); i++)
2650      composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i);
2651    if (element.hasPrescription())
2652      composeReference(t, "Claim", "prescription", element.getPrescription(), -1);
2653    if (element.hasOriginalPrescription())
2654      composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1);
2655    if (element.hasPayee())
2656      composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1);
2657    if (element.hasReferral())
2658      composeReference(t, "Claim", "referral", element.getReferral(), -1);
2659    if (element.hasFacility())
2660      composeReference(t, "Claim", "facility", element.getFacility(), -1);
2661    for (int i = 0; i < element.getCareTeam().size(); i++)
2662      composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i);
2663    for (int i = 0; i < element.getInformation().size(); i++)
2664      composeClaimSpecialConditionComponent(t, "Claim", "information", element.getInformation().get(i), i);
2665    for (int i = 0; i < element.getDiagnosis().size(); i++)
2666      composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i);
2667    for (int i = 0; i < element.getProcedure().size(); i++)
2668      composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i);
2669    for (int i = 0; i < element.getInsurance().size(); i++)
2670      composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i);
2671    if (element.hasAccident())
2672      composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1);
2673    if (element.hasEmploymentImpacted())
2674      composePeriod(t, "Claim", "employmentImpacted", element.getEmploymentImpacted(), -1);
2675    if (element.hasHospitalization())
2676      composePeriod(t, "Claim", "hospitalization", element.getHospitalization(), -1);
2677    for (int i = 0; i < element.getItem().size(); i++)
2678      composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i);
2679    if (element.hasTotal())
2680      composeMoney(t, "Claim", "total", element.getTotal(), -1);
2681  }
2682
2683  protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) {
2684    if (element == null) 
2685      return;
2686    Complex t;
2687    if (Utilities.noString(parentType))
2688      t = parent;
2689    else {
2690      t = parent.predicate("fhir:"+parentType+'.'+name);
2691    }
2692    composeBackboneElement(t, "related", name, element, index);
2693    if (element.hasClaim())
2694      composeReference(t, "Claim", "claim", element.getClaim(), -1);
2695    if (element.hasRelationship())
2696      composeCodeableConcept(t, "Claim", "relationship", element.getRelationship(), -1);
2697    if (element.hasReference())
2698      composeIdentifier(t, "Claim", "reference", element.getReference(), -1);
2699  }
2700
2701  protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) {
2702    if (element == null) 
2703      return;
2704    Complex t;
2705    if (Utilities.noString(parentType))
2706      t = parent;
2707    else {
2708      t = parent.predicate("fhir:"+parentType+'.'+name);
2709    }
2710    composeBackboneElement(t, "payee", name, element, index);
2711    if (element.hasType())
2712      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
2713    if (element.hasResourceType())
2714      composeCoding(t, "Claim", "resourceType", element.getResourceType(), -1);
2715    if (element.hasParty())
2716      composeReference(t, "Claim", "party", element.getParty(), -1);
2717  }
2718
2719  protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) {
2720    if (element == null) 
2721      return;
2722    Complex t;
2723    if (Utilities.noString(parentType))
2724      t = parent;
2725    else {
2726      t = parent.predicate("fhir:"+parentType+'.'+name);
2727    }
2728    composeBackboneElement(t, "careTeam", name, element, index);
2729    if (element.hasSequenceElement())
2730      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
2731    if (element.hasProvider())
2732      composeReference(t, "Claim", "provider", element.getProvider(), -1);
2733    if (element.hasResponsibleElement())
2734      composeBoolean(t, "Claim", "responsible", element.getResponsibleElement(), -1);
2735    if (element.hasRole())
2736      composeCodeableConcept(t, "Claim", "role", element.getRole(), -1);
2737    if (element.hasQualification())
2738      composeCodeableConcept(t, "Claim", "qualification", element.getQualification(), -1);
2739  }
2740
2741  protected void composeClaimSpecialConditionComponent(Complex parent, String parentType, String name, Claim.SpecialConditionComponent element, int index) {
2742    if (element == null) 
2743      return;
2744    Complex t;
2745    if (Utilities.noString(parentType))
2746      t = parent;
2747    else {
2748      t = parent.predicate("fhir:"+parentType+'.'+name);
2749    }
2750    composeBackboneElement(t, "information", name, element, index);
2751    if (element.hasSequenceElement())
2752      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
2753    if (element.hasCategory())
2754      composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1);
2755    if (element.hasCode())
2756      composeCodeableConcept(t, "Claim", "code", element.getCode(), -1);
2757    if (element.hasTiming())
2758      composeType(t, "Claim", "timing", element.getTiming(), -1);
2759    if (element.hasValue())
2760      composeType(t, "Claim", "value", element.getValue(), -1);
2761    if (element.hasReason())
2762      composeCodeableConcept(t, "Claim", "reason", element.getReason(), -1);
2763  }
2764
2765  protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) {
2766    if (element == null) 
2767      return;
2768    Complex t;
2769    if (Utilities.noString(parentType))
2770      t = parent;
2771    else {
2772      t = parent.predicate("fhir:"+parentType+'.'+name);
2773    }
2774    composeBackboneElement(t, "diagnosis", name, element, index);
2775    if (element.hasSequenceElement())
2776      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
2777    if (element.hasDiagnosis())
2778      composeType(t, "Claim", "diagnosis", element.getDiagnosis(), -1);
2779    for (int i = 0; i < element.getType().size(); i++)
2780      composeCodeableConcept(t, "Claim", "type", element.getType().get(i), i);
2781    if (element.hasPackageCode())
2782      composeCodeableConcept(t, "Claim", "packageCode", element.getPackageCode(), -1);
2783  }
2784
2785  protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) {
2786    if (element == null) 
2787      return;
2788    Complex t;
2789    if (Utilities.noString(parentType))
2790      t = parent;
2791    else {
2792      t = parent.predicate("fhir:"+parentType+'.'+name);
2793    }
2794    composeBackboneElement(t, "procedure", name, element, index);
2795    if (element.hasSequenceElement())
2796      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
2797    if (element.hasDateElement())
2798      composeDateTime(t, "Claim", "date", element.getDateElement(), -1);
2799    if (element.hasProcedure())
2800      composeType(t, "Claim", "procedure", element.getProcedure(), -1);
2801  }
2802
2803  protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) {
2804    if (element == null) 
2805      return;
2806    Complex t;
2807    if (Utilities.noString(parentType))
2808      t = parent;
2809    else {
2810      t = parent.predicate("fhir:"+parentType+'.'+name);
2811    }
2812    composeBackboneElement(t, "insurance", name, element, index);
2813    if (element.hasSequenceElement())
2814      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
2815    if (element.hasFocalElement())
2816      composeBoolean(t, "Claim", "focal", element.getFocalElement(), -1);
2817    if (element.hasCoverage())
2818      composeReference(t, "Claim", "coverage", element.getCoverage(), -1);
2819    if (element.hasBusinessArrangementElement())
2820      composeString(t, "Claim", "businessArrangement", element.getBusinessArrangementElement(), -1);
2821    for (int i = 0; i < element.getPreAuthRef().size(); i++)
2822      composeString(t, "Claim", "preAuthRef", element.getPreAuthRef().get(i), i);
2823    if (element.hasClaimResponse())
2824      composeReference(t, "Claim", "claimResponse", element.getClaimResponse(), -1);
2825  }
2826
2827  protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) {
2828    if (element == null) 
2829      return;
2830    Complex t;
2831    if (Utilities.noString(parentType))
2832      t = parent;
2833    else {
2834      t = parent.predicate("fhir:"+parentType+'.'+name);
2835    }
2836    composeBackboneElement(t, "accident", name, element, index);
2837    if (element.hasDateElement())
2838      composeDate(t, "Claim", "date", element.getDateElement(), -1);
2839    if (element.hasType())
2840      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
2841    if (element.hasLocation())
2842      composeType(t, "Claim", "location", element.getLocation(), -1);
2843  }
2844
2845  protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) {
2846    if (element == null) 
2847      return;
2848    Complex t;
2849    if (Utilities.noString(parentType))
2850      t = parent;
2851    else {
2852      t = parent.predicate("fhir:"+parentType+'.'+name);
2853    }
2854    composeBackboneElement(t, "item", name, element, index);
2855    if (element.hasSequenceElement())
2856      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
2857    for (int i = 0; i < element.getCareTeamLinkId().size(); i++)
2858      composePositiveInt(t, "Claim", "careTeamLinkId", element.getCareTeamLinkId().get(i), i);
2859    for (int i = 0; i < element.getDiagnosisLinkId().size(); i++)
2860      composePositiveInt(t, "Claim", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i);
2861    for (int i = 0; i < element.getProcedureLinkId().size(); i++)
2862      composePositiveInt(t, "Claim", "procedureLinkId", element.getProcedureLinkId().get(i), i);
2863    for (int i = 0; i < element.getInformationLinkId().size(); i++)
2864      composePositiveInt(t, "Claim", "informationLinkId", element.getInformationLinkId().get(i), i);
2865    if (element.hasRevenue())
2866      composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1);
2867    if (element.hasCategory())
2868      composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1);
2869    if (element.hasService())
2870      composeCodeableConcept(t, "Claim", "service", element.getService(), -1);
2871    for (int i = 0; i < element.getModifier().size(); i++)
2872      composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i);
2873    for (int i = 0; i < element.getProgramCode().size(); i++)
2874      composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i);
2875    if (element.hasServiced())
2876      composeType(t, "Claim", "serviced", element.getServiced(), -1);
2877    if (element.hasLocation())
2878      composeType(t, "Claim", "location", element.getLocation(), -1);
2879    if (element.hasQuantity())
2880      composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1);
2881    if (element.hasUnitPrice())
2882      composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1);
2883    if (element.hasFactorElement())
2884      composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1);
2885    if (element.hasNet())
2886      composeMoney(t, "Claim", "net", element.getNet(), -1);
2887    for (int i = 0; i < element.getUdi().size(); i++)
2888      composeReference(t, "Claim", "udi", element.getUdi().get(i), i);
2889    if (element.hasBodySite())
2890      composeCodeableConcept(t, "Claim", "bodySite", element.getBodySite(), -1);
2891    for (int i = 0; i < element.getSubSite().size(); i++)
2892      composeCodeableConcept(t, "Claim", "subSite", element.getSubSite().get(i), i);
2893    for (int i = 0; i < element.getEncounter().size(); i++)
2894      composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i);
2895    for (int i = 0; i < element.getDetail().size(); i++)
2896      composeClaimDetailComponent(t, "Claim", "detail", element.getDetail().get(i), i);
2897  }
2898
2899  protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) {
2900    if (element == null) 
2901      return;
2902    Complex t;
2903    if (Utilities.noString(parentType))
2904      t = parent;
2905    else {
2906      t = parent.predicate("fhir:"+parentType+'.'+name);
2907    }
2908    composeBackboneElement(t, "detail", name, element, index);
2909    if (element.hasSequenceElement())
2910      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
2911    if (element.hasRevenue())
2912      composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1);
2913    if (element.hasCategory())
2914      composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1);
2915    if (element.hasService())
2916      composeCodeableConcept(t, "Claim", "service", element.getService(), -1);
2917    for (int i = 0; i < element.getModifier().size(); i++)
2918      composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i);
2919    for (int i = 0; i < element.getProgramCode().size(); i++)
2920      composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i);
2921    if (element.hasQuantity())
2922      composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1);
2923    if (element.hasUnitPrice())
2924      composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1);
2925    if (element.hasFactorElement())
2926      composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1);
2927    if (element.hasNet())
2928      composeMoney(t, "Claim", "net", element.getNet(), -1);
2929    for (int i = 0; i < element.getUdi().size(); i++)
2930      composeReference(t, "Claim", "udi", element.getUdi().get(i), i);
2931    for (int i = 0; i < element.getSubDetail().size(); i++)
2932      composeClaimSubDetailComponent(t, "Claim", "subDetail", element.getSubDetail().get(i), i);
2933  }
2934
2935  protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) {
2936    if (element == null) 
2937      return;
2938    Complex t;
2939    if (Utilities.noString(parentType))
2940      t = parent;
2941    else {
2942      t = parent.predicate("fhir:"+parentType+'.'+name);
2943    }
2944    composeBackboneElement(t, "subDetail", name, element, index);
2945    if (element.hasSequenceElement())
2946      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
2947    if (element.hasRevenue())
2948      composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1);
2949    if (element.hasCategory())
2950      composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1);
2951    if (element.hasService())
2952      composeCodeableConcept(t, "Claim", "service", element.getService(), -1);
2953    for (int i = 0; i < element.getModifier().size(); i++)
2954      composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i);
2955    for (int i = 0; i < element.getProgramCode().size(); i++)
2956      composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i);
2957    if (element.hasQuantity())
2958      composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1);
2959    if (element.hasUnitPrice())
2960      composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1);
2961    if (element.hasFactorElement())
2962      composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1);
2963    if (element.hasNet())
2964      composeMoney(t, "Claim", "net", element.getNet(), -1);
2965    for (int i = 0; i < element.getUdi().size(); i++)
2966      composeReference(t, "Claim", "udi", element.getUdi().get(i), i);
2967  }
2968
2969  protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) {
2970    if (element == null) 
2971      return;
2972    Complex t;
2973    if (Utilities.noString(parentType))
2974      t = parent;
2975    else {
2976      t = parent.predicate("fhir:"+parentType+'.'+name);
2977    }
2978    composeDomainResource(t, "ClaimResponse", name, element, index);
2979    for (int i = 0; i < element.getIdentifier().size(); i++)
2980      composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i);
2981    if (element.hasStatusElement())
2982      composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1);
2983    if (element.hasPatient())
2984      composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1);
2985    if (element.hasCreatedElement())
2986      composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1);
2987    if (element.hasInsurer())
2988      composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1);
2989    if (element.hasRequestProvider())
2990      composeReference(t, "ClaimResponse", "requestProvider", element.getRequestProvider(), -1);
2991    if (element.hasRequestOrganization())
2992      composeReference(t, "ClaimResponse", "requestOrganization", element.getRequestOrganization(), -1);
2993    if (element.hasRequest())
2994      composeReference(t, "ClaimResponse", "request", element.getRequest(), -1);
2995    if (element.hasOutcome())
2996      composeCodeableConcept(t, "ClaimResponse", "outcome", element.getOutcome(), -1);
2997    if (element.hasDispositionElement())
2998      composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1);
2999    if (element.hasPayeeType())
3000      composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1);
3001    for (int i = 0; i < element.getItem().size(); i++)
3002      composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i);
3003    for (int i = 0; i < element.getAddItem().size(); i++)
3004      composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i);
3005    for (int i = 0; i < element.getError().size(); i++)
3006      composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i);
3007    if (element.hasTotalCost())
3008      composeMoney(t, "ClaimResponse", "totalCost", element.getTotalCost(), -1);
3009    if (element.hasUnallocDeductable())
3010      composeMoney(t, "ClaimResponse", "unallocDeductable", element.getUnallocDeductable(), -1);
3011    if (element.hasTotalBenefit())
3012      composeMoney(t, "ClaimResponse", "totalBenefit", element.getTotalBenefit(), -1);
3013    if (element.hasPayment())
3014      composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1);
3015    if (element.hasReserved())
3016      composeCoding(t, "ClaimResponse", "reserved", element.getReserved(), -1);
3017    if (element.hasForm())
3018      composeCodeableConcept(t, "ClaimResponse", "form", element.getForm(), -1);
3019    for (int i = 0; i < element.getProcessNote().size(); i++)
3020      composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i);
3021    for (int i = 0; i < element.getCommunicationRequest().size(); i++)
3022      composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i);
3023    for (int i = 0; i < element.getInsurance().size(); i++)
3024      composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i);
3025  }
3026
3027  protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) {
3028    if (element == null) 
3029      return;
3030    Complex t;
3031    if (Utilities.noString(parentType))
3032      t = parent;
3033    else {
3034      t = parent.predicate("fhir:"+parentType+'.'+name);
3035    }
3036    composeBackboneElement(t, "item", name, element, index);
3037    if (element.hasSequenceLinkIdElement())
3038      composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1);
3039    for (int i = 0; i < element.getNoteNumber().size(); i++)
3040      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3041    for (int i = 0; i < element.getAdjudication().size(); i++)
3042      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3043    for (int i = 0; i < element.getDetail().size(); i++)
3044      composeClaimResponseItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i);
3045  }
3046
3047  protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) {
3048    if (element == null) 
3049      return;
3050    Complex t;
3051    if (Utilities.noString(parentType))
3052      t = parent;
3053    else {
3054      t = parent.predicate("fhir:"+parentType+'.'+name);
3055    }
3056    composeBackboneElement(t, "adjudication", name, element, index);
3057    if (element.hasCategory())
3058      composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1);
3059    if (element.hasReason())
3060      composeCodeableConcept(t, "ClaimResponse", "reason", element.getReason(), -1);
3061    if (element.hasAmount())
3062      composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1);
3063    if (element.hasValueElement())
3064      composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1);
3065  }
3066
3067  protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) {
3068    if (element == null) 
3069      return;
3070    Complex t;
3071    if (Utilities.noString(parentType))
3072      t = parent;
3073    else {
3074      t = parent.predicate("fhir:"+parentType+'.'+name);
3075    }
3076    composeBackboneElement(t, "detail", name, element, index);
3077    if (element.hasSequenceLinkIdElement())
3078      composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1);
3079    for (int i = 0; i < element.getNoteNumber().size(); i++)
3080      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3081    for (int i = 0; i < element.getAdjudication().size(); i++)
3082      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3083    for (int i = 0; i < element.getSubDetail().size(); i++)
3084      composeClaimResponseSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i);
3085  }
3086
3087  protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) {
3088    if (element == null) 
3089      return;
3090    Complex t;
3091    if (Utilities.noString(parentType))
3092      t = parent;
3093    else {
3094      t = parent.predicate("fhir:"+parentType+'.'+name);
3095    }
3096    composeBackboneElement(t, "subDetail", name, element, index);
3097    if (element.hasSequenceLinkIdElement())
3098      composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1);
3099    for (int i = 0; i < element.getNoteNumber().size(); i++)
3100      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3101    for (int i = 0; i < element.getAdjudication().size(); i++)
3102      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3103  }
3104
3105  protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) {
3106    if (element == null) 
3107      return;
3108    Complex t;
3109    if (Utilities.noString(parentType))
3110      t = parent;
3111    else {
3112      t = parent.predicate("fhir:"+parentType+'.'+name);
3113    }
3114    composeBackboneElement(t, "addItem", name, element, index);
3115    for (int i = 0; i < element.getSequenceLinkId().size(); i++)
3116      composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkId().get(i), i);
3117    if (element.hasRevenue())
3118      composeCodeableConcept(t, "ClaimResponse", "revenue", element.getRevenue(), -1);
3119    if (element.hasCategory())
3120      composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1);
3121    if (element.hasService())
3122      composeCodeableConcept(t, "ClaimResponse", "service", element.getService(), -1);
3123    for (int i = 0; i < element.getModifier().size(); i++)
3124      composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i);
3125    if (element.hasFee())
3126      composeMoney(t, "ClaimResponse", "fee", element.getFee(), -1);
3127    for (int i = 0; i < element.getNoteNumber().size(); i++)
3128      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3129    for (int i = 0; i < element.getAdjudication().size(); i++)
3130      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3131    for (int i = 0; i < element.getDetail().size(); i++)
3132      composeClaimResponseAddedItemsDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i);
3133  }
3134
3135  protected void composeClaimResponseAddedItemsDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemsDetailComponent element, int index) {
3136    if (element == null) 
3137      return;
3138    Complex t;
3139    if (Utilities.noString(parentType))
3140      t = parent;
3141    else {
3142      t = parent.predicate("fhir:"+parentType+'.'+name);
3143    }
3144    composeBackboneElement(t, "detail", name, element, index);
3145    if (element.hasRevenue())
3146      composeCodeableConcept(t, "ClaimResponse", "revenue", element.getRevenue(), -1);
3147    if (element.hasCategory())
3148      composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1);
3149    if (element.hasService())
3150      composeCodeableConcept(t, "ClaimResponse", "service", element.getService(), -1);
3151    for (int i = 0; i < element.getModifier().size(); i++)
3152      composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i);
3153    if (element.hasFee())
3154      composeMoney(t, "ClaimResponse", "fee", element.getFee(), -1);
3155    for (int i = 0; i < element.getNoteNumber().size(); i++)
3156      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3157    for (int i = 0; i < element.getAdjudication().size(); i++)
3158      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3159  }
3160
3161  protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) {
3162    if (element == null) 
3163      return;
3164    Complex t;
3165    if (Utilities.noString(parentType))
3166      t = parent;
3167    else {
3168      t = parent.predicate("fhir:"+parentType+'.'+name);
3169    }
3170    composeBackboneElement(t, "error", name, element, index);
3171    if (element.hasSequenceLinkIdElement())
3172      composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1);
3173    if (element.hasDetailSequenceLinkIdElement())
3174      composePositiveInt(t, "ClaimResponse", "detailSequenceLinkId", element.getDetailSequenceLinkIdElement(), -1);
3175    if (element.hasSubdetailSequenceLinkIdElement())
3176      composePositiveInt(t, "ClaimResponse", "subdetailSequenceLinkId", element.getSubdetailSequenceLinkIdElement(), -1);
3177    if (element.hasCode())
3178      composeCodeableConcept(t, "ClaimResponse", "code", element.getCode(), -1);
3179  }
3180
3181  protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) {
3182    if (element == null) 
3183      return;
3184    Complex t;
3185    if (Utilities.noString(parentType))
3186      t = parent;
3187    else {
3188      t = parent.predicate("fhir:"+parentType+'.'+name);
3189    }
3190    composeBackboneElement(t, "payment", name, element, index);
3191    if (element.hasType())
3192      composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1);
3193    if (element.hasAdjustment())
3194      composeMoney(t, "ClaimResponse", "adjustment", element.getAdjustment(), -1);
3195    if (element.hasAdjustmentReason())
3196      composeCodeableConcept(t, "ClaimResponse", "adjustmentReason", element.getAdjustmentReason(), -1);
3197    if (element.hasDateElement())
3198      composeDate(t, "ClaimResponse", "date", element.getDateElement(), -1);
3199    if (element.hasAmount())
3200      composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1);
3201    if (element.hasIdentifier())
3202      composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier(), -1);
3203  }
3204
3205  protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) {
3206    if (element == null) 
3207      return;
3208    Complex t;
3209    if (Utilities.noString(parentType))
3210      t = parent;
3211    else {
3212      t = parent.predicate("fhir:"+parentType+'.'+name);
3213    }
3214    composeBackboneElement(t, "processNote", name, element, index);
3215    if (element.hasNumberElement())
3216      composePositiveInt(t, "ClaimResponse", "number", element.getNumberElement(), -1);
3217    if (element.hasType())
3218      composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1);
3219    if (element.hasTextElement())
3220      composeString(t, "ClaimResponse", "text", element.getTextElement(), -1);
3221    if (element.hasLanguage())
3222      composeCodeableConcept(t, "ClaimResponse", "language", element.getLanguage(), -1);
3223  }
3224
3225  protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) {
3226    if (element == null) 
3227      return;
3228    Complex t;
3229    if (Utilities.noString(parentType))
3230      t = parent;
3231    else {
3232      t = parent.predicate("fhir:"+parentType+'.'+name);
3233    }
3234    composeBackboneElement(t, "insurance", name, element, index);
3235    if (element.hasSequenceElement())
3236      composePositiveInt(t, "ClaimResponse", "sequence", element.getSequenceElement(), -1);
3237    if (element.hasFocalElement())
3238      composeBoolean(t, "ClaimResponse", "focal", element.getFocalElement(), -1);
3239    if (element.hasCoverage())
3240      composeReference(t, "ClaimResponse", "coverage", element.getCoverage(), -1);
3241    if (element.hasBusinessArrangementElement())
3242      composeString(t, "ClaimResponse", "businessArrangement", element.getBusinessArrangementElement(), -1);
3243    for (int i = 0; i < element.getPreAuthRef().size(); i++)
3244      composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRef().get(i), i);
3245    if (element.hasClaimResponse())
3246      composeReference(t, "ClaimResponse", "claimResponse", element.getClaimResponse(), -1);
3247  }
3248
3249  protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) {
3250    if (element == null) 
3251      return;
3252    Complex t;
3253    if (Utilities.noString(parentType))
3254      t = parent;
3255    else {
3256      t = parent.predicate("fhir:"+parentType+'.'+name);
3257    }
3258    composeDomainResource(t, "ClinicalImpression", name, element, index);
3259    for (int i = 0; i < element.getIdentifier().size(); i++)
3260      composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i);
3261    if (element.hasStatusElement())
3262      composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1);
3263    if (element.hasCode())
3264      composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1);
3265    if (element.hasDescriptionElement())
3266      composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1);
3267    if (element.hasSubject())
3268      composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1);
3269    if (element.hasContext())
3270      composeReference(t, "ClinicalImpression", "context", element.getContext(), -1);
3271    if (element.hasEffective())
3272      composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1);
3273    if (element.hasDateElement())
3274      composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1);
3275    if (element.hasAssessor())
3276      composeReference(t, "ClinicalImpression", "assessor", element.getAssessor(), -1);
3277    if (element.hasPrevious())
3278      composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1);
3279    for (int i = 0; i < element.getProblem().size(); i++)
3280      composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i);
3281    for (int i = 0; i < element.getInvestigation().size(); i++)
3282      composeClinicalImpressionClinicalImpressionInvestigationComponent(t, "ClinicalImpression", "investigation", element.getInvestigation().get(i), i);
3283    for (int i = 0; i < element.getProtocol().size(); i++)
3284      composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i);
3285    if (element.hasSummaryElement())
3286      composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1);
3287    for (int i = 0; i < element.getFinding().size(); i++)
3288      composeClinicalImpressionClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i);
3289    for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++)
3290      composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i);
3291    for (int i = 0; i < element.getPrognosisReference().size(); i++)
3292      composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i);
3293    for (int i = 0; i < element.getAction().size(); i++)
3294      composeReference(t, "ClinicalImpression", "action", element.getAction().get(i), i);
3295    for (int i = 0; i < element.getNote().size(); i++)
3296      composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i);
3297  }
3298
3299  protected void composeClinicalImpressionClinicalImpressionInvestigationComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionInvestigationComponent element, int index) {
3300    if (element == null) 
3301      return;
3302    Complex t;
3303    if (Utilities.noString(parentType))
3304      t = parent;
3305    else {
3306      t = parent.predicate("fhir:"+parentType+'.'+name);
3307    }
3308    composeBackboneElement(t, "investigation", name, element, index);
3309    if (element.hasCode())
3310      composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1);
3311    for (int i = 0; i < element.getItem().size(); i++)
3312      composeReference(t, "ClinicalImpression", "item", element.getItem().get(i), i);
3313  }
3314
3315  protected void composeClinicalImpressionClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) {
3316    if (element == null) 
3317      return;
3318    Complex t;
3319    if (Utilities.noString(parentType))
3320      t = parent;
3321    else {
3322      t = parent.predicate("fhir:"+parentType+'.'+name);
3323    }
3324    composeBackboneElement(t, "finding", name, element, index);
3325    if (element.hasItem())
3326      composeType(t, "ClinicalImpression", "item", element.getItem(), -1);
3327    if (element.hasBasisElement())
3328      composeString(t, "ClinicalImpression", "basis", element.getBasisElement(), -1);
3329  }
3330
3331  protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) {
3332    if (element == null) 
3333      return;
3334    Complex t;
3335    if (Utilities.noString(parentType))
3336      t = parent;
3337    else {
3338      t = parent.predicate("fhir:"+parentType+'.'+name);
3339    }
3340    composeDomainResource(t, "CodeSystem", name, element, index);
3341    if (element.hasUrlElement())
3342      composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1);
3343    if (element.hasIdentifier())
3344      composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier(), -1);
3345    if (element.hasVersionElement())
3346      composeString(t, "CodeSystem", "version", element.getVersionElement(), -1);
3347    if (element.hasNameElement())
3348      composeString(t, "CodeSystem", "name", element.getNameElement(), -1);
3349    if (element.hasTitleElement())
3350      composeString(t, "CodeSystem", "title", element.getTitleElement(), -1);
3351    if (element.hasStatusElement())
3352      composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1);
3353    if (element.hasExperimentalElement())
3354      composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1);
3355    if (element.hasDateElement())
3356      composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1);
3357    if (element.hasPublisherElement())
3358      composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1);
3359    for (int i = 0; i < element.getContact().size(); i++)
3360      composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i);
3361    if (element.hasDescriptionElement())
3362      composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
3363    for (int i = 0; i < element.getUseContext().size(); i++)
3364      composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i);
3365    for (int i = 0; i < element.getJurisdiction().size(); i++)
3366      composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i);
3367    if (element.hasPurposeElement())
3368      composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1);
3369    if (element.hasCopyrightElement())
3370      composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1);
3371    if (element.hasCaseSensitiveElement())
3372      composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1);
3373    if (element.hasValueSetElement())
3374      composeUri(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1);
3375    if (element.hasHierarchyMeaningElement())
3376      composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1);
3377    if (element.hasCompositionalElement())
3378      composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1);
3379    if (element.hasVersionNeededElement())
3380      composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1);
3381    if (element.hasContentElement())
3382      composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1);
3383    if (element.hasCountElement())
3384      composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1);
3385    for (int i = 0; i < element.getFilter().size(); i++)
3386      composeCodeSystemCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i);
3387    for (int i = 0; i < element.getProperty().size(); i++)
3388      composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i);
3389    for (int i = 0; i < element.getConcept().size(); i++)
3390      composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i);
3391  }
3392
3393  protected void composeCodeSystemCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) {
3394    if (element == null) 
3395      return;
3396    Complex t;
3397    if (Utilities.noString(parentType))
3398      t = parent;
3399    else {
3400      t = parent.predicate("fhir:"+parentType+'.'+name);
3401    }
3402    composeBackboneElement(t, "filter", name, element, index);
3403    if (element.hasCodeElement())
3404      composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1);
3405    if (element.hasDescriptionElement())
3406      composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
3407    for (int i = 0; i < element.getOperator().size(); i++)
3408      composeEnum(t, "CodeSystem", "operator", element.getOperator().get(i), i);
3409    if (element.hasValueElement())
3410      composeString(t, "CodeSystem", "value", element.getValueElement(), -1);
3411  }
3412
3413  protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) {
3414    if (element == null) 
3415      return;
3416    Complex t;
3417    if (Utilities.noString(parentType))
3418      t = parent;
3419    else {
3420      t = parent.predicate("fhir:"+parentType+'.'+name);
3421    }
3422    composeBackboneElement(t, "property", name, element, index);
3423    if (element.hasCodeElement())
3424      composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1);
3425    if (element.hasUriElement())
3426      composeUri(t, "CodeSystem", "uri", element.getUriElement(), -1);
3427    if (element.hasDescriptionElement())
3428      composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
3429    if (element.hasTypeElement())
3430      composeEnum(t, "CodeSystem", "type", element.getTypeElement(), -1);
3431  }
3432
3433  protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) {
3434    if (element == null) 
3435      return;
3436    Complex t;
3437    if (Utilities.noString(parentType))
3438      t = parent;
3439    else {
3440      t = parent.predicate("fhir:"+parentType+'.'+name);
3441    }
3442    composeBackboneElement(t, "concept", name, element, index);
3443    if (element.hasCodeElement())
3444      composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1);
3445    if (element.hasDisplayElement())
3446      composeString(t, "CodeSystem", "display", element.getDisplayElement(), -1);
3447    if (element.hasDefinitionElement())
3448      composeString(t, "CodeSystem", "definition", element.getDefinitionElement(), -1);
3449    for (int i = 0; i < element.getDesignation().size(); i++)
3450      composeCodeSystemConceptDefinitionDesignationComponent(t, "CodeSystem", "designation", element.getDesignation().get(i), i);
3451    for (int i = 0; i < element.getProperty().size(); i++)
3452      composeCodeSystemConceptPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i);
3453    for (int i = 0; i < element.getConcept().size(); i++)
3454      composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i);
3455  }
3456
3457  protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) {
3458    if (element == null) 
3459      return;
3460    Complex t;
3461    if (Utilities.noString(parentType))
3462      t = parent;
3463    else {
3464      t = parent.predicate("fhir:"+parentType+'.'+name);
3465    }
3466    composeBackboneElement(t, "designation", name, element, index);
3467    if (element.hasLanguageElement())
3468      composeCode(t, "CodeSystem", "language", element.getLanguageElement(), -1);
3469    if (element.hasUse())
3470      composeCoding(t, "CodeSystem", "use", element.getUse(), -1);
3471    if (element.hasValueElement())
3472      composeString(t, "CodeSystem", "value", element.getValueElement(), -1);
3473  }
3474
3475  protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) {
3476    if (element == null) 
3477      return;
3478    Complex t;
3479    if (Utilities.noString(parentType))
3480      t = parent;
3481    else {
3482      t = parent.predicate("fhir:"+parentType+'.'+name);
3483    }
3484    composeBackboneElement(t, "property", name, element, index);
3485    if (element.hasCodeElement())
3486      composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1);
3487    if (element.hasValue())
3488      composeType(t, "CodeSystem", "value", element.getValue(), -1);
3489  }
3490
3491  protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) {
3492    if (element == null) 
3493      return;
3494    Complex t;
3495    if (Utilities.noString(parentType))
3496      t = parent;
3497    else {
3498      t = parent.predicate("fhir:"+parentType+'.'+name);
3499    }
3500    composeDomainResource(t, "Communication", name, element, index);
3501    for (int i = 0; i < element.getIdentifier().size(); i++)
3502      composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i);
3503    for (int i = 0; i < element.getDefinition().size(); i++)
3504      composeReference(t, "Communication", "definition", element.getDefinition().get(i), i);
3505    for (int i = 0; i < element.getBasedOn().size(); i++)
3506      composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i);
3507    for (int i = 0; i < element.getPartOf().size(); i++)
3508      composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i);
3509    if (element.hasStatusElement())
3510      composeEnum(t, "Communication", "status", element.getStatusElement(), -1);
3511    if (element.hasNotDoneElement())
3512      composeBoolean(t, "Communication", "notDone", element.getNotDoneElement(), -1);
3513    if (element.hasNotDoneReason())
3514      composeCodeableConcept(t, "Communication", "notDoneReason", element.getNotDoneReason(), -1);
3515    for (int i = 0; i < element.getCategory().size(); i++)
3516      composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i);
3517    for (int i = 0; i < element.getMedium().size(); i++)
3518      composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i);
3519    if (element.hasSubject())
3520      composeReference(t, "Communication", "subject", element.getSubject(), -1);
3521    for (int i = 0; i < element.getRecipient().size(); i++)
3522      composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i);
3523    for (int i = 0; i < element.getTopic().size(); i++)
3524      composeReference(t, "Communication", "topic", element.getTopic().get(i), i);
3525    if (element.hasContext())
3526      composeReference(t, "Communication", "context", element.getContext(), -1);
3527    if (element.hasSentElement())
3528      composeDateTime(t, "Communication", "sent", element.getSentElement(), -1);
3529    if (element.hasReceivedElement())
3530      composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1);
3531    if (element.hasSender())
3532      composeReference(t, "Communication", "sender", element.getSender(), -1);
3533    for (int i = 0; i < element.getReasonCode().size(); i++)
3534      composeCodeableConcept(t, "Communication", "reasonCode", element.getReasonCode().get(i), i);
3535    for (int i = 0; i < element.getReasonReference().size(); i++)
3536      composeReference(t, "Communication", "reasonReference", element.getReasonReference().get(i), i);
3537    for (int i = 0; i < element.getPayload().size(); i++)
3538      composeCommunicationCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i);
3539    for (int i = 0; i < element.getNote().size(); i++)
3540      composeAnnotation(t, "Communication", "note", element.getNote().get(i), i);
3541  }
3542
3543  protected void composeCommunicationCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) {
3544    if (element == null) 
3545      return;
3546    Complex t;
3547    if (Utilities.noString(parentType))
3548      t = parent;
3549    else {
3550      t = parent.predicate("fhir:"+parentType+'.'+name);
3551    }
3552    composeBackboneElement(t, "payload", name, element, index);
3553    if (element.hasContent())
3554      composeType(t, "Communication", "content", element.getContent(), -1);
3555  }
3556
3557  protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) {
3558    if (element == null) 
3559      return;
3560    Complex t;
3561    if (Utilities.noString(parentType))
3562      t = parent;
3563    else {
3564      t = parent.predicate("fhir:"+parentType+'.'+name);
3565    }
3566    composeDomainResource(t, "CommunicationRequest", name, element, index);
3567    for (int i = 0; i < element.getIdentifier().size(); i++)
3568      composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i);
3569    for (int i = 0; i < element.getBasedOn().size(); i++)
3570      composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i);
3571    for (int i = 0; i < element.getReplaces().size(); i++)
3572      composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i);
3573    if (element.hasGroupIdentifier())
3574      composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
3575    if (element.hasStatusElement())
3576      composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1);
3577    for (int i = 0; i < element.getCategory().size(); i++)
3578      composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i);
3579    if (element.hasPriorityElement())
3580      composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1);
3581    for (int i = 0; i < element.getMedium().size(); i++)
3582      composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i);
3583    if (element.hasSubject())
3584      composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1);
3585    for (int i = 0; i < element.getRecipient().size(); i++)
3586      composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i);
3587    for (int i = 0; i < element.getTopic().size(); i++)
3588      composeReference(t, "CommunicationRequest", "topic", element.getTopic().get(i), i);
3589    if (element.hasContext())
3590      composeReference(t, "CommunicationRequest", "context", element.getContext(), -1);
3591    for (int i = 0; i < element.getPayload().size(); i++)
3592      composeCommunicationRequestCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i);
3593    if (element.hasOccurrence())
3594      composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1);
3595    if (element.hasAuthoredOnElement())
3596      composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
3597    if (element.hasSender())
3598      composeReference(t, "CommunicationRequest", "sender", element.getSender(), -1);
3599    if (element.hasRequester())
3600      composeCommunicationRequestCommunicationRequestRequesterComponent(t, "CommunicationRequest", "requester", element.getRequester(), -1);
3601    for (int i = 0; i < element.getReasonCode().size(); i++)
3602      composeCodeableConcept(t, "CommunicationRequest", "reasonCode", element.getReasonCode().get(i), i);
3603    for (int i = 0; i < element.getReasonReference().size(); i++)
3604      composeReference(t, "CommunicationRequest", "reasonReference", element.getReasonReference().get(i), i);
3605    for (int i = 0; i < element.getNote().size(); i++)
3606      composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i);
3607  }
3608
3609  protected void composeCommunicationRequestCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) {
3610    if (element == null) 
3611      return;
3612    Complex t;
3613    if (Utilities.noString(parentType))
3614      t = parent;
3615    else {
3616      t = parent.predicate("fhir:"+parentType+'.'+name);
3617    }
3618    composeBackboneElement(t, "payload", name, element, index);
3619    if (element.hasContent())
3620      composeType(t, "CommunicationRequest", "content", element.getContent(), -1);
3621  }
3622
3623  protected void composeCommunicationRequestCommunicationRequestRequesterComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestRequesterComponent element, int index) {
3624    if (element == null) 
3625      return;
3626    Complex t;
3627    if (Utilities.noString(parentType))
3628      t = parent;
3629    else {
3630      t = parent.predicate("fhir:"+parentType+'.'+name);
3631    }
3632    composeBackboneElement(t, "requester", name, element, index);
3633    if (element.hasAgent())
3634      composeReference(t, "CommunicationRequest", "agent", element.getAgent(), -1);
3635    if (element.hasOnBehalfOf())
3636      composeReference(t, "CommunicationRequest", "onBehalfOf", element.getOnBehalfOf(), -1);
3637  }
3638
3639  protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) {
3640    if (element == null) 
3641      return;
3642    Complex t;
3643    if (Utilities.noString(parentType))
3644      t = parent;
3645    else {
3646      t = parent.predicate("fhir:"+parentType+'.'+name);
3647    }
3648    composeDomainResource(t, "CompartmentDefinition", name, element, index);
3649    if (element.hasUrlElement())
3650      composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1);
3651    if (element.hasNameElement())
3652      composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1);
3653    if (element.hasTitleElement())
3654      composeString(t, "CompartmentDefinition", "title", element.getTitleElement(), -1);
3655    if (element.hasStatusElement())
3656      composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1);
3657    if (element.hasExperimentalElement())
3658      composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1);
3659    if (element.hasDateElement())
3660      composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1);
3661    if (element.hasPublisherElement())
3662      composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1);
3663    for (int i = 0; i < element.getContact().size(); i++)
3664      composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i);
3665    if (element.hasDescriptionElement())
3666      composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1);
3667    if (element.hasPurposeElement())
3668      composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1);
3669    for (int i = 0; i < element.getUseContext().size(); i++)
3670      composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i);
3671    for (int i = 0; i < element.getJurisdiction().size(); i++)
3672      composeCodeableConcept(t, "CompartmentDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
3673    if (element.hasCodeElement())
3674      composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1);
3675    if (element.hasSearchElement())
3676      composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1);
3677    for (int i = 0; i < element.getResource().size(); i++)
3678      composeCompartmentDefinitionCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i);
3679  }
3680
3681  protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) {
3682    if (element == null) 
3683      return;
3684    Complex t;
3685    if (Utilities.noString(parentType))
3686      t = parent;
3687    else {
3688      t = parent.predicate("fhir:"+parentType+'.'+name);
3689    }
3690    composeBackboneElement(t, "resource", name, element, index);
3691    if (element.hasCodeElement())
3692      composeCode(t, "CompartmentDefinition", "code", element.getCodeElement(), -1);
3693    for (int i = 0; i < element.getParam().size(); i++)
3694      composeString(t, "CompartmentDefinition", "param", element.getParam().get(i), i);
3695    if (element.hasDocumentationElement())
3696      composeString(t, "CompartmentDefinition", "documentation", element.getDocumentationElement(), -1);
3697  }
3698
3699  protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) {
3700    if (element == null) 
3701      return;
3702    Complex t;
3703    if (Utilities.noString(parentType))
3704      t = parent;
3705    else {
3706      t = parent.predicate("fhir:"+parentType+'.'+name);
3707    }
3708    composeDomainResource(t, "Composition", name, element, index);
3709    if (element.hasIdentifier())
3710      composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1);
3711    if (element.hasStatusElement())
3712      composeEnum(t, "Composition", "status", element.getStatusElement(), -1);
3713    if (element.hasType())
3714      composeCodeableConcept(t, "Composition", "type", element.getType(), -1);
3715    if (element.hasClass_())
3716      composeCodeableConcept(t, "Composition", "class", element.getClass_(), -1);
3717    if (element.hasSubject())
3718      composeReference(t, "Composition", "subject", element.getSubject(), -1);
3719    if (element.hasEncounter())
3720      composeReference(t, "Composition", "encounter", element.getEncounter(), -1);
3721    if (element.hasDateElement())
3722      composeDateTime(t, "Composition", "date", element.getDateElement(), -1);
3723    for (int i = 0; i < element.getAuthor().size(); i++)
3724      composeReference(t, "Composition", "author", element.getAuthor().get(i), i);
3725    if (element.hasTitleElement())
3726      composeString(t, "Composition", "title", element.getTitleElement(), -1);
3727    if (element.hasConfidentialityElement())
3728      composeEnum(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1);
3729    for (int i = 0; i < element.getAttester().size(); i++)
3730      composeCompositionCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i);
3731    if (element.hasCustodian())
3732      composeReference(t, "Composition", "custodian", element.getCustodian(), -1);
3733    for (int i = 0; i < element.getRelatesTo().size(); i++)
3734      composeCompositionCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i);
3735    for (int i = 0; i < element.getEvent().size(); i++)
3736      composeCompositionCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i);
3737    for (int i = 0; i < element.getSection().size(); i++)
3738      composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i);
3739  }
3740
3741  protected void composeCompositionCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) {
3742    if (element == null) 
3743      return;
3744    Complex t;
3745    if (Utilities.noString(parentType))
3746      t = parent;
3747    else {
3748      t = parent.predicate("fhir:"+parentType+'.'+name);
3749    }
3750    composeBackboneElement(t, "attester", name, element, index);
3751    for (int i = 0; i < element.getMode().size(); i++)
3752      composeEnum(t, "Composition", "mode", element.getMode().get(i), i);
3753    if (element.hasTimeElement())
3754      composeDateTime(t, "Composition", "time", element.getTimeElement(), -1);
3755    if (element.hasParty())
3756      composeReference(t, "Composition", "party", element.getParty(), -1);
3757  }
3758
3759  protected void composeCompositionCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) {
3760    if (element == null) 
3761      return;
3762    Complex t;
3763    if (Utilities.noString(parentType))
3764      t = parent;
3765    else {
3766      t = parent.predicate("fhir:"+parentType+'.'+name);
3767    }
3768    composeBackboneElement(t, "relatesTo", name, element, index);
3769    if (element.hasCodeElement())
3770      composeEnum(t, "Composition", "code", element.getCodeElement(), -1);
3771    if (element.hasTarget())
3772      composeType(t, "Composition", "target", element.getTarget(), -1);
3773  }
3774
3775  protected void composeCompositionCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) {
3776    if (element == null) 
3777      return;
3778    Complex t;
3779    if (Utilities.noString(parentType))
3780      t = parent;
3781    else {
3782      t = parent.predicate("fhir:"+parentType+'.'+name);
3783    }
3784    composeBackboneElement(t, "event", name, element, index);
3785    for (int i = 0; i < element.getCode().size(); i++)
3786      composeCodeableConcept(t, "Composition", "code", element.getCode().get(i), i);
3787    if (element.hasPeriod())
3788      composePeriod(t, "Composition", "period", element.getPeriod(), -1);
3789    for (int i = 0; i < element.getDetail().size(); i++)
3790      composeReference(t, "Composition", "detail", element.getDetail().get(i), i);
3791  }
3792
3793  protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) {
3794    if (element == null) 
3795      return;
3796    Complex t;
3797    if (Utilities.noString(parentType))
3798      t = parent;
3799    else {
3800      t = parent.predicate("fhir:"+parentType+'.'+name);
3801    }
3802    composeBackboneElement(t, "section", name, element, index);
3803    if (element.hasTitleElement())
3804      composeString(t, "Composition", "title", element.getTitleElement(), -1);
3805    if (element.hasCode())
3806      composeCodeableConcept(t, "Composition", "code", element.getCode(), -1);
3807    if (element.hasText())
3808      composeNarrative(t, "Composition", "text", element.getText(), -1);
3809    if (element.hasModeElement())
3810      composeEnum(t, "Composition", "mode", element.getModeElement(), -1);
3811    if (element.hasOrderedBy())
3812      composeCodeableConcept(t, "Composition", "orderedBy", element.getOrderedBy(), -1);
3813    for (int i = 0; i < element.getEntry().size(); i++)
3814      composeReference(t, "Composition", "entry", element.getEntry().get(i), i);
3815    if (element.hasEmptyReason())
3816      composeCodeableConcept(t, "Composition", "emptyReason", element.getEmptyReason(), -1);
3817    for (int i = 0; i < element.getSection().size(); i++)
3818      composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i);
3819  }
3820
3821  protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) {
3822    if (element == null) 
3823      return;
3824    Complex t;
3825    if (Utilities.noString(parentType))
3826      t = parent;
3827    else {
3828      t = parent.predicate("fhir:"+parentType+'.'+name);
3829    }
3830    composeDomainResource(t, "ConceptMap", name, element, index);
3831    if (element.hasUrlElement())
3832      composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1);
3833    if (element.hasIdentifier())
3834      composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier(), -1);
3835    if (element.hasVersionElement())
3836      composeString(t, "ConceptMap", "version", element.getVersionElement(), -1);
3837    if (element.hasNameElement())
3838      composeString(t, "ConceptMap", "name", element.getNameElement(), -1);
3839    if (element.hasTitleElement())
3840      composeString(t, "ConceptMap", "title", element.getTitleElement(), -1);
3841    if (element.hasStatusElement())
3842      composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1);
3843    if (element.hasExperimentalElement())
3844      composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1);
3845    if (element.hasDateElement())
3846      composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1);
3847    if (element.hasPublisherElement())
3848      composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1);
3849    for (int i = 0; i < element.getContact().size(); i++)
3850      composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i);
3851    if (element.hasDescriptionElement())
3852      composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1);
3853    for (int i = 0; i < element.getUseContext().size(); i++)
3854      composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i);
3855    for (int i = 0; i < element.getJurisdiction().size(); i++)
3856      composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i);
3857    if (element.hasPurposeElement())
3858      composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1);
3859    if (element.hasCopyrightElement())
3860      composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1);
3861    if (element.hasSource())
3862      composeType(t, "ConceptMap", "source", element.getSource(), -1);
3863    if (element.hasTarget())
3864      composeType(t, "ConceptMap", "target", element.getTarget(), -1);
3865    for (int i = 0; i < element.getGroup().size(); i++)
3866      composeConceptMapConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i);
3867  }
3868
3869  protected void composeConceptMapConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) {
3870    if (element == null) 
3871      return;
3872    Complex t;
3873    if (Utilities.noString(parentType))
3874      t = parent;
3875    else {
3876      t = parent.predicate("fhir:"+parentType+'.'+name);
3877    }
3878    composeBackboneElement(t, "group", name, element, index);
3879    if (element.hasSourceElement())
3880      composeUri(t, "ConceptMap", "source", element.getSourceElement(), -1);
3881    if (element.hasSourceVersionElement())
3882      composeString(t, "ConceptMap", "sourceVersion", element.getSourceVersionElement(), -1);
3883    if (element.hasTargetElement())
3884      composeUri(t, "ConceptMap", "target", element.getTargetElement(), -1);
3885    if (element.hasTargetVersionElement())
3886      composeString(t, "ConceptMap", "targetVersion", element.getTargetVersionElement(), -1);
3887    for (int i = 0; i < element.getElement().size(); i++)
3888      composeConceptMapSourceElementComponent(t, "ConceptMap", "element", element.getElement().get(i), i);
3889    if (element.hasUnmapped())
3890      composeConceptMapConceptMapGroupUnmappedComponent(t, "ConceptMap", "unmapped", element.getUnmapped(), -1);
3891  }
3892
3893  protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) {
3894    if (element == null) 
3895      return;
3896    Complex t;
3897    if (Utilities.noString(parentType))
3898      t = parent;
3899    else {
3900      t = parent.predicate("fhir:"+parentType+'.'+name);
3901    }
3902    composeBackboneElement(t, "element", name, element, index);
3903    if (element.hasCodeElement())
3904      composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1);
3905    if (element.hasDisplayElement())
3906      composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1);
3907    for (int i = 0; i < element.getTarget().size(); i++)
3908      composeConceptMapTargetElementComponent(t, "ConceptMap", "target", element.getTarget().get(i), i);
3909  }
3910
3911  protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) {
3912    if (element == null) 
3913      return;
3914    Complex t;
3915    if (Utilities.noString(parentType))
3916      t = parent;
3917    else {
3918      t = parent.predicate("fhir:"+parentType+'.'+name);
3919    }
3920    composeBackboneElement(t, "target", name, element, index);
3921    if (element.hasCodeElement())
3922      composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1);
3923    if (element.hasDisplayElement())
3924      composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1);
3925    if (element.hasEquivalenceElement())
3926      composeEnum(t, "ConceptMap", "equivalence", element.getEquivalenceElement(), -1);
3927    if (element.hasCommentElement())
3928      composeString(t, "ConceptMap", "comment", element.getCommentElement(), -1);
3929    for (int i = 0; i < element.getDependsOn().size(); i++)
3930      composeConceptMapOtherElementComponent(t, "ConceptMap", "dependsOn", element.getDependsOn().get(i), i);
3931    for (int i = 0; i < element.getProduct().size(); i++)
3932      composeConceptMapOtherElementComponent(t, "ConceptMap", "product", element.getProduct().get(i), i);
3933  }
3934
3935  protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) {
3936    if (element == null) 
3937      return;
3938    Complex t;
3939    if (Utilities.noString(parentType))
3940      t = parent;
3941    else {
3942      t = parent.predicate("fhir:"+parentType+'.'+name);
3943    }
3944    composeBackboneElement(t, "dependsOn", name, element, index);
3945    if (element.hasPropertyElement())
3946      composeUri(t, "ConceptMap", "property", element.getPropertyElement(), -1);
3947    if (element.hasSystemElement())
3948      composeUri(t, "ConceptMap", "system", element.getSystemElement(), -1);
3949    if (element.hasCodeElement())
3950      composeString(t, "ConceptMap", "code", element.getCodeElement(), -1);
3951    if (element.hasDisplayElement())
3952      composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1);
3953  }
3954
3955  protected void composeConceptMapConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) {
3956    if (element == null) 
3957      return;
3958    Complex t;
3959    if (Utilities.noString(parentType))
3960      t = parent;
3961    else {
3962      t = parent.predicate("fhir:"+parentType+'.'+name);
3963    }
3964    composeBackboneElement(t, "unmapped", name, element, index);
3965    if (element.hasModeElement())
3966      composeEnum(t, "ConceptMap", "mode", element.getModeElement(), -1);
3967    if (element.hasCodeElement())
3968      composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1);
3969    if (element.hasDisplayElement())
3970      composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1);
3971    if (element.hasUrlElement())
3972      composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1);
3973  }
3974
3975  protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) {
3976    if (element == null) 
3977      return;
3978    Complex t;
3979    if (Utilities.noString(parentType))
3980      t = parent;
3981    else {
3982      t = parent.predicate("fhir:"+parentType+'.'+name);
3983    }
3984    composeDomainResource(t, "Condition", name, element, index);
3985    for (int i = 0; i < element.getIdentifier().size(); i++)
3986      composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i);
3987    if (element.hasClinicalStatusElement())
3988      composeEnum(t, "Condition", "clinicalStatus", element.getClinicalStatusElement(), -1);
3989    if (element.hasVerificationStatusElement())
3990      composeEnum(t, "Condition", "verificationStatus", element.getVerificationStatusElement(), -1);
3991    for (int i = 0; i < element.getCategory().size(); i++)
3992      composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i);
3993    if (element.hasSeverity())
3994      composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1);
3995    if (element.hasCode())
3996      composeCodeableConcept(t, "Condition", "code", element.getCode(), -1);
3997    for (int i = 0; i < element.getBodySite().size(); i++)
3998      composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i);
3999    if (element.hasSubject())
4000      composeReference(t, "Condition", "subject", element.getSubject(), -1);
4001    if (element.hasContext())
4002      composeReference(t, "Condition", "context", element.getContext(), -1);
4003    if (element.hasOnset())
4004      composeType(t, "Condition", "onset", element.getOnset(), -1);
4005    if (element.hasAbatement())
4006      composeType(t, "Condition", "abatement", element.getAbatement(), -1);
4007    if (element.hasAssertedDateElement())
4008      composeDateTime(t, "Condition", "assertedDate", element.getAssertedDateElement(), -1);
4009    if (element.hasAsserter())
4010      composeReference(t, "Condition", "asserter", element.getAsserter(), -1);
4011    if (element.hasStage())
4012      composeConditionConditionStageComponent(t, "Condition", "stage", element.getStage(), -1);
4013    for (int i = 0; i < element.getEvidence().size(); i++)
4014      composeConditionConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i);
4015    for (int i = 0; i < element.getNote().size(); i++)
4016      composeAnnotation(t, "Condition", "note", element.getNote().get(i), i);
4017  }
4018
4019  protected void composeConditionConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) {
4020    if (element == null) 
4021      return;
4022    Complex t;
4023    if (Utilities.noString(parentType))
4024      t = parent;
4025    else {
4026      t = parent.predicate("fhir:"+parentType+'.'+name);
4027    }
4028    composeBackboneElement(t, "stage", name, element, index);
4029    if (element.hasSummary())
4030      composeCodeableConcept(t, "Condition", "summary", element.getSummary(), -1);
4031    for (int i = 0; i < element.getAssessment().size(); i++)
4032      composeReference(t, "Condition", "assessment", element.getAssessment().get(i), i);
4033  }
4034
4035  protected void composeConditionConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) {
4036    if (element == null) 
4037      return;
4038    Complex t;
4039    if (Utilities.noString(parentType))
4040      t = parent;
4041    else {
4042      t = parent.predicate("fhir:"+parentType+'.'+name);
4043    }
4044    composeBackboneElement(t, "evidence", name, element, index);
4045    for (int i = 0; i < element.getCode().size(); i++)
4046      composeCodeableConcept(t, "Condition", "code", element.getCode().get(i), i);
4047    for (int i = 0; i < element.getDetail().size(); i++)
4048      composeReference(t, "Condition", "detail", element.getDetail().get(i), i);
4049  }
4050
4051  protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) {
4052    if (element == null) 
4053      return;
4054    Complex t;
4055    if (Utilities.noString(parentType))
4056      t = parent;
4057    else {
4058      t = parent.predicate("fhir:"+parentType+'.'+name);
4059    }
4060    composeDomainResource(t, "Consent", name, element, index);
4061    if (element.hasIdentifier())
4062      composeIdentifier(t, "Consent", "identifier", element.getIdentifier(), -1);
4063    if (element.hasStatusElement())
4064      composeEnum(t, "Consent", "status", element.getStatusElement(), -1);
4065    for (int i = 0; i < element.getCategory().size(); i++)
4066      composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i);
4067    if (element.hasPatient())
4068      composeReference(t, "Consent", "patient", element.getPatient(), -1);
4069    if (element.hasPeriod())
4070      composePeriod(t, "Consent", "period", element.getPeriod(), -1);
4071    if (element.hasDateTimeElement())
4072      composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1);
4073    for (int i = 0; i < element.getConsentingParty().size(); i++)
4074      composeReference(t, "Consent", "consentingParty", element.getConsentingParty().get(i), i);
4075    for (int i = 0; i < element.getActor().size(); i++)
4076      composeConsentConsentActorComponent(t, "Consent", "actor", element.getActor().get(i), i);
4077    for (int i = 0; i < element.getAction().size(); i++)
4078      composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i);
4079    for (int i = 0; i < element.getOrganization().size(); i++)
4080      composeReference(t, "Consent", "organization", element.getOrganization().get(i), i);
4081    if (element.hasSource())
4082      composeType(t, "Consent", "source", element.getSource(), -1);
4083    for (int i = 0; i < element.getPolicy().size(); i++)
4084      composeConsentConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i);
4085    if (element.hasPolicyRuleElement())
4086      composeUri(t, "Consent", "policyRule", element.getPolicyRuleElement(), -1);
4087    for (int i = 0; i < element.getSecurityLabel().size(); i++)
4088      composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i);
4089    for (int i = 0; i < element.getPurpose().size(); i++)
4090      composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i);
4091    if (element.hasDataPeriod())
4092      composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1);
4093    for (int i = 0; i < element.getData().size(); i++)
4094      composeConsentConsentDataComponent(t, "Consent", "data", element.getData().get(i), i);
4095    for (int i = 0; i < element.getExcept().size(); i++)
4096      composeConsentExceptComponent(t, "Consent", "except", element.getExcept().get(i), i);
4097  }
4098
4099  protected void composeConsentConsentActorComponent(Complex parent, String parentType, String name, Consent.ConsentActorComponent element, int index) {
4100    if (element == null) 
4101      return;
4102    Complex t;
4103    if (Utilities.noString(parentType))
4104      t = parent;
4105    else {
4106      t = parent.predicate("fhir:"+parentType+'.'+name);
4107    }
4108    composeBackboneElement(t, "actor", name, element, index);
4109    if (element.hasRole())
4110      composeCodeableConcept(t, "Consent", "role", element.getRole(), -1);
4111    if (element.hasReference())
4112      composeReference(t, "Consent", "reference", element.getReference(), -1);
4113  }
4114
4115  protected void composeConsentConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) {
4116    if (element == null) 
4117      return;
4118    Complex t;
4119    if (Utilities.noString(parentType))
4120      t = parent;
4121    else {
4122      t = parent.predicate("fhir:"+parentType+'.'+name);
4123    }
4124    composeBackboneElement(t, "policy", name, element, index);
4125    if (element.hasAuthorityElement())
4126      composeUri(t, "Consent", "authority", element.getAuthorityElement(), -1);
4127    if (element.hasUriElement())
4128      composeUri(t, "Consent", "uri", element.getUriElement(), -1);
4129  }
4130
4131  protected void composeConsentConsentDataComponent(Complex parent, String parentType, String name, Consent.ConsentDataComponent element, int index) {
4132    if (element == null) 
4133      return;
4134    Complex t;
4135    if (Utilities.noString(parentType))
4136      t = parent;
4137    else {
4138      t = parent.predicate("fhir:"+parentType+'.'+name);
4139    }
4140    composeBackboneElement(t, "data", name, element, index);
4141    if (element.hasMeaningElement())
4142      composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1);
4143    if (element.hasReference())
4144      composeReference(t, "Consent", "reference", element.getReference(), -1);
4145  }
4146
4147  protected void composeConsentExceptComponent(Complex parent, String parentType, String name, Consent.ExceptComponent element, int index) {
4148    if (element == null) 
4149      return;
4150    Complex t;
4151    if (Utilities.noString(parentType))
4152      t = parent;
4153    else {
4154      t = parent.predicate("fhir:"+parentType+'.'+name);
4155    }
4156    composeBackboneElement(t, "except", name, element, index);
4157    if (element.hasTypeElement())
4158      composeEnum(t, "Consent", "type", element.getTypeElement(), -1);
4159    if (element.hasPeriod())
4160      composePeriod(t, "Consent", "period", element.getPeriod(), -1);
4161    for (int i = 0; i < element.getActor().size(); i++)
4162      composeConsentExceptActorComponent(t, "Consent", "actor", element.getActor().get(i), i);
4163    for (int i = 0; i < element.getAction().size(); i++)
4164      composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i);
4165    for (int i = 0; i < element.getSecurityLabel().size(); i++)
4166      composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i);
4167    for (int i = 0; i < element.getPurpose().size(); i++)
4168      composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i);
4169    for (int i = 0; i < element.getClass_().size(); i++)
4170      composeCoding(t, "Consent", "class", element.getClass_().get(i), i);
4171    for (int i = 0; i < element.getCode().size(); i++)
4172      composeCoding(t, "Consent", "code", element.getCode().get(i), i);
4173    if (element.hasDataPeriod())
4174      composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1);
4175    for (int i = 0; i < element.getData().size(); i++)
4176      composeConsentExceptDataComponent(t, "Consent", "data", element.getData().get(i), i);
4177  }
4178
4179  protected void composeConsentExceptActorComponent(Complex parent, String parentType, String name, Consent.ExceptActorComponent element, int index) {
4180    if (element == null) 
4181      return;
4182    Complex t;
4183    if (Utilities.noString(parentType))
4184      t = parent;
4185    else {
4186      t = parent.predicate("fhir:"+parentType+'.'+name);
4187    }
4188    composeBackboneElement(t, "actor", name, element, index);
4189    if (element.hasRole())
4190      composeCodeableConcept(t, "Consent", "role", element.getRole(), -1);
4191    if (element.hasReference())
4192      composeReference(t, "Consent", "reference", element.getReference(), -1);
4193  }
4194
4195  protected void composeConsentExceptDataComponent(Complex parent, String parentType, String name, Consent.ExceptDataComponent element, int index) {
4196    if (element == null) 
4197      return;
4198    Complex t;
4199    if (Utilities.noString(parentType))
4200      t = parent;
4201    else {
4202      t = parent.predicate("fhir:"+parentType+'.'+name);
4203    }
4204    composeBackboneElement(t, "data", name, element, index);
4205    if (element.hasMeaningElement())
4206      composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1);
4207    if (element.hasReference())
4208      composeReference(t, "Consent", "reference", element.getReference(), -1);
4209  }
4210
4211  protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) {
4212    if (element == null) 
4213      return;
4214    Complex t;
4215    if (Utilities.noString(parentType))
4216      t = parent;
4217    else {
4218      t = parent.predicate("fhir:"+parentType+'.'+name);
4219    }
4220    composeDomainResource(t, "Contract", name, element, index);
4221    if (element.hasIdentifier())
4222      composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1);
4223    if (element.hasStatusElement())
4224      composeEnum(t, "Contract", "status", element.getStatusElement(), -1);
4225    if (element.hasIssuedElement())
4226      composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1);
4227    if (element.hasApplies())
4228      composePeriod(t, "Contract", "applies", element.getApplies(), -1);
4229    for (int i = 0; i < element.getSubject().size(); i++)
4230      composeReference(t, "Contract", "subject", element.getSubject().get(i), i);
4231    for (int i = 0; i < element.getTopic().size(); i++)
4232      composeReference(t, "Contract", "topic", element.getTopic().get(i), i);
4233    for (int i = 0; i < element.getAuthority().size(); i++)
4234      composeReference(t, "Contract", "authority", element.getAuthority().get(i), i);
4235    for (int i = 0; i < element.getDomain().size(); i++)
4236      composeReference(t, "Contract", "domain", element.getDomain().get(i), i);
4237    if (element.hasType())
4238      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
4239    for (int i = 0; i < element.getSubType().size(); i++)
4240      composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i);
4241    for (int i = 0; i < element.getAction().size(); i++)
4242      composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i);
4243    for (int i = 0; i < element.getActionReason().size(); i++)
4244      composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i);
4245    if (element.hasDecisionType())
4246      composeCodeableConcept(t, "Contract", "decisionType", element.getDecisionType(), -1);
4247    if (element.hasContentDerivative())
4248      composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1);
4249    for (int i = 0; i < element.getSecurityLabel().size(); i++)
4250      composeCoding(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i);
4251    for (int i = 0; i < element.getAgent().size(); i++)
4252      composeContractAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i);
4253    for (int i = 0; i < element.getSigner().size(); i++)
4254      composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i);
4255    for (int i = 0; i < element.getValuedItem().size(); i++)
4256      composeContractValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i);
4257    for (int i = 0; i < element.getTerm().size(); i++)
4258      composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i);
4259    if (element.hasBinding())
4260      composeType(t, "Contract", "binding", element.getBinding(), -1);
4261    for (int i = 0; i < element.getFriendly().size(); i++)
4262      composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i);
4263    for (int i = 0; i < element.getLegal().size(); i++)
4264      composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i);
4265    for (int i = 0; i < element.getRule().size(); i++)
4266      composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i);
4267  }
4268
4269  protected void composeContractAgentComponent(Complex parent, String parentType, String name, Contract.AgentComponent element, int index) {
4270    if (element == null) 
4271      return;
4272    Complex t;
4273    if (Utilities.noString(parentType))
4274      t = parent;
4275    else {
4276      t = parent.predicate("fhir:"+parentType+'.'+name);
4277    }
4278    composeBackboneElement(t, "agent", name, element, index);
4279    if (element.hasActor())
4280      composeReference(t, "Contract", "actor", element.getActor(), -1);
4281    for (int i = 0; i < element.getRole().size(); i++)
4282      composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i);
4283  }
4284
4285  protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) {
4286    if (element == null) 
4287      return;
4288    Complex t;
4289    if (Utilities.noString(parentType))
4290      t = parent;
4291    else {
4292      t = parent.predicate("fhir:"+parentType+'.'+name);
4293    }
4294    composeBackboneElement(t, "signer", name, element, index);
4295    if (element.hasType())
4296      composeCoding(t, "Contract", "type", element.getType(), -1);
4297    if (element.hasParty())
4298      composeReference(t, "Contract", "party", element.getParty(), -1);
4299    for (int i = 0; i < element.getSignature().size(); i++)
4300      composeSignature(t, "Contract", "signature", element.getSignature().get(i), i);
4301  }
4302
4303  protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) {
4304    if (element == null) 
4305      return;
4306    Complex t;
4307    if (Utilities.noString(parentType))
4308      t = parent;
4309    else {
4310      t = parent.predicate("fhir:"+parentType+'.'+name);
4311    }
4312    composeBackboneElement(t, "valuedItem", name, element, index);
4313    if (element.hasEntity())
4314      composeType(t, "Contract", "entity", element.getEntity(), -1);
4315    if (element.hasIdentifier())
4316      composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1);
4317    if (element.hasEffectiveTimeElement())
4318      composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1);
4319    if (element.hasQuantity())
4320      composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1);
4321    if (element.hasUnitPrice())
4322      composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1);
4323    if (element.hasFactorElement())
4324      composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1);
4325    if (element.hasPointsElement())
4326      composeDecimal(t, "Contract", "points", element.getPointsElement(), -1);
4327    if (element.hasNet())
4328      composeMoney(t, "Contract", "net", element.getNet(), -1);
4329  }
4330
4331  protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) {
4332    if (element == null) 
4333      return;
4334    Complex t;
4335    if (Utilities.noString(parentType))
4336      t = parent;
4337    else {
4338      t = parent.predicate("fhir:"+parentType+'.'+name);
4339    }
4340    composeBackboneElement(t, "term", name, element, index);
4341    if (element.hasIdentifier())
4342      composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1);
4343    if (element.hasIssuedElement())
4344      composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1);
4345    if (element.hasApplies())
4346      composePeriod(t, "Contract", "applies", element.getApplies(), -1);
4347    if (element.hasType())
4348      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
4349    if (element.hasSubType())
4350      composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1);
4351    for (int i = 0; i < element.getTopic().size(); i++)
4352      composeReference(t, "Contract", "topic", element.getTopic().get(i), i);
4353    for (int i = 0; i < element.getAction().size(); i++)
4354      composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i);
4355    for (int i = 0; i < element.getActionReason().size(); i++)
4356      composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i);
4357    for (int i = 0; i < element.getSecurityLabel().size(); i++)
4358      composeCoding(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i);
4359    for (int i = 0; i < element.getAgent().size(); i++)
4360      composeContractTermAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i);
4361    if (element.hasTextElement())
4362      composeString(t, "Contract", "text", element.getTextElement(), -1);
4363    for (int i = 0; i < element.getValuedItem().size(); i++)
4364      composeContractTermValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i);
4365    for (int i = 0; i < element.getGroup().size(); i++)
4366      composeContractTermComponent(t, "Contract", "group", element.getGroup().get(i), i);
4367  }
4368
4369  protected void composeContractTermAgentComponent(Complex parent, String parentType, String name, Contract.TermAgentComponent element, int index) {
4370    if (element == null) 
4371      return;
4372    Complex t;
4373    if (Utilities.noString(parentType))
4374      t = parent;
4375    else {
4376      t = parent.predicate("fhir:"+parentType+'.'+name);
4377    }
4378    composeBackboneElement(t, "agent", name, element, index);
4379    if (element.hasActor())
4380      composeReference(t, "Contract", "actor", element.getActor(), -1);
4381    for (int i = 0; i < element.getRole().size(); i++)
4382      composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i);
4383  }
4384
4385  protected void composeContractTermValuedItemComponent(Complex parent, String parentType, String name, Contract.TermValuedItemComponent element, int index) {
4386    if (element == null) 
4387      return;
4388    Complex t;
4389    if (Utilities.noString(parentType))
4390      t = parent;
4391    else {
4392      t = parent.predicate("fhir:"+parentType+'.'+name);
4393    }
4394    composeBackboneElement(t, "valuedItem", name, element, index);
4395    if (element.hasEntity())
4396      composeType(t, "Contract", "entity", element.getEntity(), -1);
4397    if (element.hasIdentifier())
4398      composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1);
4399    if (element.hasEffectiveTimeElement())
4400      composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1);
4401    if (element.hasQuantity())
4402      composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1);
4403    if (element.hasUnitPrice())
4404      composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1);
4405    if (element.hasFactorElement())
4406      composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1);
4407    if (element.hasPointsElement())
4408      composeDecimal(t, "Contract", "points", element.getPointsElement(), -1);
4409    if (element.hasNet())
4410      composeMoney(t, "Contract", "net", element.getNet(), -1);
4411  }
4412
4413  protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) {
4414    if (element == null) 
4415      return;
4416    Complex t;
4417    if (Utilities.noString(parentType))
4418      t = parent;
4419    else {
4420      t = parent.predicate("fhir:"+parentType+'.'+name);
4421    }
4422    composeBackboneElement(t, "friendly", name, element, index);
4423    if (element.hasContent())
4424      composeType(t, "Contract", "content", element.getContent(), -1);
4425  }
4426
4427  protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) {
4428    if (element == null) 
4429      return;
4430    Complex t;
4431    if (Utilities.noString(parentType))
4432      t = parent;
4433    else {
4434      t = parent.predicate("fhir:"+parentType+'.'+name);
4435    }
4436    composeBackboneElement(t, "legal", name, element, index);
4437    if (element.hasContent())
4438      composeType(t, "Contract", "content", element.getContent(), -1);
4439  }
4440
4441  protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) {
4442    if (element == null) 
4443      return;
4444    Complex t;
4445    if (Utilities.noString(parentType))
4446      t = parent;
4447    else {
4448      t = parent.predicate("fhir:"+parentType+'.'+name);
4449    }
4450    composeBackboneElement(t, "rule", name, element, index);
4451    if (element.hasContent())
4452      composeType(t, "Contract", "content", element.getContent(), -1);
4453  }
4454
4455  protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) {
4456    if (element == null) 
4457      return;
4458    Complex t;
4459    if (Utilities.noString(parentType))
4460      t = parent;
4461    else {
4462      t = parent.predicate("fhir:"+parentType+'.'+name);
4463    }
4464    composeDomainResource(t, "Coverage", name, element, index);
4465    for (int i = 0; i < element.getIdentifier().size(); i++)
4466      composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i);
4467    if (element.hasStatusElement())
4468      composeEnum(t, "Coverage", "status", element.getStatusElement(), -1);
4469    if (element.hasType())
4470      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
4471    if (element.hasPolicyHolder())
4472      composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1);
4473    if (element.hasSubscriber())
4474      composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1);
4475    if (element.hasSubscriberIdElement())
4476      composeString(t, "Coverage", "subscriberId", element.getSubscriberIdElement(), -1);
4477    if (element.hasBeneficiary())
4478      composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1);
4479    if (element.hasRelationship())
4480      composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1);
4481    if (element.hasPeriod())
4482      composePeriod(t, "Coverage", "period", element.getPeriod(), -1);
4483    for (int i = 0; i < element.getPayor().size(); i++)
4484      composeReference(t, "Coverage", "payor", element.getPayor().get(i), i);
4485    if (element.hasGrouping())
4486      composeCoverageGroupComponent(t, "Coverage", "grouping", element.getGrouping(), -1);
4487    if (element.hasDependentElement())
4488      composeString(t, "Coverage", "dependent", element.getDependentElement(), -1);
4489    if (element.hasSequenceElement())
4490      composeString(t, "Coverage", "sequence", element.getSequenceElement(), -1);
4491    if (element.hasOrderElement())
4492      composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1);
4493    if (element.hasNetworkElement())
4494      composeString(t, "Coverage", "network", element.getNetworkElement(), -1);
4495    for (int i = 0; i < element.getContract().size(); i++)
4496      composeReference(t, "Coverage", "contract", element.getContract().get(i), i);
4497  }
4498
4499  protected void composeCoverageGroupComponent(Complex parent, String parentType, String name, Coverage.GroupComponent element, int index) {
4500    if (element == null) 
4501      return;
4502    Complex t;
4503    if (Utilities.noString(parentType))
4504      t = parent;
4505    else {
4506      t = parent.predicate("fhir:"+parentType+'.'+name);
4507    }
4508    composeBackboneElement(t, "grouping", name, element, index);
4509    if (element.hasGroupElement())
4510      composeString(t, "Coverage", "group", element.getGroupElement(), -1);
4511    if (element.hasGroupDisplayElement())
4512      composeString(t, "Coverage", "groupDisplay", element.getGroupDisplayElement(), -1);
4513    if (element.hasSubGroupElement())
4514      composeString(t, "Coverage", "subGroup", element.getSubGroupElement(), -1);
4515    if (element.hasSubGroupDisplayElement())
4516      composeString(t, "Coverage", "subGroupDisplay", element.getSubGroupDisplayElement(), -1);
4517    if (element.hasPlanElement())
4518      composeString(t, "Coverage", "plan", element.getPlanElement(), -1);
4519    if (element.hasPlanDisplayElement())
4520      composeString(t, "Coverage", "planDisplay", element.getPlanDisplayElement(), -1);
4521    if (element.hasSubPlanElement())
4522      composeString(t, "Coverage", "subPlan", element.getSubPlanElement(), -1);
4523    if (element.hasSubPlanDisplayElement())
4524      composeString(t, "Coverage", "subPlanDisplay", element.getSubPlanDisplayElement(), -1);
4525    if (element.hasClass_Element())
4526      composeString(t, "Coverage", "class", element.getClass_Element(), -1);
4527    if (element.hasClassDisplayElement())
4528      composeString(t, "Coverage", "classDisplay", element.getClassDisplayElement(), -1);
4529    if (element.hasSubClassElement())
4530      composeString(t, "Coverage", "subClass", element.getSubClassElement(), -1);
4531    if (element.hasSubClassDisplayElement())
4532      composeString(t, "Coverage", "subClassDisplay", element.getSubClassDisplayElement(), -1);
4533  }
4534
4535  protected void composeDataElement(Complex parent, String parentType, String name, DataElement element, int index) {
4536    if (element == null) 
4537      return;
4538    Complex t;
4539    if (Utilities.noString(parentType))
4540      t = parent;
4541    else {
4542      t = parent.predicate("fhir:"+parentType+'.'+name);
4543    }
4544    composeDomainResource(t, "DataElement", name, element, index);
4545    if (element.hasUrlElement())
4546      composeUri(t, "DataElement", "url", element.getUrlElement(), -1);
4547    for (int i = 0; i < element.getIdentifier().size(); i++)
4548      composeIdentifier(t, "DataElement", "identifier", element.getIdentifier().get(i), i);
4549    if (element.hasVersionElement())
4550      composeString(t, "DataElement", "version", element.getVersionElement(), -1);
4551    if (element.hasStatusElement())
4552      composeEnum(t, "DataElement", "status", element.getStatusElement(), -1);
4553    if (element.hasExperimentalElement())
4554      composeBoolean(t, "DataElement", "experimental", element.getExperimentalElement(), -1);
4555    if (element.hasDateElement())
4556      composeDateTime(t, "DataElement", "date", element.getDateElement(), -1);
4557    if (element.hasPublisherElement())
4558      composeString(t, "DataElement", "publisher", element.getPublisherElement(), -1);
4559    if (element.hasNameElement())
4560      composeString(t, "DataElement", "name", element.getNameElement(), -1);
4561    if (element.hasTitleElement())
4562      composeString(t, "DataElement", "title", element.getTitleElement(), -1);
4563    for (int i = 0; i < element.getContact().size(); i++)
4564      composeContactDetail(t, "DataElement", "contact", element.getContact().get(i), i);
4565    for (int i = 0; i < element.getUseContext().size(); i++)
4566      composeUsageContext(t, "DataElement", "useContext", element.getUseContext().get(i), i);
4567    for (int i = 0; i < element.getJurisdiction().size(); i++)
4568      composeCodeableConcept(t, "DataElement", "jurisdiction", element.getJurisdiction().get(i), i);
4569    if (element.hasCopyrightElement())
4570      composeMarkdown(t, "DataElement", "copyright", element.getCopyrightElement(), -1);
4571    if (element.hasStringencyElement())
4572      composeEnum(t, "DataElement", "stringency", element.getStringencyElement(), -1);
4573    for (int i = 0; i < element.getMapping().size(); i++)
4574      composeDataElementDataElementMappingComponent(t, "DataElement", "mapping", element.getMapping().get(i), i);
4575    for (int i = 0; i < element.getElement().size(); i++)
4576      composeElementDefinition(t, "DataElement", "element", element.getElement().get(i), i);
4577  }
4578
4579  protected void composeDataElementDataElementMappingComponent(Complex parent, String parentType, String name, DataElement.DataElementMappingComponent element, int index) {
4580    if (element == null) 
4581      return;
4582    Complex t;
4583    if (Utilities.noString(parentType))
4584      t = parent;
4585    else {
4586      t = parent.predicate("fhir:"+parentType+'.'+name);
4587    }
4588    composeBackboneElement(t, "mapping", name, element, index);
4589    if (element.hasIdentityElement())
4590      composeId(t, "DataElement", "identity", element.getIdentityElement(), -1);
4591    if (element.hasUriElement())
4592      composeUri(t, "DataElement", "uri", element.getUriElement(), -1);
4593    if (element.hasNameElement())
4594      composeString(t, "DataElement", "name", element.getNameElement(), -1);
4595    if (element.hasCommentElement())
4596      composeString(t, "DataElement", "comment", element.getCommentElement(), -1);
4597  }
4598
4599  protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) {
4600    if (element == null) 
4601      return;
4602    Complex t;
4603    if (Utilities.noString(parentType))
4604      t = parent;
4605    else {
4606      t = parent.predicate("fhir:"+parentType+'.'+name);
4607    }
4608    composeDomainResource(t, "DetectedIssue", name, element, index);
4609    if (element.hasIdentifier())
4610      composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier(), -1);
4611    if (element.hasStatusElement())
4612      composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1);
4613    if (element.hasCategory())
4614      composeCodeableConcept(t, "DetectedIssue", "category", element.getCategory(), -1);
4615    if (element.hasSeverityElement())
4616      composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1);
4617    if (element.hasPatient())
4618      composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1);
4619    if (element.hasDateElement())
4620      composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1);
4621    if (element.hasAuthor())
4622      composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1);
4623    for (int i = 0; i < element.getImplicated().size(); i++)
4624      composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i);
4625    if (element.hasDetailElement())
4626      composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1);
4627    if (element.hasReferenceElement())
4628      composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1);
4629    for (int i = 0; i < element.getMitigation().size(); i++)
4630      composeDetectedIssueDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i);
4631  }
4632
4633  protected void composeDetectedIssueDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) {
4634    if (element == null) 
4635      return;
4636    Complex t;
4637    if (Utilities.noString(parentType))
4638      t = parent;
4639    else {
4640      t = parent.predicate("fhir:"+parentType+'.'+name);
4641    }
4642    composeBackboneElement(t, "mitigation", name, element, index);
4643    if (element.hasAction())
4644      composeCodeableConcept(t, "DetectedIssue", "action", element.getAction(), -1);
4645    if (element.hasDateElement())
4646      composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1);
4647    if (element.hasAuthor())
4648      composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1);
4649  }
4650
4651  protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) {
4652    if (element == null) 
4653      return;
4654    Complex t;
4655    if (Utilities.noString(parentType))
4656      t = parent;
4657    else {
4658      t = parent.predicate("fhir:"+parentType+'.'+name);
4659    }
4660    composeDomainResource(t, "Device", name, element, index);
4661    for (int i = 0; i < element.getIdentifier().size(); i++)
4662      composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i);
4663    if (element.hasUdi())
4664      composeDeviceDeviceUdiComponent(t, "Device", "udi", element.getUdi(), -1);
4665    if (element.hasStatusElement())
4666      composeEnum(t, "Device", "status", element.getStatusElement(), -1);
4667    if (element.hasType())
4668      composeCodeableConcept(t, "Device", "type", element.getType(), -1);
4669    if (element.hasLotNumberElement())
4670      composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1);
4671    if (element.hasManufacturerElement())
4672      composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1);
4673    if (element.hasManufactureDateElement())
4674      composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1);
4675    if (element.hasExpirationDateElement())
4676      composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1);
4677    if (element.hasModelElement())
4678      composeString(t, "Device", "model", element.getModelElement(), -1);
4679    if (element.hasVersionElement())
4680      composeString(t, "Device", "version", element.getVersionElement(), -1);
4681    if (element.hasPatient())
4682      composeReference(t, "Device", "patient", element.getPatient(), -1);
4683    if (element.hasOwner())
4684      composeReference(t, "Device", "owner", element.getOwner(), -1);
4685    for (int i = 0; i < element.getContact().size(); i++)
4686      composeContactPoint(t, "Device", "contact", element.getContact().get(i), i);
4687    if (element.hasLocation())
4688      composeReference(t, "Device", "location", element.getLocation(), -1);
4689    if (element.hasUrlElement())
4690      composeUri(t, "Device", "url", element.getUrlElement(), -1);
4691    for (int i = 0; i < element.getNote().size(); i++)
4692      composeAnnotation(t, "Device", "note", element.getNote().get(i), i);
4693    for (int i = 0; i < element.getSafety().size(); i++)
4694      composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i);
4695  }
4696
4697  protected void composeDeviceDeviceUdiComponent(Complex parent, String parentType, String name, Device.DeviceUdiComponent element, int index) {
4698    if (element == null) 
4699      return;
4700    Complex t;
4701    if (Utilities.noString(parentType))
4702      t = parent;
4703    else {
4704      t = parent.predicate("fhir:"+parentType+'.'+name);
4705    }
4706    composeBackboneElement(t, "udi", name, element, index);
4707    if (element.hasDeviceIdentifierElement())
4708      composeString(t, "Device", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
4709    if (element.hasNameElement())
4710      composeString(t, "Device", "name", element.getNameElement(), -1);
4711    if (element.hasJurisdictionElement())
4712      composeUri(t, "Device", "jurisdiction", element.getJurisdictionElement(), -1);
4713    if (element.hasCarrierHRFElement())
4714      composeString(t, "Device", "carrierHRF", element.getCarrierHRFElement(), -1);
4715    if (element.hasCarrierAIDCElement())
4716      composeBase64Binary(t, "Device", "carrierAIDC", element.getCarrierAIDCElement(), -1);
4717    if (element.hasIssuerElement())
4718      composeUri(t, "Device", "issuer", element.getIssuerElement(), -1);
4719    if (element.hasEntryTypeElement())
4720      composeEnum(t, "Device", "entryType", element.getEntryTypeElement(), -1);
4721  }
4722
4723  protected void composeDeviceComponent(Complex parent, String parentType, String name, DeviceComponent element, int index) {
4724    if (element == null) 
4725      return;
4726    Complex t;
4727    if (Utilities.noString(parentType))
4728      t = parent;
4729    else {
4730      t = parent.predicate("fhir:"+parentType+'.'+name);
4731    }
4732    composeDomainResource(t, "DeviceComponent", name, element, index);
4733    if (element.hasIdentifier())
4734      composeIdentifier(t, "DeviceComponent", "identifier", element.getIdentifier(), -1);
4735    if (element.hasType())
4736      composeCodeableConcept(t, "DeviceComponent", "type", element.getType(), -1);
4737    if (element.hasLastSystemChangeElement())
4738      composeInstant(t, "DeviceComponent", "lastSystemChange", element.getLastSystemChangeElement(), -1);
4739    if (element.hasSource())
4740      composeReference(t, "DeviceComponent", "source", element.getSource(), -1);
4741    if (element.hasParent())
4742      composeReference(t, "DeviceComponent", "parent", element.getParent(), -1);
4743    for (int i = 0; i < element.getOperationalStatus().size(); i++)
4744      composeCodeableConcept(t, "DeviceComponent", "operationalStatus", element.getOperationalStatus().get(i), i);
4745    if (element.hasParameterGroup())
4746      composeCodeableConcept(t, "DeviceComponent", "parameterGroup", element.getParameterGroup(), -1);
4747    if (element.hasMeasurementPrincipleElement())
4748      composeEnum(t, "DeviceComponent", "measurementPrinciple", element.getMeasurementPrincipleElement(), -1);
4749    for (int i = 0; i < element.getProductionSpecification().size(); i++)
4750      composeDeviceComponentDeviceComponentProductionSpecificationComponent(t, "DeviceComponent", "productionSpecification", element.getProductionSpecification().get(i), i);
4751    if (element.hasLanguageCode())
4752      composeCodeableConcept(t, "DeviceComponent", "languageCode", element.getLanguageCode(), -1);
4753  }
4754
4755  protected void composeDeviceComponentDeviceComponentProductionSpecificationComponent(Complex parent, String parentType, String name, DeviceComponent.DeviceComponentProductionSpecificationComponent element, int index) {
4756    if (element == null) 
4757      return;
4758    Complex t;
4759    if (Utilities.noString(parentType))
4760      t = parent;
4761    else {
4762      t = parent.predicate("fhir:"+parentType+'.'+name);
4763    }
4764    composeBackboneElement(t, "productionSpecification", name, element, index);
4765    if (element.hasSpecType())
4766      composeCodeableConcept(t, "DeviceComponent", "specType", element.getSpecType(), -1);
4767    if (element.hasComponentId())
4768      composeIdentifier(t, "DeviceComponent", "componentId", element.getComponentId(), -1);
4769    if (element.hasProductionSpecElement())
4770      composeString(t, "DeviceComponent", "productionSpec", element.getProductionSpecElement(), -1);
4771  }
4772
4773  protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) {
4774    if (element == null) 
4775      return;
4776    Complex t;
4777    if (Utilities.noString(parentType))
4778      t = parent;
4779    else {
4780      t = parent.predicate("fhir:"+parentType+'.'+name);
4781    }
4782    composeDomainResource(t, "DeviceMetric", name, element, index);
4783    if (element.hasIdentifier())
4784      composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier(), -1);
4785    if (element.hasType())
4786      composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1);
4787    if (element.hasUnit())
4788      composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1);
4789    if (element.hasSource())
4790      composeReference(t, "DeviceMetric", "source", element.getSource(), -1);
4791    if (element.hasParent())
4792      composeReference(t, "DeviceMetric", "parent", element.getParent(), -1);
4793    if (element.hasOperationalStatusElement())
4794      composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1);
4795    if (element.hasColorElement())
4796      composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1);
4797    if (element.hasCategoryElement())
4798      composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1);
4799    if (element.hasMeasurementPeriod())
4800      composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1);
4801    for (int i = 0; i < element.getCalibration().size(); i++)
4802      composeDeviceMetricDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i);
4803  }
4804
4805  protected void composeDeviceMetricDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) {
4806    if (element == null) 
4807      return;
4808    Complex t;
4809    if (Utilities.noString(parentType))
4810      t = parent;
4811    else {
4812      t = parent.predicate("fhir:"+parentType+'.'+name);
4813    }
4814    composeBackboneElement(t, "calibration", name, element, index);
4815    if (element.hasTypeElement())
4816      composeEnum(t, "DeviceMetric", "type", element.getTypeElement(), -1);
4817    if (element.hasStateElement())
4818      composeEnum(t, "DeviceMetric", "state", element.getStateElement(), -1);
4819    if (element.hasTimeElement())
4820      composeInstant(t, "DeviceMetric", "time", element.getTimeElement(), -1);
4821  }
4822
4823  protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest element, int index) {
4824    if (element == null) 
4825      return;
4826    Complex t;
4827    if (Utilities.noString(parentType))
4828      t = parent;
4829    else {
4830      t = parent.predicate("fhir:"+parentType+'.'+name);
4831    }
4832    composeDomainResource(t, "DeviceRequest", name, element, index);
4833    for (int i = 0; i < element.getIdentifier().size(); i++)
4834      composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i);
4835    for (int i = 0; i < element.getDefinition().size(); i++)
4836      composeReference(t, "DeviceRequest", "definition", element.getDefinition().get(i), i);
4837    for (int i = 0; i < element.getBasedOn().size(); i++)
4838      composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i);
4839    for (int i = 0; i < element.getPriorRequest().size(); i++)
4840      composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i);
4841    if (element.hasGroupIdentifier())
4842      composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
4843    if (element.hasStatusElement())
4844      composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1);
4845    if (element.hasIntent())
4846      composeCodeableConcept(t, "DeviceRequest", "intent", element.getIntent(), -1);
4847    if (element.hasPriorityElement())
4848      composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1);
4849    if (element.hasCode())
4850      composeType(t, "DeviceRequest", "code", element.getCode(), -1);
4851    if (element.hasSubject())
4852      composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1);
4853    if (element.hasContext())
4854      composeReference(t, "DeviceRequest", "context", element.getContext(), -1);
4855    if (element.hasOccurrence())
4856      composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1);
4857    if (element.hasAuthoredOnElement())
4858      composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1);
4859    if (element.hasRequester())
4860      composeDeviceRequestDeviceRequestRequesterComponent(t, "DeviceRequest", "requester", element.getRequester(), -1);
4861    if (element.hasPerformerType())
4862      composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1);
4863    if (element.hasPerformer())
4864      composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1);
4865    for (int i = 0; i < element.getReasonCode().size(); i++)
4866      composeCodeableConcept(t, "DeviceRequest", "reasonCode", element.getReasonCode().get(i), i);
4867    for (int i = 0; i < element.getReasonReference().size(); i++)
4868      composeReference(t, "DeviceRequest", "reasonReference", element.getReasonReference().get(i), i);
4869    for (int i = 0; i < element.getSupportingInfo().size(); i++)
4870      composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
4871    for (int i = 0; i < element.getNote().size(); i++)
4872      composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i);
4873    for (int i = 0; i < element.getRelevantHistory().size(); i++)
4874      composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i);
4875  }
4876
4877  protected void composeDeviceRequestDeviceRequestRequesterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestRequesterComponent element, int index) {
4878    if (element == null) 
4879      return;
4880    Complex t;
4881    if (Utilities.noString(parentType))
4882      t = parent;
4883    else {
4884      t = parent.predicate("fhir:"+parentType+'.'+name);
4885    }
4886    composeBackboneElement(t, "requester", name, element, index);
4887    if (element.hasAgent())
4888      composeReference(t, "DeviceRequest", "agent", element.getAgent(), -1);
4889    if (element.hasOnBehalfOf())
4890      composeReference(t, "DeviceRequest", "onBehalfOf", element.getOnBehalfOf(), -1);
4891  }
4892
4893  protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) {
4894    if (element == null) 
4895      return;
4896    Complex t;
4897    if (Utilities.noString(parentType))
4898      t = parent;
4899    else {
4900      t = parent.predicate("fhir:"+parentType+'.'+name);
4901    }
4902    composeDomainResource(t, "DeviceUseStatement", name, element, index);
4903    for (int i = 0; i < element.getIdentifier().size(); i++)
4904      composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i);
4905    if (element.hasStatusElement())
4906      composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1);
4907    if (element.hasSubject())
4908      composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1);
4909    if (element.hasWhenUsed())
4910      composePeriod(t, "DeviceUseStatement", "whenUsed", element.getWhenUsed(), -1);
4911    if (element.hasTiming())
4912      composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1);
4913    if (element.hasRecordedOnElement())
4914      composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1);
4915    if (element.hasSource())
4916      composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1);
4917    if (element.hasDevice())
4918      composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1);
4919    for (int i = 0; i < element.getIndication().size(); i++)
4920      composeCodeableConcept(t, "DeviceUseStatement", "indication", element.getIndication().get(i), i);
4921    if (element.hasBodySite())
4922      composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1);
4923    for (int i = 0; i < element.getNote().size(); i++)
4924      composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i);
4925  }
4926
4927  protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) {
4928    if (element == null) 
4929      return;
4930    Complex t;
4931    if (Utilities.noString(parentType))
4932      t = parent;
4933    else {
4934      t = parent.predicate("fhir:"+parentType+'.'+name);
4935    }
4936    composeDomainResource(t, "DiagnosticReport", name, element, index);
4937    for (int i = 0; i < element.getIdentifier().size(); i++)
4938      composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i);
4939    for (int i = 0; i < element.getBasedOn().size(); i++)
4940      composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i);
4941    if (element.hasStatusElement())
4942      composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1);
4943    if (element.hasCategory())
4944      composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory(), -1);
4945    if (element.hasCode())
4946      composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1);
4947    if (element.hasSubject())
4948      composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1);
4949    if (element.hasContext())
4950      composeReference(t, "DiagnosticReport", "context", element.getContext(), -1);
4951    if (element.hasEffective())
4952      composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1);
4953    if (element.hasIssuedElement())
4954      composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1);
4955    for (int i = 0; i < element.getPerformer().size(); i++)
4956      composeDiagnosticReportDiagnosticReportPerformerComponent(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i);
4957    for (int i = 0; i < element.getSpecimen().size(); i++)
4958      composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i);
4959    for (int i = 0; i < element.getResult().size(); i++)
4960      composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i);
4961    for (int i = 0; i < element.getImagingStudy().size(); i++)
4962      composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i);
4963    for (int i = 0; i < element.getImage().size(); i++)
4964      composeDiagnosticReportDiagnosticReportImageComponent(t, "DiagnosticReport", "image", element.getImage().get(i), i);
4965    if (element.hasConclusionElement())
4966      composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1);
4967    for (int i = 0; i < element.getCodedDiagnosis().size(); i++)
4968      composeCodeableConcept(t, "DiagnosticReport", "codedDiagnosis", element.getCodedDiagnosis().get(i), i);
4969    for (int i = 0; i < element.getPresentedForm().size(); i++)
4970      composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i);
4971  }
4972
4973  protected void composeDiagnosticReportDiagnosticReportPerformerComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportPerformerComponent element, int index) {
4974    if (element == null) 
4975      return;
4976    Complex t;
4977    if (Utilities.noString(parentType))
4978      t = parent;
4979    else {
4980      t = parent.predicate("fhir:"+parentType+'.'+name);
4981    }
4982    composeBackboneElement(t, "performer", name, element, index);
4983    if (element.hasRole())
4984      composeCodeableConcept(t, "DiagnosticReport", "role", element.getRole(), -1);
4985    if (element.hasActor())
4986      composeReference(t, "DiagnosticReport", "actor", element.getActor(), -1);
4987  }
4988
4989  protected void composeDiagnosticReportDiagnosticReportImageComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportImageComponent element, int index) {
4990    if (element == null) 
4991      return;
4992    Complex t;
4993    if (Utilities.noString(parentType))
4994      t = parent;
4995    else {
4996      t = parent.predicate("fhir:"+parentType+'.'+name);
4997    }
4998    composeBackboneElement(t, "image", name, element, index);
4999    if (element.hasCommentElement())
5000      composeString(t, "DiagnosticReport", "comment", element.getCommentElement(), -1);
5001    if (element.hasLink())
5002      composeReference(t, "DiagnosticReport", "link", element.getLink(), -1);
5003  }
5004
5005  protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) {
5006    if (element == null) 
5007      return;
5008    Complex t;
5009    if (Utilities.noString(parentType))
5010      t = parent;
5011    else {
5012      t = parent.predicate("fhir:"+parentType+'.'+name);
5013    }
5014    composeDomainResource(t, "DocumentManifest", name, element, index);
5015    if (element.hasMasterIdentifier())
5016      composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1);
5017    for (int i = 0; i < element.getIdentifier().size(); i++)
5018      composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i);
5019    if (element.hasStatusElement())
5020      composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1);
5021    if (element.hasType())
5022      composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1);
5023    if (element.hasSubject())
5024      composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1);
5025    if (element.hasCreatedElement())
5026      composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1);
5027    for (int i = 0; i < element.getAuthor().size(); i++)
5028      composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i);
5029    for (int i = 0; i < element.getRecipient().size(); i++)
5030      composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i);
5031    if (element.hasSourceElement())
5032      composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1);
5033    if (element.hasDescriptionElement())
5034      composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1);
5035    for (int i = 0; i < element.getContent().size(); i++)
5036      composeDocumentManifestDocumentManifestContentComponent(t, "DocumentManifest", "content", element.getContent().get(i), i);
5037    for (int i = 0; i < element.getRelated().size(); i++)
5038      composeDocumentManifestDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i);
5039  }
5040
5041  protected void composeDocumentManifestDocumentManifestContentComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestContentComponent element, int index) {
5042    if (element == null) 
5043      return;
5044    Complex t;
5045    if (Utilities.noString(parentType))
5046      t = parent;
5047    else {
5048      t = parent.predicate("fhir:"+parentType+'.'+name);
5049    }
5050    composeBackboneElement(t, "content", name, element, index);
5051    if (element.hasP())
5052      composeType(t, "DocumentManifest", "p", element.getP(), -1);
5053  }
5054
5055  protected void composeDocumentManifestDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) {
5056    if (element == null) 
5057      return;
5058    Complex t;
5059    if (Utilities.noString(parentType))
5060      t = parent;
5061    else {
5062      t = parent.predicate("fhir:"+parentType+'.'+name);
5063    }
5064    composeBackboneElement(t, "related", name, element, index);
5065    if (element.hasIdentifier())
5066      composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier(), -1);
5067    if (element.hasRef())
5068      composeReference(t, "DocumentManifest", "ref", element.getRef(), -1);
5069  }
5070
5071  protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) {
5072    if (element == null) 
5073      return;
5074    Complex t;
5075    if (Utilities.noString(parentType))
5076      t = parent;
5077    else {
5078      t = parent.predicate("fhir:"+parentType+'.'+name);
5079    }
5080    composeDomainResource(t, "DocumentReference", name, element, index);
5081    if (element.hasMasterIdentifier())
5082      composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1);
5083    for (int i = 0; i < element.getIdentifier().size(); i++)
5084      composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i);
5085    if (element.hasStatusElement())
5086      composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1);
5087    if (element.hasDocStatusElement())
5088      composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1);
5089    if (element.hasType())
5090      composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1);
5091    if (element.hasClass_())
5092      composeCodeableConcept(t, "DocumentReference", "class", element.getClass_(), -1);
5093    if (element.hasSubject())
5094      composeReference(t, "DocumentReference", "subject", element.getSubject(), -1);
5095    if (element.hasCreatedElement())
5096      composeDateTime(t, "DocumentReference", "created", element.getCreatedElement(), -1);
5097    if (element.hasIndexedElement())
5098      composeInstant(t, "DocumentReference", "indexed", element.getIndexedElement(), -1);
5099    for (int i = 0; i < element.getAuthor().size(); i++)
5100      composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i);
5101    if (element.hasAuthenticator())
5102      composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1);
5103    if (element.hasCustodian())
5104      composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1);
5105    for (int i = 0; i < element.getRelatesTo().size(); i++)
5106      composeDocumentReferenceDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i);
5107    if (element.hasDescriptionElement())
5108      composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1);
5109    for (int i = 0; i < element.getSecurityLabel().size(); i++)
5110      composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i);
5111    for (int i = 0; i < element.getContent().size(); i++)
5112      composeDocumentReferenceDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i);
5113    if (element.hasContext())
5114      composeDocumentReferenceDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1);
5115  }
5116
5117  protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) {
5118    if (element == null) 
5119      return;
5120    Complex t;
5121    if (Utilities.noString(parentType))
5122      t = parent;
5123    else {
5124      t = parent.predicate("fhir:"+parentType+'.'+name);
5125    }
5126    composeBackboneElement(t, "relatesTo", name, element, index);
5127    if (element.hasCodeElement())
5128      composeEnum(t, "DocumentReference", "code", element.getCodeElement(), -1);
5129    if (element.hasTarget())
5130      composeReference(t, "DocumentReference", "target", element.getTarget(), -1);
5131  }
5132
5133  protected void composeDocumentReferenceDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) {
5134    if (element == null) 
5135      return;
5136    Complex t;
5137    if (Utilities.noString(parentType))
5138      t = parent;
5139    else {
5140      t = parent.predicate("fhir:"+parentType+'.'+name);
5141    }
5142    composeBackboneElement(t, "content", name, element, index);
5143    if (element.hasAttachment())
5144      composeAttachment(t, "DocumentReference", "attachment", element.getAttachment(), -1);
5145    if (element.hasFormat())
5146      composeCoding(t, "DocumentReference", "format", element.getFormat(), -1);
5147  }
5148
5149  protected void composeDocumentReferenceDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) {
5150    if (element == null) 
5151      return;
5152    Complex t;
5153    if (Utilities.noString(parentType))
5154      t = parent;
5155    else {
5156      t = parent.predicate("fhir:"+parentType+'.'+name);
5157    }
5158    composeBackboneElement(t, "context", name, element, index);
5159    if (element.hasEncounter())
5160      composeReference(t, "DocumentReference", "encounter", element.getEncounter(), -1);
5161    for (int i = 0; i < element.getEvent().size(); i++)
5162      composeCodeableConcept(t, "DocumentReference", "event", element.getEvent().get(i), i);
5163    if (element.hasPeriod())
5164      composePeriod(t, "DocumentReference", "period", element.getPeriod(), -1);
5165    if (element.hasFacilityType())
5166      composeCodeableConcept(t, "DocumentReference", "facilityType", element.getFacilityType(), -1);
5167    if (element.hasPracticeSetting())
5168      composeCodeableConcept(t, "DocumentReference", "practiceSetting", element.getPracticeSetting(), -1);
5169    if (element.hasSourcePatientInfo())
5170      composeReference(t, "DocumentReference", "sourcePatientInfo", element.getSourcePatientInfo(), -1);
5171    for (int i = 0; i < element.getRelated().size(); i++)
5172      composeDocumentReferenceDocumentReferenceContextRelatedComponent(t, "DocumentReference", "related", element.getRelated().get(i), i);
5173  }
5174
5175  protected void composeDocumentReferenceDocumentReferenceContextRelatedComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextRelatedComponent element, int index) {
5176    if (element == null) 
5177      return;
5178    Complex t;
5179    if (Utilities.noString(parentType))
5180      t = parent;
5181    else {
5182      t = parent.predicate("fhir:"+parentType+'.'+name);
5183    }
5184    composeBackboneElement(t, "related", name, element, index);
5185    if (element.hasIdentifier())
5186      composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier(), -1);
5187    if (element.hasRef())
5188      composeReference(t, "DocumentReference", "ref", element.getRef(), -1);
5189  }
5190
5191  protected void composeEligibilityRequest(Complex parent, String parentType, String name, EligibilityRequest element, int index) {
5192    if (element == null) 
5193      return;
5194    Complex t;
5195    if (Utilities.noString(parentType))
5196      t = parent;
5197    else {
5198      t = parent.predicate("fhir:"+parentType+'.'+name);
5199    }
5200    composeDomainResource(t, "EligibilityRequest", name, element, index);
5201    for (int i = 0; i < element.getIdentifier().size(); i++)
5202      composeIdentifier(t, "EligibilityRequest", "identifier", element.getIdentifier().get(i), i);
5203    if (element.hasStatusElement())
5204      composeEnum(t, "EligibilityRequest", "status", element.getStatusElement(), -1);
5205    if (element.hasPriority())
5206      composeCodeableConcept(t, "EligibilityRequest", "priority", element.getPriority(), -1);
5207    if (element.hasPatient())
5208      composeReference(t, "EligibilityRequest", "patient", element.getPatient(), -1);
5209    if (element.hasServiced())
5210      composeType(t, "EligibilityRequest", "serviced", element.getServiced(), -1);
5211    if (element.hasCreatedElement())
5212      composeDateTime(t, "EligibilityRequest", "created", element.getCreatedElement(), -1);
5213    if (element.hasEnterer())
5214      composeReference(t, "EligibilityRequest", "enterer", element.getEnterer(), -1);
5215    if (element.hasProvider())
5216      composeReference(t, "EligibilityRequest", "provider", element.getProvider(), -1);
5217    if (element.hasOrganization())
5218      composeReference(t, "EligibilityRequest", "organization", element.getOrganization(), -1);
5219    if (element.hasInsurer())
5220      composeReference(t, "EligibilityRequest", "insurer", element.getInsurer(), -1);
5221    if (element.hasFacility())
5222      composeReference(t, "EligibilityRequest", "facility", element.getFacility(), -1);
5223    if (element.hasCoverage())
5224      composeReference(t, "EligibilityRequest", "coverage", element.getCoverage(), -1);
5225    if (element.hasBusinessArrangementElement())
5226      composeString(t, "EligibilityRequest", "businessArrangement", element.getBusinessArrangementElement(), -1);
5227    if (element.hasBenefitCategory())
5228      composeCodeableConcept(t, "EligibilityRequest", "benefitCategory", element.getBenefitCategory(), -1);
5229    if (element.hasBenefitSubCategory())
5230      composeCodeableConcept(t, "EligibilityRequest", "benefitSubCategory", element.getBenefitSubCategory(), -1);
5231  }
5232
5233  protected void composeEligibilityResponse(Complex parent, String parentType, String name, EligibilityResponse element, int index) {
5234    if (element == null) 
5235      return;
5236    Complex t;
5237    if (Utilities.noString(parentType))
5238      t = parent;
5239    else {
5240      t = parent.predicate("fhir:"+parentType+'.'+name);
5241    }
5242    composeDomainResource(t, "EligibilityResponse", name, element, index);
5243    for (int i = 0; i < element.getIdentifier().size(); i++)
5244      composeIdentifier(t, "EligibilityResponse", "identifier", element.getIdentifier().get(i), i);
5245    if (element.hasStatusElement())
5246      composeEnum(t, "EligibilityResponse", "status", element.getStatusElement(), -1);
5247    if (element.hasCreatedElement())
5248      composeDateTime(t, "EligibilityResponse", "created", element.getCreatedElement(), -1);
5249    if (element.hasRequestProvider())
5250      composeReference(t, "EligibilityResponse", "requestProvider", element.getRequestProvider(), -1);
5251    if (element.hasRequestOrganization())
5252      composeReference(t, "EligibilityResponse", "requestOrganization", element.getRequestOrganization(), -1);
5253    if (element.hasRequest())
5254      composeReference(t, "EligibilityResponse", "request", element.getRequest(), -1);
5255    if (element.hasOutcome())
5256      composeCodeableConcept(t, "EligibilityResponse", "outcome", element.getOutcome(), -1);
5257    if (element.hasDispositionElement())
5258      composeString(t, "EligibilityResponse", "disposition", element.getDispositionElement(), -1);
5259    if (element.hasInsurer())
5260      composeReference(t, "EligibilityResponse", "insurer", element.getInsurer(), -1);
5261    if (element.hasInforceElement())
5262      composeBoolean(t, "EligibilityResponse", "inforce", element.getInforceElement(), -1);
5263    for (int i = 0; i < element.getInsurance().size(); i++)
5264      composeEligibilityResponseInsuranceComponent(t, "EligibilityResponse", "insurance", element.getInsurance().get(i), i);
5265    if (element.hasForm())
5266      composeCodeableConcept(t, "EligibilityResponse", "form", element.getForm(), -1);
5267    for (int i = 0; i < element.getError().size(); i++)
5268      composeEligibilityResponseErrorsComponent(t, "EligibilityResponse", "error", element.getError().get(i), i);
5269  }
5270
5271  protected void composeEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, EligibilityResponse.InsuranceComponent element, int index) {
5272    if (element == null) 
5273      return;
5274    Complex t;
5275    if (Utilities.noString(parentType))
5276      t = parent;
5277    else {
5278      t = parent.predicate("fhir:"+parentType+'.'+name);
5279    }
5280    composeBackboneElement(t, "insurance", name, element, index);
5281    if (element.hasCoverage())
5282      composeReference(t, "EligibilityResponse", "coverage", element.getCoverage(), -1);
5283    if (element.hasContract())
5284      composeReference(t, "EligibilityResponse", "contract", element.getContract(), -1);
5285    for (int i = 0; i < element.getBenefitBalance().size(); i++)
5286      composeEligibilityResponseBenefitsComponent(t, "EligibilityResponse", "benefitBalance", element.getBenefitBalance().get(i), i);
5287  }
5288
5289  protected void composeEligibilityResponseBenefitsComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitsComponent element, int index) {
5290    if (element == null) 
5291      return;
5292    Complex t;
5293    if (Utilities.noString(parentType))
5294      t = parent;
5295    else {
5296      t = parent.predicate("fhir:"+parentType+'.'+name);
5297    }
5298    composeBackboneElement(t, "benefitBalance", name, element, index);
5299    if (element.hasCategory())
5300      composeCodeableConcept(t, "EligibilityResponse", "category", element.getCategory(), -1);
5301    if (element.hasSubCategory())
5302      composeCodeableConcept(t, "EligibilityResponse", "subCategory", element.getSubCategory(), -1);
5303    if (element.hasExcludedElement())
5304      composeBoolean(t, "EligibilityResponse", "excluded", element.getExcludedElement(), -1);
5305    if (element.hasNameElement())
5306      composeString(t, "EligibilityResponse", "name", element.getNameElement(), -1);
5307    if (element.hasDescriptionElement())
5308      composeString(t, "EligibilityResponse", "description", element.getDescriptionElement(), -1);
5309    if (element.hasNetwork())
5310      composeCodeableConcept(t, "EligibilityResponse", "network", element.getNetwork(), -1);
5311    if (element.hasUnit())
5312      composeCodeableConcept(t, "EligibilityResponse", "unit", element.getUnit(), -1);
5313    if (element.hasTerm())
5314      composeCodeableConcept(t, "EligibilityResponse", "term", element.getTerm(), -1);
5315    for (int i = 0; i < element.getFinancial().size(); i++)
5316      composeEligibilityResponseBenefitComponent(t, "EligibilityResponse", "financial", element.getFinancial().get(i), i);
5317  }
5318
5319  protected void composeEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitComponent element, int index) {
5320    if (element == null) 
5321      return;
5322    Complex t;
5323    if (Utilities.noString(parentType))
5324      t = parent;
5325    else {
5326      t = parent.predicate("fhir:"+parentType+'.'+name);
5327    }
5328    composeBackboneElement(t, "financial", name, element, index);
5329    if (element.hasType())
5330      composeCodeableConcept(t, "EligibilityResponse", "type", element.getType(), -1);
5331    if (element.hasAllowed())
5332      composeType(t, "EligibilityResponse", "allowed", element.getAllowed(), -1);
5333    if (element.hasUsed())
5334      composeType(t, "EligibilityResponse", "used", element.getUsed(), -1);
5335  }
5336
5337  protected void composeEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, EligibilityResponse.ErrorsComponent element, int index) {
5338    if (element == null) 
5339      return;
5340    Complex t;
5341    if (Utilities.noString(parentType))
5342      t = parent;
5343    else {
5344      t = parent.predicate("fhir:"+parentType+'.'+name);
5345    }
5346    composeBackboneElement(t, "error", name, element, index);
5347    if (element.hasCode())
5348      composeCodeableConcept(t, "EligibilityResponse", "code", element.getCode(), -1);
5349  }
5350
5351  protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) {
5352    if (element == null) 
5353      return;
5354    Complex t;
5355    if (Utilities.noString(parentType))
5356      t = parent;
5357    else {
5358      t = parent.predicate("fhir:"+parentType+'.'+name);
5359    }
5360    composeDomainResource(t, "Encounter", name, element, index);
5361    for (int i = 0; i < element.getIdentifier().size(); i++)
5362      composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i);
5363    if (element.hasStatusElement())
5364      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
5365    for (int i = 0; i < element.getStatusHistory().size(); i++)
5366      composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i);
5367    if (element.hasClass_())
5368      composeCoding(t, "Encounter", "class", element.getClass_(), -1);
5369    for (int i = 0; i < element.getClassHistory().size(); i++)
5370      composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i);
5371    for (int i = 0; i < element.getType().size(); i++)
5372      composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i);
5373    if (element.hasPriority())
5374      composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1);
5375    if (element.hasSubject())
5376      composeReference(t, "Encounter", "subject", element.getSubject(), -1);
5377    for (int i = 0; i < element.getEpisodeOfCare().size(); i++)
5378      composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i);
5379    for (int i = 0; i < element.getIncomingReferral().size(); i++)
5380      composeReference(t, "Encounter", "incomingReferral", element.getIncomingReferral().get(i), i);
5381    for (int i = 0; i < element.getParticipant().size(); i++)
5382      composeEncounterEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i);
5383    if (element.hasAppointment())
5384      composeReference(t, "Encounter", "appointment", element.getAppointment(), -1);
5385    if (element.hasPeriod())
5386      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
5387    if (element.hasLength())
5388      composeDuration(t, "Encounter", "length", element.getLength(), -1);
5389    for (int i = 0; i < element.getReason().size(); i++)
5390      composeCodeableConcept(t, "Encounter", "reason", element.getReason().get(i), i);
5391    for (int i = 0; i < element.getDiagnosis().size(); i++)
5392      composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i);
5393    for (int i = 0; i < element.getAccount().size(); i++)
5394      composeReference(t, "Encounter", "account", element.getAccount().get(i), i);
5395    if (element.hasHospitalization())
5396      composeEncounterEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1);
5397    for (int i = 0; i < element.getLocation().size(); i++)
5398      composeEncounterEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i);
5399    if (element.hasServiceProvider())
5400      composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1);
5401    if (element.hasPartOf())
5402      composeReference(t, "Encounter", "partOf", element.getPartOf(), -1);
5403  }
5404
5405  protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent element, int index) {
5406    if (element == null) 
5407      return;
5408    Complex t;
5409    if (Utilities.noString(parentType))
5410      t = parent;
5411    else {
5412      t = parent.predicate("fhir:"+parentType+'.'+name);
5413    }
5414    composeBackboneElement(t, "statusHistory", name, element, index);
5415    if (element.hasStatusElement())
5416      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
5417    if (element.hasPeriod())
5418      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
5419  }
5420
5421  protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent element, int index) {
5422    if (element == null) 
5423      return;
5424    Complex t;
5425    if (Utilities.noString(parentType))
5426      t = parent;
5427    else {
5428      t = parent.predicate("fhir:"+parentType+'.'+name);
5429    }
5430    composeBackboneElement(t, "classHistory", name, element, index);
5431    if (element.hasClass_())
5432      composeCoding(t, "Encounter", "class", element.getClass_(), -1);
5433    if (element.hasPeriod())
5434      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
5435  }
5436
5437  protected void composeEncounterEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) {
5438    if (element == null) 
5439      return;
5440    Complex t;
5441    if (Utilities.noString(parentType))
5442      t = parent;
5443    else {
5444      t = parent.predicate("fhir:"+parentType+'.'+name);
5445    }
5446    composeBackboneElement(t, "participant", name, element, index);
5447    for (int i = 0; i < element.getType().size(); i++)
5448      composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i);
5449    if (element.hasPeriod())
5450      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
5451    if (element.hasIndividual())
5452      composeReference(t, "Encounter", "individual", element.getIndividual(), -1);
5453  }
5454
5455  protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) {
5456    if (element == null) 
5457      return;
5458    Complex t;
5459    if (Utilities.noString(parentType))
5460      t = parent;
5461    else {
5462      t = parent.predicate("fhir:"+parentType+'.'+name);
5463    }
5464    composeBackboneElement(t, "diagnosis", name, element, index);
5465    if (element.hasCondition())
5466      composeReference(t, "Encounter", "condition", element.getCondition(), -1);
5467    if (element.hasRole())
5468      composeCodeableConcept(t, "Encounter", "role", element.getRole(), -1);
5469    if (element.hasRankElement())
5470      composePositiveInt(t, "Encounter", "rank", element.getRankElement(), -1);
5471  }
5472
5473  protected void composeEncounterEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) {
5474    if (element == null) 
5475      return;
5476    Complex t;
5477    if (Utilities.noString(parentType))
5478      t = parent;
5479    else {
5480      t = parent.predicate("fhir:"+parentType+'.'+name);
5481    }
5482    composeBackboneElement(t, "hospitalization", name, element, index);
5483    if (element.hasPreAdmissionIdentifier())
5484      composeIdentifier(t, "Encounter", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1);
5485    if (element.hasOrigin())
5486      composeReference(t, "Encounter", "origin", element.getOrigin(), -1);
5487    if (element.hasAdmitSource())
5488      composeCodeableConcept(t, "Encounter", "admitSource", element.getAdmitSource(), -1);
5489    if (element.hasReAdmission())
5490      composeCodeableConcept(t, "Encounter", "reAdmission", element.getReAdmission(), -1);
5491    for (int i = 0; i < element.getDietPreference().size(); i++)
5492      composeCodeableConcept(t, "Encounter", "dietPreference", element.getDietPreference().get(i), i);
5493    for (int i = 0; i < element.getSpecialCourtesy().size(); i++)
5494      composeCodeableConcept(t, "Encounter", "specialCourtesy", element.getSpecialCourtesy().get(i), i);
5495    for (int i = 0; i < element.getSpecialArrangement().size(); i++)
5496      composeCodeableConcept(t, "Encounter", "specialArrangement", element.getSpecialArrangement().get(i), i);
5497    if (element.hasDestination())
5498      composeReference(t, "Encounter", "destination", element.getDestination(), -1);
5499    if (element.hasDischargeDisposition())
5500      composeCodeableConcept(t, "Encounter", "dischargeDisposition", element.getDischargeDisposition(), -1);
5501  }
5502
5503  protected void composeEncounterEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) {
5504    if (element == null) 
5505      return;
5506    Complex t;
5507    if (Utilities.noString(parentType))
5508      t = parent;
5509    else {
5510      t = parent.predicate("fhir:"+parentType+'.'+name);
5511    }
5512    composeBackboneElement(t, "location", name, element, index);
5513    if (element.hasLocation())
5514      composeReference(t, "Encounter", "location", element.getLocation(), -1);
5515    if (element.hasStatusElement())
5516      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
5517    if (element.hasPeriod())
5518      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
5519  }
5520
5521  protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) {
5522    if (element == null) 
5523      return;
5524    Complex t;
5525    if (Utilities.noString(parentType))
5526      t = parent;
5527    else {
5528      t = parent.predicate("fhir:"+parentType+'.'+name);
5529    }
5530    composeDomainResource(t, "Endpoint", name, element, index);
5531    for (int i = 0; i < element.getIdentifier().size(); i++)
5532      composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i);
5533    if (element.hasStatusElement())
5534      composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1);
5535    if (element.hasConnectionType())
5536      composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1);
5537    if (element.hasNameElement())
5538      composeString(t, "Endpoint", "name", element.getNameElement(), -1);
5539    if (element.hasManagingOrganization())
5540      composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1);
5541    for (int i = 0; i < element.getContact().size(); i++)
5542      composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i);
5543    if (element.hasPeriod())
5544      composePeriod(t, "Endpoint", "period", element.getPeriod(), -1);
5545    for (int i = 0; i < element.getPayloadType().size(); i++)
5546      composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i);
5547    for (int i = 0; i < element.getPayloadMimeType().size(); i++)
5548      composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i);
5549    if (element.hasAddressElement())
5550      composeUri(t, "Endpoint", "address", element.getAddressElement(), -1);
5551    for (int i = 0; i < element.getHeader().size(); i++)
5552      composeString(t, "Endpoint", "header", element.getHeader().get(i), i);
5553  }
5554
5555  protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) {
5556    if (element == null) 
5557      return;
5558    Complex t;
5559    if (Utilities.noString(parentType))
5560      t = parent;
5561    else {
5562      t = parent.predicate("fhir:"+parentType+'.'+name);
5563    }
5564    composeDomainResource(t, "EnrollmentRequest", name, element, index);
5565    for (int i = 0; i < element.getIdentifier().size(); i++)
5566      composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i);
5567    if (element.hasStatusElement())
5568      composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1);
5569    if (element.hasCreatedElement())
5570      composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1);
5571    if (element.hasInsurer())
5572      composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1);
5573    if (element.hasProvider())
5574      composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1);
5575    if (element.hasOrganization())
5576      composeReference(t, "EnrollmentRequest", "organization", element.getOrganization(), -1);
5577    if (element.hasSubject())
5578      composeReference(t, "EnrollmentRequest", "subject", element.getSubject(), -1);
5579    if (element.hasCoverage())
5580      composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1);
5581  }
5582
5583  protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) {
5584    if (element == null) 
5585      return;
5586    Complex t;
5587    if (Utilities.noString(parentType))
5588      t = parent;
5589    else {
5590      t = parent.predicate("fhir:"+parentType+'.'+name);
5591    }
5592    composeDomainResource(t, "EnrollmentResponse", name, element, index);
5593    for (int i = 0; i < element.getIdentifier().size(); i++)
5594      composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i);
5595    if (element.hasStatusElement())
5596      composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1);
5597    if (element.hasRequest())
5598      composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1);
5599    if (element.hasOutcome())
5600      composeCodeableConcept(t, "EnrollmentResponse", "outcome", element.getOutcome(), -1);
5601    if (element.hasDispositionElement())
5602      composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1);
5603    if (element.hasCreatedElement())
5604      composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1);
5605    if (element.hasOrganization())
5606      composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1);
5607    if (element.hasRequestProvider())
5608      composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1);
5609    if (element.hasRequestOrganization())
5610      composeReference(t, "EnrollmentResponse", "requestOrganization", element.getRequestOrganization(), -1);
5611  }
5612
5613  protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) {
5614    if (element == null) 
5615      return;
5616    Complex t;
5617    if (Utilities.noString(parentType))
5618      t = parent;
5619    else {
5620      t = parent.predicate("fhir:"+parentType+'.'+name);
5621    }
5622    composeDomainResource(t, "EpisodeOfCare", name, element, index);
5623    for (int i = 0; i < element.getIdentifier().size(); i++)
5624      composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i);
5625    if (element.hasStatusElement())
5626      composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1);
5627    for (int i = 0; i < element.getStatusHistory().size(); i++)
5628      composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i);
5629    for (int i = 0; i < element.getType().size(); i++)
5630      composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i);
5631    for (int i = 0; i < element.getDiagnosis().size(); i++)
5632      composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i);
5633    if (element.hasPatient())
5634      composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1);
5635    if (element.hasManagingOrganization())
5636      composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1);
5637    if (element.hasPeriod())
5638      composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1);
5639    for (int i = 0; i < element.getReferralRequest().size(); i++)
5640      composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i);
5641    if (element.hasCareManager())
5642      composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1);
5643    for (int i = 0; i < element.getTeam().size(); i++)
5644      composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i);
5645    for (int i = 0; i < element.getAccount().size(); i++)
5646      composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i);
5647  }
5648
5649  protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) {
5650    if (element == null) 
5651      return;
5652    Complex t;
5653    if (Utilities.noString(parentType))
5654      t = parent;
5655    else {
5656      t = parent.predicate("fhir:"+parentType+'.'+name);
5657    }
5658    composeBackboneElement(t, "statusHistory", name, element, index);
5659    if (element.hasStatusElement())
5660      composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1);
5661    if (element.hasPeriod())
5662      composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1);
5663  }
5664
5665  protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) {
5666    if (element == null) 
5667      return;
5668    Complex t;
5669    if (Utilities.noString(parentType))
5670      t = parent;
5671    else {
5672      t = parent.predicate("fhir:"+parentType+'.'+name);
5673    }
5674    composeBackboneElement(t, "diagnosis", name, element, index);
5675    if (element.hasCondition())
5676      composeReference(t, "EpisodeOfCare", "condition", element.getCondition(), -1);
5677    if (element.hasRole())
5678      composeCodeableConcept(t, "EpisodeOfCare", "role", element.getRole(), -1);
5679    if (element.hasRankElement())
5680      composePositiveInt(t, "EpisodeOfCare", "rank", element.getRankElement(), -1);
5681  }
5682
5683  protected void composeExpansionProfile(Complex parent, String parentType, String name, ExpansionProfile element, int index) {
5684    if (element == null) 
5685      return;
5686    Complex t;
5687    if (Utilities.noString(parentType))
5688      t = parent;
5689    else {
5690      t = parent.predicate("fhir:"+parentType+'.'+name);
5691    }
5692    composeDomainResource(t, "ExpansionProfile", name, element, index);
5693    if (element.hasUrlElement())
5694      composeUri(t, "ExpansionProfile", "url", element.getUrlElement(), -1);
5695    if (element.hasIdentifier())
5696      composeIdentifier(t, "ExpansionProfile", "identifier", element.getIdentifier(), -1);
5697    if (element.hasVersionElement())
5698      composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1);
5699    if (element.hasNameElement())
5700      composeString(t, "ExpansionProfile", "name", element.getNameElement(), -1);
5701    if (element.hasStatusElement())
5702      composeEnum(t, "ExpansionProfile", "status", element.getStatusElement(), -1);
5703    if (element.hasExperimentalElement())
5704      composeBoolean(t, "ExpansionProfile", "experimental", element.getExperimentalElement(), -1);
5705    if (element.hasDateElement())
5706      composeDateTime(t, "ExpansionProfile", "date", element.getDateElement(), -1);
5707    if (element.hasPublisherElement())
5708      composeString(t, "ExpansionProfile", "publisher", element.getPublisherElement(), -1);
5709    for (int i = 0; i < element.getContact().size(); i++)
5710      composeContactDetail(t, "ExpansionProfile", "contact", element.getContact().get(i), i);
5711    if (element.hasDescriptionElement())
5712      composeMarkdown(t, "ExpansionProfile", "description", element.getDescriptionElement(), -1);
5713    for (int i = 0; i < element.getUseContext().size(); i++)
5714      composeUsageContext(t, "ExpansionProfile", "useContext", element.getUseContext().get(i), i);
5715    for (int i = 0; i < element.getJurisdiction().size(); i++)
5716      composeCodeableConcept(t, "ExpansionProfile", "jurisdiction", element.getJurisdiction().get(i), i);
5717    for (int i = 0; i < element.getFixedVersion().size(); i++)
5718      composeExpansionProfileExpansionProfileFixedVersionComponent(t, "ExpansionProfile", "fixedVersion", element.getFixedVersion().get(i), i);
5719    if (element.hasExcludedSystem())
5720      composeExpansionProfileExpansionProfileExcludedSystemComponent(t, "ExpansionProfile", "excludedSystem", element.getExcludedSystem(), -1);
5721    if (element.hasIncludeDesignationsElement())
5722      composeBoolean(t, "ExpansionProfile", "includeDesignations", element.getIncludeDesignationsElement(), -1);
5723    if (element.hasDesignation())
5724      composeExpansionProfileExpansionProfileDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation(), -1);
5725    if (element.hasIncludeDefinitionElement())
5726      composeBoolean(t, "ExpansionProfile", "includeDefinition", element.getIncludeDefinitionElement(), -1);
5727    if (element.hasActiveOnlyElement())
5728      composeBoolean(t, "ExpansionProfile", "activeOnly", element.getActiveOnlyElement(), -1);
5729    if (element.hasExcludeNestedElement())
5730      composeBoolean(t, "ExpansionProfile", "excludeNested", element.getExcludeNestedElement(), -1);
5731    if (element.hasExcludeNotForUIElement())
5732      composeBoolean(t, "ExpansionProfile", "excludeNotForUI", element.getExcludeNotForUIElement(), -1);
5733    if (element.hasExcludePostCoordinatedElement())
5734      composeBoolean(t, "ExpansionProfile", "excludePostCoordinated", element.getExcludePostCoordinatedElement(), -1);
5735    if (element.hasDisplayLanguageElement())
5736      composeCode(t, "ExpansionProfile", "displayLanguage", element.getDisplayLanguageElement(), -1);
5737    if (element.hasLimitedExpansionElement())
5738      composeBoolean(t, "ExpansionProfile", "limitedExpansion", element.getLimitedExpansionElement(), -1);
5739  }
5740
5741  protected void composeExpansionProfileExpansionProfileFixedVersionComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileFixedVersionComponent element, int index) {
5742    if (element == null) 
5743      return;
5744    Complex t;
5745    if (Utilities.noString(parentType))
5746      t = parent;
5747    else {
5748      t = parent.predicate("fhir:"+parentType+'.'+name);
5749    }
5750    composeBackboneElement(t, "fixedVersion", name, element, index);
5751    if (element.hasSystemElement())
5752      composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1);
5753    if (element.hasVersionElement())
5754      composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1);
5755    if (element.hasModeElement())
5756      composeEnum(t, "ExpansionProfile", "mode", element.getModeElement(), -1);
5757  }
5758
5759  protected void composeExpansionProfileExpansionProfileExcludedSystemComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileExcludedSystemComponent element, int index) {
5760    if (element == null) 
5761      return;
5762    Complex t;
5763    if (Utilities.noString(parentType))
5764      t = parent;
5765    else {
5766      t = parent.predicate("fhir:"+parentType+'.'+name);
5767    }
5768    composeBackboneElement(t, "excludedSystem", name, element, index);
5769    if (element.hasSystemElement())
5770      composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1);
5771    if (element.hasVersionElement())
5772      composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1);
5773  }
5774
5775  protected void composeExpansionProfileExpansionProfileDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileDesignationComponent element, int index) {
5776    if (element == null) 
5777      return;
5778    Complex t;
5779    if (Utilities.noString(parentType))
5780      t = parent;
5781    else {
5782      t = parent.predicate("fhir:"+parentType+'.'+name);
5783    }
5784    composeBackboneElement(t, "designation", name, element, index);
5785    if (element.hasInclude())
5786      composeExpansionProfileDesignationIncludeComponent(t, "ExpansionProfile", "include", element.getInclude(), -1);
5787    if (element.hasExclude())
5788      composeExpansionProfileDesignationExcludeComponent(t, "ExpansionProfile", "exclude", element.getExclude(), -1);
5789  }
5790
5791  protected void composeExpansionProfileDesignationIncludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeComponent element, int index) {
5792    if (element == null) 
5793      return;
5794    Complex t;
5795    if (Utilities.noString(parentType))
5796      t = parent;
5797    else {
5798      t = parent.predicate("fhir:"+parentType+'.'+name);
5799    }
5800    composeBackboneElement(t, "include", name, element, index);
5801    for (int i = 0; i < element.getDesignation().size(); i++)
5802      composeExpansionProfileDesignationIncludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i);
5803  }
5804
5805  protected void composeExpansionProfileDesignationIncludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeDesignationComponent element, int index) {
5806    if (element == null) 
5807      return;
5808    Complex t;
5809    if (Utilities.noString(parentType))
5810      t = parent;
5811    else {
5812      t = parent.predicate("fhir:"+parentType+'.'+name);
5813    }
5814    composeBackboneElement(t, "designation", name, element, index);
5815    if (element.hasLanguageElement())
5816      composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1);
5817    if (element.hasUse())
5818      composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1);
5819  }
5820
5821  protected void composeExpansionProfileDesignationExcludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeComponent element, int index) {
5822    if (element == null) 
5823      return;
5824    Complex t;
5825    if (Utilities.noString(parentType))
5826      t = parent;
5827    else {
5828      t = parent.predicate("fhir:"+parentType+'.'+name);
5829    }
5830    composeBackboneElement(t, "exclude", name, element, index);
5831    for (int i = 0; i < element.getDesignation().size(); i++)
5832      composeExpansionProfileDesignationExcludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i);
5833  }
5834
5835  protected void composeExpansionProfileDesignationExcludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeDesignationComponent element, int index) {
5836    if (element == null) 
5837      return;
5838    Complex t;
5839    if (Utilities.noString(parentType))
5840      t = parent;
5841    else {
5842      t = parent.predicate("fhir:"+parentType+'.'+name);
5843    }
5844    composeBackboneElement(t, "designation", name, element, index);
5845    if (element.hasLanguageElement())
5846      composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1);
5847    if (element.hasUse())
5848      composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1);
5849  }
5850
5851  protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) {
5852    if (element == null) 
5853      return;
5854    Complex t;
5855    if (Utilities.noString(parentType))
5856      t = parent;
5857    else {
5858      t = parent.predicate("fhir:"+parentType+'.'+name);
5859    }
5860    composeDomainResource(t, "ExplanationOfBenefit", name, element, index);
5861    for (int i = 0; i < element.getIdentifier().size(); i++)
5862      composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i);
5863    if (element.hasStatusElement())
5864      composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1);
5865    if (element.hasType())
5866      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
5867    for (int i = 0; i < element.getSubType().size(); i++)
5868      composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType().get(i), i);
5869    if (element.hasPatient())
5870      composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1);
5871    if (element.hasBillablePeriod())
5872      composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1);
5873    if (element.hasCreatedElement())
5874      composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1);
5875    if (element.hasEnterer())
5876      composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1);
5877    if (element.hasInsurer())
5878      composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1);
5879    if (element.hasProvider())
5880      composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1);
5881    if (element.hasOrganization())
5882      composeReference(t, "ExplanationOfBenefit", "organization", element.getOrganization(), -1);
5883    if (element.hasReferral())
5884      composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1);
5885    if (element.hasFacility())
5886      composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1);
5887    if (element.hasClaim())
5888      composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1);
5889    if (element.hasClaimResponse())
5890      composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1);
5891    if (element.hasOutcome())
5892      composeCodeableConcept(t, "ExplanationOfBenefit", "outcome", element.getOutcome(), -1);
5893    if (element.hasDispositionElement())
5894      composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1);
5895    for (int i = 0; i < element.getRelated().size(); i++)
5896      composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i);
5897    if (element.hasPrescription())
5898      composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1);
5899    if (element.hasOriginalPrescription())
5900      composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1);
5901    if (element.hasPayee())
5902      composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1);
5903    for (int i = 0; i < element.getInformation().size(); i++)
5904      composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "information", element.getInformation().get(i), i);
5905    for (int i = 0; i < element.getCareTeam().size(); i++)
5906      composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i);
5907    for (int i = 0; i < element.getDiagnosis().size(); i++)
5908      composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i);
5909    for (int i = 0; i < element.getProcedure().size(); i++)
5910      composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i);
5911    if (element.hasPrecedenceElement())
5912      composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1);
5913    if (element.hasInsurance())
5914      composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance(), -1);
5915    if (element.hasAccident())
5916      composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1);
5917    if (element.hasEmploymentImpacted())
5918      composePeriod(t, "ExplanationOfBenefit", "employmentImpacted", element.getEmploymentImpacted(), -1);
5919    if (element.hasHospitalization())
5920      composePeriod(t, "ExplanationOfBenefit", "hospitalization", element.getHospitalization(), -1);
5921    for (int i = 0; i < element.getItem().size(); i++)
5922      composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i);
5923    for (int i = 0; i < element.getAddItem().size(); i++)
5924      composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i);
5925    if (element.hasTotalCost())
5926      composeMoney(t, "ExplanationOfBenefit", "totalCost", element.getTotalCost(), -1);
5927    if (element.hasUnallocDeductable())
5928      composeMoney(t, "ExplanationOfBenefit", "unallocDeductable", element.getUnallocDeductable(), -1);
5929    if (element.hasTotalBenefit())
5930      composeMoney(t, "ExplanationOfBenefit", "totalBenefit", element.getTotalBenefit(), -1);
5931    if (element.hasPayment())
5932      composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1);
5933    if (element.hasForm())
5934      composeCodeableConcept(t, "ExplanationOfBenefit", "form", element.getForm(), -1);
5935    for (int i = 0; i < element.getProcessNote().size(); i++)
5936      composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i);
5937    for (int i = 0; i < element.getBenefitBalance().size(); i++)
5938      composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i);
5939  }
5940
5941  protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) {
5942    if (element == null) 
5943      return;
5944    Complex t;
5945    if (Utilities.noString(parentType))
5946      t = parent;
5947    else {
5948      t = parent.predicate("fhir:"+parentType+'.'+name);
5949    }
5950    composeBackboneElement(t, "related", name, element, index);
5951    if (element.hasClaim())
5952      composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1);
5953    if (element.hasRelationship())
5954      composeCodeableConcept(t, "ExplanationOfBenefit", "relationship", element.getRelationship(), -1);
5955    if (element.hasReference())
5956      composeIdentifier(t, "ExplanationOfBenefit", "reference", element.getReference(), -1);
5957  }
5958
5959  protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) {
5960    if (element == null) 
5961      return;
5962    Complex t;
5963    if (Utilities.noString(parentType))
5964      t = parent;
5965    else {
5966      t = parent.predicate("fhir:"+parentType+'.'+name);
5967    }
5968    composeBackboneElement(t, "payee", name, element, index);
5969    if (element.hasType())
5970      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
5971    if (element.hasResourceType())
5972      composeCodeableConcept(t, "ExplanationOfBenefit", "resourceType", element.getResourceType(), -1);
5973    if (element.hasParty())
5974      composeReference(t, "ExplanationOfBenefit", "party", element.getParty(), -1);
5975  }
5976
5977  protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) {
5978    if (element == null) 
5979      return;
5980    Complex t;
5981    if (Utilities.noString(parentType))
5982      t = parent;
5983    else {
5984      t = parent.predicate("fhir:"+parentType+'.'+name);
5985    }
5986    composeBackboneElement(t, "information", name, element, index);
5987    if (element.hasSequenceElement())
5988      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
5989    if (element.hasCategory())
5990      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
5991    if (element.hasCode())
5992      composeCodeableConcept(t, "ExplanationOfBenefit", "code", element.getCode(), -1);
5993    if (element.hasTiming())
5994      composeType(t, "ExplanationOfBenefit", "timing", element.getTiming(), -1);
5995    if (element.hasValue())
5996      composeType(t, "ExplanationOfBenefit", "value", element.getValue(), -1);
5997    if (element.hasReason())
5998      composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1);
5999  }
6000
6001  protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) {
6002    if (element == null) 
6003      return;
6004    Complex t;
6005    if (Utilities.noString(parentType))
6006      t = parent;
6007    else {
6008      t = parent.predicate("fhir:"+parentType+'.'+name);
6009    }
6010    composeBackboneElement(t, "careTeam", name, element, index);
6011    if (element.hasSequenceElement())
6012      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
6013    if (element.hasProvider())
6014      composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1);
6015    if (element.hasResponsibleElement())
6016      composeBoolean(t, "ExplanationOfBenefit", "responsible", element.getResponsibleElement(), -1);
6017    if (element.hasRole())
6018      composeCodeableConcept(t, "ExplanationOfBenefit", "role", element.getRole(), -1);
6019    if (element.hasQualification())
6020      composeCodeableConcept(t, "ExplanationOfBenefit", "qualification", element.getQualification(), -1);
6021  }
6022
6023  protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) {
6024    if (element == null) 
6025      return;
6026    Complex t;
6027    if (Utilities.noString(parentType))
6028      t = parent;
6029    else {
6030      t = parent.predicate("fhir:"+parentType+'.'+name);
6031    }
6032    composeBackboneElement(t, "diagnosis", name, element, index);
6033    if (element.hasSequenceElement())
6034      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
6035    if (element.hasDiagnosis())
6036      composeType(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis(), -1);
6037    for (int i = 0; i < element.getType().size(); i++)
6038      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType().get(i), i);
6039    if (element.hasPackageCode())
6040      composeCodeableConcept(t, "ExplanationOfBenefit", "packageCode", element.getPackageCode(), -1);
6041  }
6042
6043  protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) {
6044    if (element == null) 
6045      return;
6046    Complex t;
6047    if (Utilities.noString(parentType))
6048      t = parent;
6049    else {
6050      t = parent.predicate("fhir:"+parentType+'.'+name);
6051    }
6052    composeBackboneElement(t, "procedure", name, element, index);
6053    if (element.hasSequenceElement())
6054      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
6055    if (element.hasDateElement())
6056      composeDateTime(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1);
6057    if (element.hasProcedure())
6058      composeType(t, "ExplanationOfBenefit", "procedure", element.getProcedure(), -1);
6059  }
6060
6061  protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) {
6062    if (element == null) 
6063      return;
6064    Complex t;
6065    if (Utilities.noString(parentType))
6066      t = parent;
6067    else {
6068      t = parent.predicate("fhir:"+parentType+'.'+name);
6069    }
6070    composeBackboneElement(t, "insurance", name, element, index);
6071    if (element.hasCoverage())
6072      composeReference(t, "ExplanationOfBenefit", "coverage", element.getCoverage(), -1);
6073    for (int i = 0; i < element.getPreAuthRef().size(); i++)
6074      composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i);
6075  }
6076
6077  protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) {
6078    if (element == null) 
6079      return;
6080    Complex t;
6081    if (Utilities.noString(parentType))
6082      t = parent;
6083    else {
6084      t = parent.predicate("fhir:"+parentType+'.'+name);
6085    }
6086    composeBackboneElement(t, "accident", name, element, index);
6087    if (element.hasDateElement())
6088      composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1);
6089    if (element.hasType())
6090      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
6091    if (element.hasLocation())
6092      composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1);
6093  }
6094
6095  protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent element, int index) {
6096    if (element == null) 
6097      return;
6098    Complex t;
6099    if (Utilities.noString(parentType))
6100      t = parent;
6101    else {
6102      t = parent.predicate("fhir:"+parentType+'.'+name);
6103    }
6104    composeBackboneElement(t, "item", name, element, index);
6105    if (element.hasSequenceElement())
6106      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
6107    for (int i = 0; i < element.getCareTeamLinkId().size(); i++)
6108      composePositiveInt(t, "ExplanationOfBenefit", "careTeamLinkId", element.getCareTeamLinkId().get(i), i);
6109    for (int i = 0; i < element.getDiagnosisLinkId().size(); i++)
6110      composePositiveInt(t, "ExplanationOfBenefit", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i);
6111    for (int i = 0; i < element.getProcedureLinkId().size(); i++)
6112      composePositiveInt(t, "ExplanationOfBenefit", "procedureLinkId", element.getProcedureLinkId().get(i), i);
6113    for (int i = 0; i < element.getInformationLinkId().size(); i++)
6114      composePositiveInt(t, "ExplanationOfBenefit", "informationLinkId", element.getInformationLinkId().get(i), i);
6115    if (element.hasRevenue())
6116      composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1);
6117    if (element.hasCategory())
6118      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
6119    if (element.hasService())
6120      composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1);
6121    for (int i = 0; i < element.getModifier().size(); i++)
6122      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
6123    for (int i = 0; i < element.getProgramCode().size(); i++)
6124      composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i);
6125    if (element.hasServiced())
6126      composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1);
6127    if (element.hasLocation())
6128      composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1);
6129    if (element.hasQuantity())
6130      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
6131    if (element.hasUnitPrice())
6132      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
6133    if (element.hasFactorElement())
6134      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
6135    if (element.hasNet())
6136      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
6137    for (int i = 0; i < element.getUdi().size(); i++)
6138      composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i);
6139    if (element.hasBodySite())
6140      composeCodeableConcept(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1);
6141    for (int i = 0; i < element.getSubSite().size(); i++)
6142      composeCodeableConcept(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i);
6143    for (int i = 0; i < element.getEncounter().size(); i++)
6144      composeReference(t, "ExplanationOfBenefit", "encounter", element.getEncounter().get(i), i);
6145    for (int i = 0; i < element.getNoteNumber().size(); i++)
6146      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
6147    for (int i = 0; i < element.getAdjudication().size(); i++)
6148      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
6149    for (int i = 0; i < element.getDetail().size(); i++)
6150      composeExplanationOfBenefitDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i);
6151  }
6152
6153  protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) {
6154    if (element == null) 
6155      return;
6156    Complex t;
6157    if (Utilities.noString(parentType))
6158      t = parent;
6159    else {
6160      t = parent.predicate("fhir:"+parentType+'.'+name);
6161    }
6162    composeBackboneElement(t, "adjudication", name, element, index);
6163    if (element.hasCategory())
6164      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
6165    if (element.hasReason())
6166      composeCodeableConcept(t, "ExplanationOfBenefit", "reason", element.getReason(), -1);
6167    if (element.hasAmount())
6168      composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1);
6169    if (element.hasValueElement())
6170      composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1);
6171  }
6172
6173  protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) {
6174    if (element == null) 
6175      return;
6176    Complex t;
6177    if (Utilities.noString(parentType))
6178      t = parent;
6179    else {
6180      t = parent.predicate("fhir:"+parentType+'.'+name);
6181    }
6182    composeBackboneElement(t, "detail", name, element, index);
6183    if (element.hasSequenceElement())
6184      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
6185    if (element.hasType())
6186      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
6187    if (element.hasRevenue())
6188      composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1);
6189    if (element.hasCategory())
6190      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
6191    if (element.hasService())
6192      composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1);
6193    for (int i = 0; i < element.getModifier().size(); i++)
6194      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
6195    for (int i = 0; i < element.getProgramCode().size(); i++)
6196      composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i);
6197    if (element.hasQuantity())
6198      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
6199    if (element.hasUnitPrice())
6200      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
6201    if (element.hasFactorElement())
6202      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
6203    if (element.hasNet())
6204      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
6205    for (int i = 0; i < element.getUdi().size(); i++)
6206      composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i);
6207    for (int i = 0; i < element.getNoteNumber().size(); i++)
6208      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
6209    for (int i = 0; i < element.getAdjudication().size(); i++)
6210      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
6211    for (int i = 0; i < element.getSubDetail().size(); i++)
6212      composeExplanationOfBenefitSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i);
6213  }
6214
6215  protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) {
6216    if (element == null) 
6217      return;
6218    Complex t;
6219    if (Utilities.noString(parentType))
6220      t = parent;
6221    else {
6222      t = parent.predicate("fhir:"+parentType+'.'+name);
6223    }
6224    composeBackboneElement(t, "subDetail", name, element, index);
6225    if (element.hasSequenceElement())
6226      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
6227    if (element.hasType())
6228      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
6229    if (element.hasRevenue())
6230      composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1);
6231    if (element.hasCategory())
6232      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
6233    if (element.hasService())
6234      composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1);
6235    for (int i = 0; i < element.getModifier().size(); i++)
6236      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
6237    for (int i = 0; i < element.getProgramCode().size(); i++)
6238      composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i);
6239    if (element.hasQuantity())
6240      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
6241    if (element.hasUnitPrice())
6242      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
6243    if (element.hasFactorElement())
6244      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
6245    if (element.hasNet())
6246      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
6247    for (int i = 0; i < element.getUdi().size(); i++)
6248      composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i);
6249    for (int i = 0; i < element.getNoteNumber().size(); i++)
6250      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
6251    for (int i = 0; i < element.getAdjudication().size(); i++)
6252      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
6253  }
6254
6255  protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) {
6256    if (element == null) 
6257      return;
6258    Complex t;
6259    if (Utilities.noString(parentType))
6260      t = parent;
6261    else {
6262      t = parent.predicate("fhir:"+parentType+'.'+name);
6263    }
6264    composeBackboneElement(t, "addItem", name, element, index);
6265    for (int i = 0; i < element.getSequenceLinkId().size(); i++)
6266      composePositiveInt(t, "ExplanationOfBenefit", "sequenceLinkId", element.getSequenceLinkId().get(i), i);
6267    if (element.hasRevenue())
6268      composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1);
6269    if (element.hasCategory())
6270      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
6271    if (element.hasService())
6272      composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1);
6273    for (int i = 0; i < element.getModifier().size(); i++)
6274      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
6275    if (element.hasFee())
6276      composeMoney(t, "ExplanationOfBenefit", "fee", element.getFee(), -1);
6277    for (int i = 0; i < element.getNoteNumber().size(); i++)
6278      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
6279    for (int i = 0; i < element.getAdjudication().size(); i++)
6280      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
6281    for (int i = 0; i < element.getDetail().size(); i++)
6282      composeExplanationOfBenefitAddedItemsDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i);
6283  }
6284
6285  protected void composeExplanationOfBenefitAddedItemsDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemsDetailComponent element, int index) {
6286    if (element == null) 
6287      return;
6288    Complex t;
6289    if (Utilities.noString(parentType))
6290      t = parent;
6291    else {
6292      t = parent.predicate("fhir:"+parentType+'.'+name);
6293    }
6294    composeBackboneElement(t, "detail", name, element, index);
6295    if (element.hasRevenue())
6296      composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1);
6297    if (element.hasCategory())
6298      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
6299    if (element.hasService())
6300      composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1);
6301    for (int i = 0; i < element.getModifier().size(); i++)
6302      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
6303    if (element.hasFee())
6304      composeMoney(t, "ExplanationOfBenefit", "fee", element.getFee(), -1);
6305    for (int i = 0; i < element.getNoteNumber().size(); i++)
6306      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
6307    for (int i = 0; i < element.getAdjudication().size(); i++)
6308      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
6309  }
6310
6311  protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) {
6312    if (element == null) 
6313      return;
6314    Complex t;
6315    if (Utilities.noString(parentType))
6316      t = parent;
6317    else {
6318      t = parent.predicate("fhir:"+parentType+'.'+name);
6319    }
6320    composeBackboneElement(t, "payment", name, element, index);
6321    if (element.hasType())
6322      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
6323    if (element.hasAdjustment())
6324      composeMoney(t, "ExplanationOfBenefit", "adjustment", element.getAdjustment(), -1);
6325    if (element.hasAdjustmentReason())
6326      composeCodeableConcept(t, "ExplanationOfBenefit", "adjustmentReason", element.getAdjustmentReason(), -1);
6327    if (element.hasDateElement())
6328      composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1);
6329    if (element.hasAmount())
6330      composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1);
6331    if (element.hasIdentifier())
6332      composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier(), -1);
6333  }
6334
6335  protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) {
6336    if (element == null) 
6337      return;
6338    Complex t;
6339    if (Utilities.noString(parentType))
6340      t = parent;
6341    else {
6342      t = parent.predicate("fhir:"+parentType+'.'+name);
6343    }
6344    composeBackboneElement(t, "processNote", name, element, index);
6345    if (element.hasNumberElement())
6346      composePositiveInt(t, "ExplanationOfBenefit", "number", element.getNumberElement(), -1);
6347    if (element.hasType())
6348      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
6349    if (element.hasTextElement())
6350      composeString(t, "ExplanationOfBenefit", "text", element.getTextElement(), -1);
6351    if (element.hasLanguage())
6352      composeCodeableConcept(t, "ExplanationOfBenefit", "language", element.getLanguage(), -1);
6353  }
6354
6355  protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) {
6356    if (element == null) 
6357      return;
6358    Complex t;
6359    if (Utilities.noString(parentType))
6360      t = parent;
6361    else {
6362      t = parent.predicate("fhir:"+parentType+'.'+name);
6363    }
6364    composeBackboneElement(t, "benefitBalance", name, element, index);
6365    if (element.hasCategory())
6366      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
6367    if (element.hasSubCategory())
6368      composeCodeableConcept(t, "ExplanationOfBenefit", "subCategory", element.getSubCategory(), -1);
6369    if (element.hasExcludedElement())
6370      composeBoolean(t, "ExplanationOfBenefit", "excluded", element.getExcludedElement(), -1);
6371    if (element.hasNameElement())
6372      composeString(t, "ExplanationOfBenefit", "name", element.getNameElement(), -1);
6373    if (element.hasDescriptionElement())
6374      composeString(t, "ExplanationOfBenefit", "description", element.getDescriptionElement(), -1);
6375    if (element.hasNetwork())
6376      composeCodeableConcept(t, "ExplanationOfBenefit", "network", element.getNetwork(), -1);
6377    if (element.hasUnit())
6378      composeCodeableConcept(t, "ExplanationOfBenefit", "unit", element.getUnit(), -1);
6379    if (element.hasTerm())
6380      composeCodeableConcept(t, "ExplanationOfBenefit", "term", element.getTerm(), -1);
6381    for (int i = 0; i < element.getFinancial().size(); i++)
6382      composeExplanationOfBenefitBenefitComponent(t, "ExplanationOfBenefit", "financial", element.getFinancial().get(i), i);
6383  }
6384
6385  protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) {
6386    if (element == null) 
6387      return;
6388    Complex t;
6389    if (Utilities.noString(parentType))
6390      t = parent;
6391    else {
6392      t = parent.predicate("fhir:"+parentType+'.'+name);
6393    }
6394    composeBackboneElement(t, "financial", name, element, index);
6395    if (element.hasType())
6396      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
6397    if (element.hasAllowed())
6398      composeType(t, "ExplanationOfBenefit", "allowed", element.getAllowed(), -1);
6399    if (element.hasUsed())
6400      composeType(t, "ExplanationOfBenefit", "used", element.getUsed(), -1);
6401  }
6402
6403  protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) {
6404    if (element == null) 
6405      return;
6406    Complex t;
6407    if (Utilities.noString(parentType))
6408      t = parent;
6409    else {
6410      t = parent.predicate("fhir:"+parentType+'.'+name);
6411    }
6412    composeDomainResource(t, "FamilyMemberHistory", name, element, index);
6413    for (int i = 0; i < element.getIdentifier().size(); i++)
6414      composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i);
6415    for (int i = 0; i < element.getDefinition().size(); i++)
6416      composeReference(t, "FamilyMemberHistory", "definition", element.getDefinition().get(i), i);
6417    if (element.hasStatusElement())
6418      composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1);
6419    if (element.hasNotDoneElement())
6420      composeBoolean(t, "FamilyMemberHistory", "notDone", element.getNotDoneElement(), -1);
6421    if (element.hasNotDoneReason())
6422      composeCodeableConcept(t, "FamilyMemberHistory", "notDoneReason", element.getNotDoneReason(), -1);
6423    if (element.hasPatient())
6424      composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1);
6425    if (element.hasDateElement())
6426      composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1);
6427    if (element.hasNameElement())
6428      composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1);
6429    if (element.hasRelationship())
6430      composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1);
6431    if (element.hasGenderElement())
6432      composeEnum(t, "FamilyMemberHistory", "gender", element.getGenderElement(), -1);
6433    if (element.hasBorn())
6434      composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1);
6435    if (element.hasAge())
6436      composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1);
6437    if (element.hasEstimatedAgeElement())
6438      composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1);
6439    if (element.hasDeceased())
6440      composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1);
6441    for (int i = 0; i < element.getReasonCode().size(); i++)
6442      composeCodeableConcept(t, "FamilyMemberHistory", "reasonCode", element.getReasonCode().get(i), i);
6443    for (int i = 0; i < element.getReasonReference().size(); i++)
6444      composeReference(t, "FamilyMemberHistory", "reasonReference", element.getReasonReference().get(i), i);
6445    for (int i = 0; i < element.getNote().size(); i++)
6446      composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i);
6447    for (int i = 0; i < element.getCondition().size(); i++)
6448      composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i);
6449  }
6450
6451  protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) {
6452    if (element == null) 
6453      return;
6454    Complex t;
6455    if (Utilities.noString(parentType))
6456      t = parent;
6457    else {
6458      t = parent.predicate("fhir:"+parentType+'.'+name);
6459    }
6460    composeBackboneElement(t, "condition", name, element, index);
6461    if (element.hasCode())
6462      composeCodeableConcept(t, "FamilyMemberHistory", "code", element.getCode(), -1);
6463    if (element.hasOutcome())
6464      composeCodeableConcept(t, "FamilyMemberHistory", "outcome", element.getOutcome(), -1);
6465    if (element.hasOnset())
6466      composeType(t, "FamilyMemberHistory", "onset", element.getOnset(), -1);
6467    for (int i = 0; i < element.getNote().size(); i++)
6468      composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i);
6469  }
6470
6471  protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) {
6472    if (element == null) 
6473      return;
6474    Complex t;
6475    if (Utilities.noString(parentType))
6476      t = parent;
6477    else {
6478      t = parent.predicate("fhir:"+parentType+'.'+name);
6479    }
6480    composeDomainResource(t, "Flag", name, element, index);
6481    for (int i = 0; i < element.getIdentifier().size(); i++)
6482      composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i);
6483    if (element.hasStatusElement())
6484      composeEnum(t, "Flag", "status", element.getStatusElement(), -1);
6485    if (element.hasCategory())
6486      composeCodeableConcept(t, "Flag", "category", element.getCategory(), -1);
6487    if (element.hasCode())
6488      composeCodeableConcept(t, "Flag", "code", element.getCode(), -1);
6489    if (element.hasSubject())
6490      composeReference(t, "Flag", "subject", element.getSubject(), -1);
6491    if (element.hasPeriod())
6492      composePeriod(t, "Flag", "period", element.getPeriod(), -1);
6493    if (element.hasEncounter())
6494      composeReference(t, "Flag", "encounter", element.getEncounter(), -1);
6495    if (element.hasAuthor())
6496      composeReference(t, "Flag", "author", element.getAuthor(), -1);
6497  }
6498
6499  protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) {
6500    if (element == null) 
6501      return;
6502    Complex t;
6503    if (Utilities.noString(parentType))
6504      t = parent;
6505    else {
6506      t = parent.predicate("fhir:"+parentType+'.'+name);
6507    }
6508    composeDomainResource(t, "Goal", name, element, index);
6509    for (int i = 0; i < element.getIdentifier().size(); i++)
6510      composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i);
6511    if (element.hasStatusElement())
6512      composeEnum(t, "Goal", "status", element.getStatusElement(), -1);
6513    for (int i = 0; i < element.getCategory().size(); i++)
6514      composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i);
6515    if (element.hasPriority())
6516      composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1);
6517    if (element.hasDescription())
6518      composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1);
6519    if (element.hasSubject())
6520      composeReference(t, "Goal", "subject", element.getSubject(), -1);
6521    if (element.hasStart())
6522      composeType(t, "Goal", "start", element.getStart(), -1);
6523    if (element.hasTarget())
6524      composeGoalGoalTargetComponent(t, "Goal", "target", element.getTarget(), -1);
6525    if (element.hasStatusDateElement())
6526      composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1);
6527    if (element.hasStatusReasonElement())
6528      composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1);
6529    if (element.hasExpressedBy())
6530      composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1);
6531    for (int i = 0; i < element.getAddresses().size(); i++)
6532      composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i);
6533    for (int i = 0; i < element.getNote().size(); i++)
6534      composeAnnotation(t, "Goal", "note", element.getNote().get(i), i);
6535    for (int i = 0; i < element.getOutcomeCode().size(); i++)
6536      composeCodeableConcept(t, "Goal", "outcomeCode", element.getOutcomeCode().get(i), i);
6537    for (int i = 0; i < element.getOutcomeReference().size(); i++)
6538      composeReference(t, "Goal", "outcomeReference", element.getOutcomeReference().get(i), i);
6539  }
6540
6541  protected void composeGoalGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent element, int index) {
6542    if (element == null) 
6543      return;
6544    Complex t;
6545    if (Utilities.noString(parentType))
6546      t = parent;
6547    else {
6548      t = parent.predicate("fhir:"+parentType+'.'+name);
6549    }
6550    composeBackboneElement(t, "target", name, element, index);
6551    if (element.hasMeasure())
6552      composeCodeableConcept(t, "Goal", "measure", element.getMeasure(), -1);
6553    if (element.hasDetail())
6554      composeType(t, "Goal", "detail", element.getDetail(), -1);
6555    if (element.hasDue())
6556      composeType(t, "Goal", "due", element.getDue(), -1);
6557  }
6558
6559  protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) {
6560    if (element == null) 
6561      return;
6562    Complex t;
6563    if (Utilities.noString(parentType))
6564      t = parent;
6565    else {
6566      t = parent.predicate("fhir:"+parentType+'.'+name);
6567    }
6568    composeDomainResource(t, "GraphDefinition", name, element, index);
6569    if (element.hasUrlElement())
6570      composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1);
6571    if (element.hasVersionElement())
6572      composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1);
6573    if (element.hasNameElement())
6574      composeString(t, "GraphDefinition", "name", element.getNameElement(), -1);
6575    if (element.hasStatusElement())
6576      composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1);
6577    if (element.hasExperimentalElement())
6578      composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1);
6579    if (element.hasDateElement())
6580      composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1);
6581    if (element.hasPublisherElement())
6582      composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1);
6583    for (int i = 0; i < element.getContact().size(); i++)
6584      composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i);
6585    if (element.hasDescriptionElement())
6586      composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
6587    for (int i = 0; i < element.getUseContext().size(); i++)
6588      composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i);
6589    for (int i = 0; i < element.getJurisdiction().size(); i++)
6590      composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
6591    if (element.hasPurposeElement())
6592      composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1);
6593    if (element.hasStartElement())
6594      composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1);
6595    if (element.hasProfileElement())
6596      composeUri(t, "GraphDefinition", "profile", element.getProfileElement(), -1);
6597    for (int i = 0; i < element.getLink().size(); i++)
6598      composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i);
6599  }
6600
6601  protected void composeGraphDefinitionGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) {
6602    if (element == null) 
6603      return;
6604    Complex t;
6605    if (Utilities.noString(parentType))
6606      t = parent;
6607    else {
6608      t = parent.predicate("fhir:"+parentType+'.'+name);
6609    }
6610    composeBackboneElement(t, "link", name, element, index);
6611    if (element.hasPathElement())
6612      composeString(t, "GraphDefinition", "path", element.getPathElement(), -1);
6613    if (element.hasSliceNameElement())
6614      composeString(t, "GraphDefinition", "sliceName", element.getSliceNameElement(), -1);
6615    if (element.hasMinElement())
6616      composeInteger(t, "GraphDefinition", "min", element.getMinElement(), -1);
6617    if (element.hasMaxElement())
6618      composeString(t, "GraphDefinition", "max", element.getMaxElement(), -1);
6619    if (element.hasDescriptionElement())
6620      composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
6621    for (int i = 0; i < element.getTarget().size(); i++)
6622      composeGraphDefinitionGraphDefinitionLinkTargetComponent(t, "GraphDefinition", "target", element.getTarget().get(i), i);
6623  }
6624
6625  protected void composeGraphDefinitionGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) {
6626    if (element == null) 
6627      return;
6628    Complex t;
6629    if (Utilities.noString(parentType))
6630      t = parent;
6631    else {
6632      t = parent.predicate("fhir:"+parentType+'.'+name);
6633    }
6634    composeBackboneElement(t, "target", name, element, index);
6635    if (element.hasTypeElement())
6636      composeCode(t, "GraphDefinition", "type", element.getTypeElement(), -1);
6637    if (element.hasProfileElement())
6638      composeUri(t, "GraphDefinition", "profile", element.getProfileElement(), -1);
6639    for (int i = 0; i < element.getCompartment().size(); i++)
6640      composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinition", "compartment", element.getCompartment().get(i), i);
6641    for (int i = 0; i < element.getLink().size(); i++)
6642      composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i);
6643  }
6644
6645  protected void composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent element, int index) {
6646    if (element == null) 
6647      return;
6648    Complex t;
6649    if (Utilities.noString(parentType))
6650      t = parent;
6651    else {
6652      t = parent.predicate("fhir:"+parentType+'.'+name);
6653    }
6654    composeBackboneElement(t, "compartment", name, element, index);
6655    if (element.hasCodeElement())
6656      composeEnum(t, "GraphDefinition", "code", element.getCodeElement(), -1);
6657    if (element.hasRuleElement())
6658      composeEnum(t, "GraphDefinition", "rule", element.getRuleElement(), -1);
6659    if (element.hasExpressionElement())
6660      composeString(t, "GraphDefinition", "expression", element.getExpressionElement(), -1);
6661    if (element.hasDescriptionElement())
6662      composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
6663  }
6664
6665  protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) {
6666    if (element == null) 
6667      return;
6668    Complex t;
6669    if (Utilities.noString(parentType))
6670      t = parent;
6671    else {
6672      t = parent.predicate("fhir:"+parentType+'.'+name);
6673    }
6674    composeDomainResource(t, "Group", name, element, index);
6675    for (int i = 0; i < element.getIdentifier().size(); i++)
6676      composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i);
6677    if (element.hasActiveElement())
6678      composeBoolean(t, "Group", "active", element.getActiveElement(), -1);
6679    if (element.hasTypeElement())
6680      composeEnum(t, "Group", "type", element.getTypeElement(), -1);
6681    if (element.hasActualElement())
6682      composeBoolean(t, "Group", "actual", element.getActualElement(), -1);
6683    if (element.hasCode())
6684      composeCodeableConcept(t, "Group", "code", element.getCode(), -1);
6685    if (element.hasNameElement())
6686      composeString(t, "Group", "name", element.getNameElement(), -1);
6687    if (element.hasQuantityElement())
6688      composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1);
6689    for (int i = 0; i < element.getCharacteristic().size(); i++)
6690      composeGroupGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i);
6691    for (int i = 0; i < element.getMember().size(); i++)
6692      composeGroupGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i);
6693  }
6694
6695  protected void composeGroupGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) {
6696    if (element == null) 
6697      return;
6698    Complex t;
6699    if (Utilities.noString(parentType))
6700      t = parent;
6701    else {
6702      t = parent.predicate("fhir:"+parentType+'.'+name);
6703    }
6704    composeBackboneElement(t, "characteristic", name, element, index);
6705    if (element.hasCode())
6706      composeCodeableConcept(t, "Group", "code", element.getCode(), -1);
6707    if (element.hasValue())
6708      composeType(t, "Group", "value", element.getValue(), -1);
6709    if (element.hasExcludeElement())
6710      composeBoolean(t, "Group", "exclude", element.getExcludeElement(), -1);
6711    if (element.hasPeriod())
6712      composePeriod(t, "Group", "period", element.getPeriod(), -1);
6713  }
6714
6715  protected void composeGroupGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) {
6716    if (element == null) 
6717      return;
6718    Complex t;
6719    if (Utilities.noString(parentType))
6720      t = parent;
6721    else {
6722      t = parent.predicate("fhir:"+parentType+'.'+name);
6723    }
6724    composeBackboneElement(t, "member", name, element, index);
6725    if (element.hasEntity())
6726      composeReference(t, "Group", "entity", element.getEntity(), -1);
6727    if (element.hasPeriod())
6728      composePeriod(t, "Group", "period", element.getPeriod(), -1);
6729    if (element.hasInactiveElement())
6730      composeBoolean(t, "Group", "inactive", element.getInactiveElement(), -1);
6731  }
6732
6733  protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) {
6734    if (element == null) 
6735      return;
6736    Complex t;
6737    if (Utilities.noString(parentType))
6738      t = parent;
6739    else {
6740      t = parent.predicate("fhir:"+parentType+'.'+name);
6741    }
6742    composeDomainResource(t, "GuidanceResponse", name, element, index);
6743    if (element.hasRequestIdElement())
6744      composeId(t, "GuidanceResponse", "requestId", element.getRequestIdElement(), -1);
6745    if (element.hasIdentifier())
6746      composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier(), -1);
6747    if (element.hasModule())
6748      composeReference(t, "GuidanceResponse", "module", element.getModule(), -1);
6749    if (element.hasStatusElement())
6750      composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1);
6751    if (element.hasSubject())
6752      composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1);
6753    if (element.hasContext())
6754      composeReference(t, "GuidanceResponse", "context", element.getContext(), -1);
6755    if (element.hasOccurrenceDateTimeElement())
6756      composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1);
6757    if (element.hasPerformer())
6758      composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1);
6759    if (element.hasReason())
6760      composeType(t, "GuidanceResponse", "reason", element.getReason(), -1);
6761    for (int i = 0; i < element.getNote().size(); i++)
6762      composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i);
6763    for (int i = 0; i < element.getEvaluationMessage().size(); i++)
6764      composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i);
6765    if (element.hasOutputParameters())
6766      composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1);
6767    if (element.hasResult())
6768      composeReference(t, "GuidanceResponse", "result", element.getResult(), -1);
6769    for (int i = 0; i < element.getDataRequirement().size(); i++)
6770      composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i);
6771  }
6772
6773  protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) {
6774    if (element == null) 
6775      return;
6776    Complex t;
6777    if (Utilities.noString(parentType))
6778      t = parent;
6779    else {
6780      t = parent.predicate("fhir:"+parentType+'.'+name);
6781    }
6782    composeDomainResource(t, "HealthcareService", name, element, index);
6783    for (int i = 0; i < element.getIdentifier().size(); i++)
6784      composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i);
6785    if (element.hasActiveElement())
6786      composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1);
6787    if (element.hasProvidedBy())
6788      composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1);
6789    if (element.hasCategory())
6790      composeCodeableConcept(t, "HealthcareService", "category", element.getCategory(), -1);
6791    for (int i = 0; i < element.getType().size(); i++)
6792      composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i);
6793    for (int i = 0; i < element.getSpecialty().size(); i++)
6794      composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i);
6795    for (int i = 0; i < element.getLocation().size(); i++)
6796      composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i);
6797    if (element.hasNameElement())
6798      composeString(t, "HealthcareService", "name", element.getNameElement(), -1);
6799    if (element.hasCommentElement())
6800      composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1);
6801    if (element.hasExtraDetailsElement())
6802      composeString(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1);
6803    if (element.hasPhoto())
6804      composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1);
6805    for (int i = 0; i < element.getTelecom().size(); i++)
6806      composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i);
6807    for (int i = 0; i < element.getCoverageArea().size(); i++)
6808      composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i);
6809    for (int i = 0; i < element.getServiceProvisionCode().size(); i++)
6810      composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i);
6811    if (element.hasEligibility())
6812      composeCodeableConcept(t, "HealthcareService", "eligibility", element.getEligibility(), -1);
6813    if (element.hasEligibilityNoteElement())
6814      composeString(t, "HealthcareService", "eligibilityNote", element.getEligibilityNoteElement(), -1);
6815    for (int i = 0; i < element.getProgramName().size(); i++)
6816      composeString(t, "HealthcareService", "programName", element.getProgramName().get(i), i);
6817    for (int i = 0; i < element.getCharacteristic().size(); i++)
6818      composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i);
6819    for (int i = 0; i < element.getReferralMethod().size(); i++)
6820      composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i);
6821    if (element.hasAppointmentRequiredElement())
6822      composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1);
6823    for (int i = 0; i < element.getAvailableTime().size(); i++)
6824      composeHealthcareServiceHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i);
6825    for (int i = 0; i < element.getNotAvailable().size(); i++)
6826      composeHealthcareServiceHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i);
6827    if (element.hasAvailabilityExceptionsElement())
6828      composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1);
6829    for (int i = 0; i < element.getEndpoint().size(); i++)
6830      composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i);
6831  }
6832
6833  protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) {
6834    if (element == null) 
6835      return;
6836    Complex t;
6837    if (Utilities.noString(parentType))
6838      t = parent;
6839    else {
6840      t = parent.predicate("fhir:"+parentType+'.'+name);
6841    }
6842    composeBackboneElement(t, "availableTime", name, element, index);
6843    for (int i = 0; i < element.getDaysOfWeek().size(); i++)
6844      composeEnum(t, "HealthcareService", "daysOfWeek", element.getDaysOfWeek().get(i), i);
6845    if (element.hasAllDayElement())
6846      composeBoolean(t, "HealthcareService", "allDay", element.getAllDayElement(), -1);
6847    if (element.hasAvailableStartTimeElement())
6848      composeTime(t, "HealthcareService", "availableStartTime", element.getAvailableStartTimeElement(), -1);
6849    if (element.hasAvailableEndTimeElement())
6850      composeTime(t, "HealthcareService", "availableEndTime", element.getAvailableEndTimeElement(), -1);
6851  }
6852
6853  protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) {
6854    if (element == null) 
6855      return;
6856    Complex t;
6857    if (Utilities.noString(parentType))
6858      t = parent;
6859    else {
6860      t = parent.predicate("fhir:"+parentType+'.'+name);
6861    }
6862    composeBackboneElement(t, "notAvailable", name, element, index);
6863    if (element.hasDescriptionElement())
6864      composeString(t, "HealthcareService", "description", element.getDescriptionElement(), -1);
6865    if (element.hasDuring())
6866      composePeriod(t, "HealthcareService", "during", element.getDuring(), -1);
6867  }
6868
6869  protected void composeImagingManifest(Complex parent, String parentType, String name, ImagingManifest element, int index) {
6870    if (element == null) 
6871      return;
6872    Complex t;
6873    if (Utilities.noString(parentType))
6874      t = parent;
6875    else {
6876      t = parent.predicate("fhir:"+parentType+'.'+name);
6877    }
6878    composeDomainResource(t, "ImagingManifest", name, element, index);
6879    if (element.hasIdentifier())
6880      composeIdentifier(t, "ImagingManifest", "identifier", element.getIdentifier(), -1);
6881    if (element.hasPatient())
6882      composeReference(t, "ImagingManifest", "patient", element.getPatient(), -1);
6883    if (element.hasAuthoringTimeElement())
6884      composeDateTime(t, "ImagingManifest", "authoringTime", element.getAuthoringTimeElement(), -1);
6885    if (element.hasAuthor())
6886      composeReference(t, "ImagingManifest", "author", element.getAuthor(), -1);
6887    if (element.hasDescriptionElement())
6888      composeString(t, "ImagingManifest", "description", element.getDescriptionElement(), -1);
6889    for (int i = 0; i < element.getStudy().size(); i++)
6890      composeImagingManifestStudyComponent(t, "ImagingManifest", "study", element.getStudy().get(i), i);
6891  }
6892
6893  protected void composeImagingManifestStudyComponent(Complex parent, String parentType, String name, ImagingManifest.StudyComponent element, int index) {
6894    if (element == null) 
6895      return;
6896    Complex t;
6897    if (Utilities.noString(parentType))
6898      t = parent;
6899    else {
6900      t = parent.predicate("fhir:"+parentType+'.'+name);
6901    }
6902    composeBackboneElement(t, "study", name, element, index);
6903    if (element.hasUidElement())
6904      composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1);
6905    if (element.hasImagingStudy())
6906      composeReference(t, "ImagingManifest", "imagingStudy", element.getImagingStudy(), -1);
6907    for (int i = 0; i < element.getEndpoint().size(); i++)
6908      composeReference(t, "ImagingManifest", "endpoint", element.getEndpoint().get(i), i);
6909    for (int i = 0; i < element.getSeries().size(); i++)
6910      composeImagingManifestSeriesComponent(t, "ImagingManifest", "series", element.getSeries().get(i), i);
6911  }
6912
6913  protected void composeImagingManifestSeriesComponent(Complex parent, String parentType, String name, ImagingManifest.SeriesComponent element, int index) {
6914    if (element == null) 
6915      return;
6916    Complex t;
6917    if (Utilities.noString(parentType))
6918      t = parent;
6919    else {
6920      t = parent.predicate("fhir:"+parentType+'.'+name);
6921    }
6922    composeBackboneElement(t, "series", name, element, index);
6923    if (element.hasUidElement())
6924      composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1);
6925    for (int i = 0; i < element.getEndpoint().size(); i++)
6926      composeReference(t, "ImagingManifest", "endpoint", element.getEndpoint().get(i), i);
6927    for (int i = 0; i < element.getInstance().size(); i++)
6928      composeImagingManifestInstanceComponent(t, "ImagingManifest", "instance", element.getInstance().get(i), i);
6929  }
6930
6931  protected void composeImagingManifestInstanceComponent(Complex parent, String parentType, String name, ImagingManifest.InstanceComponent element, int index) {
6932    if (element == null) 
6933      return;
6934    Complex t;
6935    if (Utilities.noString(parentType))
6936      t = parent;
6937    else {
6938      t = parent.predicate("fhir:"+parentType+'.'+name);
6939    }
6940    composeBackboneElement(t, "instance", name, element, index);
6941    if (element.hasSopClassElement())
6942      composeOid(t, "ImagingManifest", "sopClass", element.getSopClassElement(), -1);
6943    if (element.hasUidElement())
6944      composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1);
6945  }
6946
6947  protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) {
6948    if (element == null) 
6949      return;
6950    Complex t;
6951    if (Utilities.noString(parentType))
6952      t = parent;
6953    else {
6954      t = parent.predicate("fhir:"+parentType+'.'+name);
6955    }
6956    composeDomainResource(t, "ImagingStudy", name, element, index);
6957    if (element.hasUidElement())
6958      composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1);
6959    if (element.hasAccession())
6960      composeIdentifier(t, "ImagingStudy", "accession", element.getAccession(), -1);
6961    for (int i = 0; i < element.getIdentifier().size(); i++)
6962      composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i);
6963    if (element.hasAvailabilityElement())
6964      composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1);
6965    for (int i = 0; i < element.getModalityList().size(); i++)
6966      composeCoding(t, "ImagingStudy", "modalityList", element.getModalityList().get(i), i);
6967    if (element.hasPatient())
6968      composeReference(t, "ImagingStudy", "patient", element.getPatient(), -1);
6969    if (element.hasContext())
6970      composeReference(t, "ImagingStudy", "context", element.getContext(), -1);
6971    if (element.hasStartedElement())
6972      composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1);
6973    for (int i = 0; i < element.getBasedOn().size(); i++)
6974      composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i);
6975    if (element.hasReferrer())
6976      composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1);
6977    for (int i = 0; i < element.getInterpreter().size(); i++)
6978      composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i);
6979    for (int i = 0; i < element.getEndpoint().size(); i++)
6980      composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i);
6981    if (element.hasNumberOfSeriesElement())
6982      composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1);
6983    if (element.hasNumberOfInstancesElement())
6984      composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
6985    for (int i = 0; i < element.getProcedureReference().size(); i++)
6986      composeReference(t, "ImagingStudy", "procedureReference", element.getProcedureReference().get(i), i);
6987    for (int i = 0; i < element.getProcedureCode().size(); i++)
6988      composeCodeableConcept(t, "ImagingStudy", "procedureCode", element.getProcedureCode().get(i), i);
6989    if (element.hasReason())
6990      composeCodeableConcept(t, "ImagingStudy", "reason", element.getReason(), -1);
6991    if (element.hasDescriptionElement())
6992      composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1);
6993    for (int i = 0; i < element.getSeries().size(); i++)
6994      composeImagingStudyImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i);
6995  }
6996
6997  protected void composeImagingStudyImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) {
6998    if (element == null) 
6999      return;
7000    Complex t;
7001    if (Utilities.noString(parentType))
7002      t = parent;
7003    else {
7004      t = parent.predicate("fhir:"+parentType+'.'+name);
7005    }
7006    composeBackboneElement(t, "series", name, element, index);
7007    if (element.hasUidElement())
7008      composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1);
7009    if (element.hasNumberElement())
7010      composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1);
7011    if (element.hasModality())
7012      composeCoding(t, "ImagingStudy", "modality", element.getModality(), -1);
7013    if (element.hasDescriptionElement())
7014      composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1);
7015    if (element.hasNumberOfInstancesElement())
7016      composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
7017    if (element.hasAvailabilityElement())
7018      composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1);
7019    for (int i = 0; i < element.getEndpoint().size(); i++)
7020      composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i);
7021    if (element.hasBodySite())
7022      composeCoding(t, "ImagingStudy", "bodySite", element.getBodySite(), -1);
7023    if (element.hasLaterality())
7024      composeCoding(t, "ImagingStudy", "laterality", element.getLaterality(), -1);
7025    if (element.hasStartedElement())
7026      composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1);
7027    for (int i = 0; i < element.getPerformer().size(); i++)
7028      composeReference(t, "ImagingStudy", "performer", element.getPerformer().get(i), i);
7029    for (int i = 0; i < element.getInstance().size(); i++)
7030      composeImagingStudyImagingStudySeriesInstanceComponent(t, "ImagingStudy", "instance", element.getInstance().get(i), i);
7031  }
7032
7033  protected void composeImagingStudyImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) {
7034    if (element == null) 
7035      return;
7036    Complex t;
7037    if (Utilities.noString(parentType))
7038      t = parent;
7039    else {
7040      t = parent.predicate("fhir:"+parentType+'.'+name);
7041    }
7042    composeBackboneElement(t, "instance", name, element, index);
7043    if (element.hasUidElement())
7044      composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1);
7045    if (element.hasNumberElement())
7046      composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1);
7047    if (element.hasSopClassElement())
7048      composeOid(t, "ImagingStudy", "sopClass", element.getSopClassElement(), -1);
7049    if (element.hasTitleElement())
7050      composeString(t, "ImagingStudy", "title", element.getTitleElement(), -1);
7051  }
7052
7053  protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) {
7054    if (element == null) 
7055      return;
7056    Complex t;
7057    if (Utilities.noString(parentType))
7058      t = parent;
7059    else {
7060      t = parent.predicate("fhir:"+parentType+'.'+name);
7061    }
7062    composeDomainResource(t, "Immunization", name, element, index);
7063    for (int i = 0; i < element.getIdentifier().size(); i++)
7064      composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i);
7065    if (element.hasStatusElement())
7066      composeEnum(t, "Immunization", "status", element.getStatusElement(), -1);
7067    if (element.hasNotGivenElement())
7068      composeBoolean(t, "Immunization", "notGiven", element.getNotGivenElement(), -1);
7069    if (element.hasVaccineCode())
7070      composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1);
7071    if (element.hasPatient())
7072      composeReference(t, "Immunization", "patient", element.getPatient(), -1);
7073    if (element.hasEncounter())
7074      composeReference(t, "Immunization", "encounter", element.getEncounter(), -1);
7075    if (element.hasDateElement())
7076      composeDateTime(t, "Immunization", "date", element.getDateElement(), -1);
7077    if (element.hasPrimarySourceElement())
7078      composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1);
7079    if (element.hasReportOrigin())
7080      composeCodeableConcept(t, "Immunization", "reportOrigin", element.getReportOrigin(), -1);
7081    if (element.hasLocation())
7082      composeReference(t, "Immunization", "location", element.getLocation(), -1);
7083    if (element.hasManufacturer())
7084      composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1);
7085    if (element.hasLotNumberElement())
7086      composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1);
7087    if (element.hasExpirationDateElement())
7088      composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1);
7089    if (element.hasSite())
7090      composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1);
7091    if (element.hasRoute())
7092      composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1);
7093    if (element.hasDoseQuantity())
7094      composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1);
7095    for (int i = 0; i < element.getPractitioner().size(); i++)
7096      composeImmunizationImmunizationPractitionerComponent(t, "Immunization", "practitioner", element.getPractitioner().get(i), i);
7097    for (int i = 0; i < element.getNote().size(); i++)
7098      composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i);
7099    if (element.hasExplanation())
7100      composeImmunizationImmunizationExplanationComponent(t, "Immunization", "explanation", element.getExplanation(), -1);
7101    for (int i = 0; i < element.getReaction().size(); i++)
7102      composeImmunizationImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i);
7103    for (int i = 0; i < element.getVaccinationProtocol().size(); i++)
7104      composeImmunizationImmunizationVaccinationProtocolComponent(t, "Immunization", "vaccinationProtocol", element.getVaccinationProtocol().get(i), i);
7105  }
7106
7107  protected void composeImmunizationImmunizationPractitionerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPractitionerComponent element, int index) {
7108    if (element == null) 
7109      return;
7110    Complex t;
7111    if (Utilities.noString(parentType))
7112      t = parent;
7113    else {
7114      t = parent.predicate("fhir:"+parentType+'.'+name);
7115    }
7116    composeBackboneElement(t, "practitioner", name, element, index);
7117    if (element.hasRole())
7118      composeCodeableConcept(t, "Immunization", "role", element.getRole(), -1);
7119    if (element.hasActor())
7120      composeReference(t, "Immunization", "actor", element.getActor(), -1);
7121  }
7122
7123  protected void composeImmunizationImmunizationExplanationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationExplanationComponent element, int index) {
7124    if (element == null) 
7125      return;
7126    Complex t;
7127    if (Utilities.noString(parentType))
7128      t = parent;
7129    else {
7130      t = parent.predicate("fhir:"+parentType+'.'+name);
7131    }
7132    composeBackboneElement(t, "explanation", name, element, index);
7133    for (int i = 0; i < element.getReason().size(); i++)
7134      composeCodeableConcept(t, "Immunization", "reason", element.getReason().get(i), i);
7135    for (int i = 0; i < element.getReasonNotGiven().size(); i++)
7136      composeCodeableConcept(t, "Immunization", "reasonNotGiven", element.getReasonNotGiven().get(i), i);
7137  }
7138
7139  protected void composeImmunizationImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) {
7140    if (element == null) 
7141      return;
7142    Complex t;
7143    if (Utilities.noString(parentType))
7144      t = parent;
7145    else {
7146      t = parent.predicate("fhir:"+parentType+'.'+name);
7147    }
7148    composeBackboneElement(t, "reaction", name, element, index);
7149    if (element.hasDateElement())
7150      composeDateTime(t, "Immunization", "date", element.getDateElement(), -1);
7151    if (element.hasDetail())
7152      composeReference(t, "Immunization", "detail", element.getDetail(), -1);
7153    if (element.hasReportedElement())
7154      composeBoolean(t, "Immunization", "reported", element.getReportedElement(), -1);
7155  }
7156
7157  protected void composeImmunizationImmunizationVaccinationProtocolComponent(Complex parent, String parentType, String name, Immunization.ImmunizationVaccinationProtocolComponent element, int index) {
7158    if (element == null) 
7159      return;
7160    Complex t;
7161    if (Utilities.noString(parentType))
7162      t = parent;
7163    else {
7164      t = parent.predicate("fhir:"+parentType+'.'+name);
7165    }
7166    composeBackboneElement(t, "vaccinationProtocol", name, element, index);
7167    if (element.hasDoseSequenceElement())
7168      composePositiveInt(t, "Immunization", "doseSequence", element.getDoseSequenceElement(), -1);
7169    if (element.hasDescriptionElement())
7170      composeString(t, "Immunization", "description", element.getDescriptionElement(), -1);
7171    if (element.hasAuthority())
7172      composeReference(t, "Immunization", "authority", element.getAuthority(), -1);
7173    if (element.hasSeriesElement())
7174      composeString(t, "Immunization", "series", element.getSeriesElement(), -1);
7175    if (element.hasSeriesDosesElement())
7176      composePositiveInt(t, "Immunization", "seriesDoses", element.getSeriesDosesElement(), -1);
7177    for (int i = 0; i < element.getTargetDisease().size(); i++)
7178      composeCodeableConcept(t, "Immunization", "targetDisease", element.getTargetDisease().get(i), i);
7179    if (element.hasDoseStatus())
7180      composeCodeableConcept(t, "Immunization", "doseStatus", element.getDoseStatus(), -1);
7181    if (element.hasDoseStatusReason())
7182      composeCodeableConcept(t, "Immunization", "doseStatusReason", element.getDoseStatusReason(), -1);
7183  }
7184
7185  protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) {
7186    if (element == null) 
7187      return;
7188    Complex t;
7189    if (Utilities.noString(parentType))
7190      t = parent;
7191    else {
7192      t = parent.predicate("fhir:"+parentType+'.'+name);
7193    }
7194    composeDomainResource(t, "ImmunizationRecommendation", name, element, index);
7195    for (int i = 0; i < element.getIdentifier().size(); i++)
7196      composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i);
7197    if (element.hasPatient())
7198      composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1);
7199    for (int i = 0; i < element.getRecommendation().size(); i++)
7200      composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i);
7201  }
7202
7203  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) {
7204    if (element == null) 
7205      return;
7206    Complex t;
7207    if (Utilities.noString(parentType))
7208      t = parent;
7209    else {
7210      t = parent.predicate("fhir:"+parentType+'.'+name);
7211    }
7212    composeBackboneElement(t, "recommendation", name, element, index);
7213    if (element.hasDateElement())
7214      composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1);
7215    if (element.hasVaccineCode())
7216      composeCodeableConcept(t, "ImmunizationRecommendation", "vaccineCode", element.getVaccineCode(), -1);
7217    if (element.hasTargetDisease())
7218      composeCodeableConcept(t, "ImmunizationRecommendation", "targetDisease", element.getTargetDisease(), -1);
7219    if (element.hasDoseNumberElement())
7220      composePositiveInt(t, "ImmunizationRecommendation", "doseNumber", element.getDoseNumberElement(), -1);
7221    if (element.hasForecastStatus())
7222      composeCodeableConcept(t, "ImmunizationRecommendation", "forecastStatus", element.getForecastStatus(), -1);
7223    for (int i = 0; i < element.getDateCriterion().size(); i++)
7224      composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendation", "dateCriterion", element.getDateCriterion().get(i), i);
7225    if (element.hasProtocol())
7226      composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(t, "ImmunizationRecommendation", "protocol", element.getProtocol(), -1);
7227    for (int i = 0; i < element.getSupportingImmunization().size(); i++)
7228      composeReference(t, "ImmunizationRecommendation", "supportingImmunization", element.getSupportingImmunization().get(i), i);
7229    for (int i = 0; i < element.getSupportingPatientInformation().size(); i++)
7230      composeReference(t, "ImmunizationRecommendation", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i);
7231  }
7232
7233  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) {
7234    if (element == null) 
7235      return;
7236    Complex t;
7237    if (Utilities.noString(parentType))
7238      t = parent;
7239    else {
7240      t = parent.predicate("fhir:"+parentType+'.'+name);
7241    }
7242    composeBackboneElement(t, "dateCriterion", name, element, index);
7243    if (element.hasCode())
7244      composeCodeableConcept(t, "ImmunizationRecommendation", "code", element.getCode(), -1);
7245    if (element.hasValueElement())
7246      composeDateTime(t, "ImmunizationRecommendation", "value", element.getValueElement(), -1);
7247  }
7248
7249  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element, int index) {
7250    if (element == null) 
7251      return;
7252    Complex t;
7253    if (Utilities.noString(parentType))
7254      t = parent;
7255    else {
7256      t = parent.predicate("fhir:"+parentType+'.'+name);
7257    }
7258    composeBackboneElement(t, "protocol", name, element, index);
7259    if (element.hasDoseSequenceElement())
7260      composePositiveInt(t, "ImmunizationRecommendation", "doseSequence", element.getDoseSequenceElement(), -1);
7261    if (element.hasDescriptionElement())
7262      composeString(t, "ImmunizationRecommendation", "description", element.getDescriptionElement(), -1);
7263    if (element.hasAuthority())
7264      composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1);
7265    if (element.hasSeriesElement())
7266      composeString(t, "ImmunizationRecommendation", "series", element.getSeriesElement(), -1);
7267  }
7268
7269  protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide element, int index) {
7270    if (element == null) 
7271      return;
7272    Complex t;
7273    if (Utilities.noString(parentType))
7274      t = parent;
7275    else {
7276      t = parent.predicate("fhir:"+parentType+'.'+name);
7277    }
7278    composeDomainResource(t, "ImplementationGuide", name, element, index);
7279    if (element.hasUrlElement())
7280      composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1);
7281    if (element.hasVersionElement())
7282      composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1);
7283    if (element.hasNameElement())
7284      composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1);
7285    if (element.hasStatusElement())
7286      composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1);
7287    if (element.hasExperimentalElement())
7288      composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1);
7289    if (element.hasDateElement())
7290      composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1);
7291    if (element.hasPublisherElement())
7292      composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1);
7293    for (int i = 0; i < element.getContact().size(); i++)
7294      composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i);
7295    if (element.hasDescriptionElement())
7296      composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1);
7297    for (int i = 0; i < element.getUseContext().size(); i++)
7298      composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i);
7299    for (int i = 0; i < element.getJurisdiction().size(); i++)
7300      composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i);
7301    if (element.hasCopyrightElement())
7302      composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1);
7303    if (element.hasFhirVersionElement())
7304      composeId(t, "ImplementationGuide", "fhirVersion", element.getFhirVersionElement(), -1);
7305    for (int i = 0; i < element.getDependency().size(); i++)
7306      composeImplementationGuideImplementationGuideDependencyComponent(t, "ImplementationGuide", "dependency", element.getDependency().get(i), i);
7307    for (int i = 0; i < element.getPackage().size(); i++)
7308      composeImplementationGuideImplementationGuidePackageComponent(t, "ImplementationGuide", "package", element.getPackage().get(i), i);
7309    for (int i = 0; i < element.getGlobal().size(); i++)
7310      composeImplementationGuideImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i);
7311    for (int i = 0; i < element.getBinary().size(); i++)
7312      composeUri(t, "ImplementationGuide", "binary", element.getBinary().get(i), i);
7313    if (element.hasPage())
7314      composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage(), -1);
7315  }
7316
7317  protected void composeImplementationGuideImplementationGuideDependencyComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependencyComponent element, int index) {
7318    if (element == null) 
7319      return;
7320    Complex t;
7321    if (Utilities.noString(parentType))
7322      t = parent;
7323    else {
7324      t = parent.predicate("fhir:"+parentType+'.'+name);
7325    }
7326    composeBackboneElement(t, "dependency", name, element, index);
7327    if (element.hasTypeElement())
7328      composeEnum(t, "ImplementationGuide", "type", element.getTypeElement(), -1);
7329    if (element.hasUriElement())
7330      composeUri(t, "ImplementationGuide", "uri", element.getUriElement(), -1);
7331  }
7332
7333  protected void composeImplementationGuideImplementationGuidePackageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageComponent element, int index) {
7334    if (element == null) 
7335      return;
7336    Complex t;
7337    if (Utilities.noString(parentType))
7338      t = parent;
7339    else {
7340      t = parent.predicate("fhir:"+parentType+'.'+name);
7341    }
7342    composeBackboneElement(t, "package", name, element, index);
7343    if (element.hasNameElement())
7344      composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1);
7345    if (element.hasDescriptionElement())
7346      composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1);
7347    for (int i = 0; i < element.getResource().size(); i++)
7348      composeImplementationGuideImplementationGuidePackageResourceComponent(t, "ImplementationGuide", "resource", element.getResource().get(i), i);
7349  }
7350
7351  protected void composeImplementationGuideImplementationGuidePackageResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageResourceComponent element, int index) {
7352    if (element == null) 
7353      return;
7354    Complex t;
7355    if (Utilities.noString(parentType))
7356      t = parent;
7357    else {
7358      t = parent.predicate("fhir:"+parentType+'.'+name);
7359    }
7360    composeBackboneElement(t, "resource", name, element, index);
7361    if (element.hasExampleElement())
7362      composeBoolean(t, "ImplementationGuide", "example", element.getExampleElement(), -1);
7363    if (element.hasNameElement())
7364      composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1);
7365    if (element.hasDescriptionElement())
7366      composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1);
7367    if (element.hasAcronymElement())
7368      composeString(t, "ImplementationGuide", "acronym", element.getAcronymElement(), -1);
7369    if (element.hasSource())
7370      composeType(t, "ImplementationGuide", "source", element.getSource(), -1);
7371    if (element.hasExampleFor())
7372      composeReference(t, "ImplementationGuide", "exampleFor", element.getExampleFor(), -1);
7373  }
7374
7375  protected void composeImplementationGuideImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) {
7376    if (element == null) 
7377      return;
7378    Complex t;
7379    if (Utilities.noString(parentType))
7380      t = parent;
7381    else {
7382      t = parent.predicate("fhir:"+parentType+'.'+name);
7383    }
7384    composeBackboneElement(t, "global", name, element, index);
7385    if (element.hasTypeElement())
7386      composeCode(t, "ImplementationGuide", "type", element.getTypeElement(), -1);
7387    if (element.hasProfile())
7388      composeReference(t, "ImplementationGuide", "profile", element.getProfile(), -1);
7389  }
7390
7391  protected void composeImplementationGuideImplementationGuidePageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePageComponent element, int index) {
7392    if (element == null) 
7393      return;
7394    Complex t;
7395    if (Utilities.noString(parentType))
7396      t = parent;
7397    else {
7398      t = parent.predicate("fhir:"+parentType+'.'+name);
7399    }
7400    composeBackboneElement(t, "page", name, element, index);
7401    if (element.hasSourceElement())
7402      composeUri(t, "ImplementationGuide", "source", element.getSourceElement(), -1);
7403    if (element.hasTitleElement())
7404      composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1);
7405    if (element.hasKindElement())
7406      composeEnum(t, "ImplementationGuide", "kind", element.getKindElement(), -1);
7407    for (int i = 0; i < element.getType().size(); i++)
7408      composeCode(t, "ImplementationGuide", "type", element.getType().get(i), i);
7409    for (int i = 0; i < element.getPackage().size(); i++)
7410      composeString(t, "ImplementationGuide", "package", element.getPackage().get(i), i);
7411    if (element.hasFormatElement())
7412      composeCode(t, "ImplementationGuide", "format", element.getFormatElement(), -1);
7413    for (int i = 0; i < element.getPage().size(); i++)
7414      composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage().get(i), i);
7415  }
7416
7417  protected void composeLibrary(Complex parent, String parentType, String name, Library element, int index) {
7418    if (element == null) 
7419      return;
7420    Complex t;
7421    if (Utilities.noString(parentType))
7422      t = parent;
7423    else {
7424      t = parent.predicate("fhir:"+parentType+'.'+name);
7425    }
7426    composeDomainResource(t, "Library", name, element, index);
7427    if (element.hasUrlElement())
7428      composeUri(t, "Library", "url", element.getUrlElement(), -1);
7429    for (int i = 0; i < element.getIdentifier().size(); i++)
7430      composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i);
7431    if (element.hasVersionElement())
7432      composeString(t, "Library", "version", element.getVersionElement(), -1);
7433    if (element.hasNameElement())
7434      composeString(t, "Library", "name", element.getNameElement(), -1);
7435    if (element.hasTitleElement())
7436      composeString(t, "Library", "title", element.getTitleElement(), -1);
7437    if (element.hasStatusElement())
7438      composeEnum(t, "Library", "status", element.getStatusElement(), -1);
7439    if (element.hasExperimentalElement())
7440      composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1);
7441    if (element.hasType())
7442      composeCodeableConcept(t, "Library", "type", element.getType(), -1);
7443    if (element.hasDateElement())
7444      composeDateTime(t, "Library", "date", element.getDateElement(), -1);
7445    if (element.hasPublisherElement())
7446      composeString(t, "Library", "publisher", element.getPublisherElement(), -1);
7447    if (element.hasDescriptionElement())
7448      composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1);
7449    if (element.hasPurposeElement())
7450      composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1);
7451    if (element.hasUsageElement())
7452      composeString(t, "Library", "usage", element.getUsageElement(), -1);
7453    if (element.hasApprovalDateElement())
7454      composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1);
7455    if (element.hasLastReviewDateElement())
7456      composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1);
7457    if (element.hasEffectivePeriod())
7458      composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1);
7459    for (int i = 0; i < element.getUseContext().size(); i++)
7460      composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i);
7461    for (int i = 0; i < element.getJurisdiction().size(); i++)
7462      composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i);
7463    for (int i = 0; i < element.getTopic().size(); i++)
7464      composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i);
7465    for (int i = 0; i < element.getContributor().size(); i++)
7466      composeContributor(t, "Library", "contributor", element.getContributor().get(i), i);
7467    for (int i = 0; i < element.getContact().size(); i++)
7468      composeContactDetail(t, "Library", "contact", element.getContact().get(i), i);
7469    if (element.hasCopyrightElement())
7470      composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1);
7471    for (int i = 0; i < element.getRelatedArtifact().size(); i++)
7472      composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i);
7473    for (int i = 0; i < element.getParameter().size(); i++)
7474      composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i);
7475    for (int i = 0; i < element.getDataRequirement().size(); i++)
7476      composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i);
7477    for (int i = 0; i < element.getContent().size(); i++)
7478      composeAttachment(t, "Library", "content", element.getContent().get(i), i);
7479  }
7480
7481  protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) {
7482    if (element == null) 
7483      return;
7484    Complex t;
7485    if (Utilities.noString(parentType))
7486      t = parent;
7487    else {
7488      t = parent.predicate("fhir:"+parentType+'.'+name);
7489    }
7490    composeDomainResource(t, "Linkage", name, element, index);
7491    if (element.hasActiveElement())
7492      composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1);
7493    if (element.hasAuthor())
7494      composeReference(t, "Linkage", "author", element.getAuthor(), -1);
7495    for (int i = 0; i < element.getItem().size(); i++)
7496      composeLinkageLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i);
7497  }
7498
7499  protected void composeLinkageLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) {
7500    if (element == null) 
7501      return;
7502    Complex t;
7503    if (Utilities.noString(parentType))
7504      t = parent;
7505    else {
7506      t = parent.predicate("fhir:"+parentType+'.'+name);
7507    }
7508    composeBackboneElement(t, "item", name, element, index);
7509    if (element.hasTypeElement())
7510      composeEnum(t, "Linkage", "type", element.getTypeElement(), -1);
7511    if (element.hasResource())
7512      composeReference(t, "Linkage", "resource", element.getResource(), -1);
7513  }
7514
7515  protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) {
7516    if (element == null) 
7517      return;
7518    Complex t;
7519    if (Utilities.noString(parentType))
7520      t = parent;
7521    else {
7522      t = parent.predicate("fhir:"+parentType+'.'+name);
7523    }
7524    composeDomainResource(t, "List", name, element, index);
7525    for (int i = 0; i < element.getIdentifier().size(); i++)
7526      composeIdentifier(t, "List", "identifier", element.getIdentifier().get(i), i);
7527    if (element.hasStatusElement())
7528      composeEnum(t, "List", "status", element.getStatusElement(), -1);
7529    if (element.hasModeElement())
7530      composeEnum(t, "List", "mode", element.getModeElement(), -1);
7531    if (element.hasTitleElement())
7532      composeString(t, "List", "title", element.getTitleElement(), -1);
7533    if (element.hasCode())
7534      composeCodeableConcept(t, "List", "code", element.getCode(), -1);
7535    if (element.hasSubject())
7536      composeReference(t, "List", "subject", element.getSubject(), -1);
7537    if (element.hasEncounter())
7538      composeReference(t, "List", "encounter", element.getEncounter(), -1);
7539    if (element.hasDateElement())
7540      composeDateTime(t, "List", "date", element.getDateElement(), -1);
7541    if (element.hasSource())
7542      composeReference(t, "List", "source", element.getSource(), -1);
7543    if (element.hasOrderedBy())
7544      composeCodeableConcept(t, "List", "orderedBy", element.getOrderedBy(), -1);
7545    for (int i = 0; i < element.getNote().size(); i++)
7546      composeAnnotation(t, "List", "note", element.getNote().get(i), i);
7547    for (int i = 0; i < element.getEntry().size(); i++)
7548      composeListResourceListEntryComponent(t, "List", "entry", element.getEntry().get(i), i);
7549    if (element.hasEmptyReason())
7550      composeCodeableConcept(t, "List", "emptyReason", element.getEmptyReason(), -1);
7551  }
7552
7553  protected void composeListResourceListEntryComponent(Complex parent, String parentType, String name, ListResource.ListEntryComponent element, int index) {
7554    if (element == null) 
7555      return;
7556    Complex t;
7557    if (Utilities.noString(parentType))
7558      t = parent;
7559    else {
7560      t = parent.predicate("fhir:"+parentType+'.'+name);
7561    }
7562    composeBackboneElement(t, "entry", name, element, index);
7563    if (element.hasFlag())
7564      composeCodeableConcept(t, "List", "flag", element.getFlag(), -1);
7565    if (element.hasDeletedElement())
7566      composeBoolean(t, "List", "deleted", element.getDeletedElement(), -1);
7567    if (element.hasDateElement())
7568      composeDateTime(t, "List", "date", element.getDateElement(), -1);
7569    if (element.hasItem())
7570      composeReference(t, "List", "item", element.getItem(), -1);
7571  }
7572
7573  protected void composeLocation(Complex parent, String parentType, String name, Location element, int index) {
7574    if (element == null) 
7575      return;
7576    Complex t;
7577    if (Utilities.noString(parentType))
7578      t = parent;
7579    else {
7580      t = parent.predicate("fhir:"+parentType+'.'+name);
7581    }
7582    composeDomainResource(t, "Location", name, element, index);
7583    for (int i = 0; i < element.getIdentifier().size(); i++)
7584      composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i);
7585    if (element.hasStatusElement())
7586      composeEnum(t, "Location", "status", element.getStatusElement(), -1);
7587    if (element.hasOperationalStatus())
7588      composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1);
7589    if (element.hasNameElement())
7590      composeString(t, "Location", "name", element.getNameElement(), -1);
7591    for (int i = 0; i < element.getAlias().size(); i++)
7592      composeString(t, "Location", "alias", element.getAlias().get(i), i);
7593    if (element.hasDescriptionElement())
7594      composeString(t, "Location", "description", element.getDescriptionElement(), -1);
7595    if (element.hasModeElement())
7596      composeEnum(t, "Location", "mode", element.getModeElement(), -1);
7597    if (element.hasType())
7598      composeCodeableConcept(t, "Location", "type", element.getType(), -1);
7599    for (int i = 0; i < element.getTelecom().size(); i++)
7600      composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i);
7601    if (element.hasAddress())
7602      composeAddress(t, "Location", "address", element.getAddress(), -1);
7603    if (element.hasPhysicalType())
7604      composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1);
7605    if (element.hasPosition())
7606      composeLocationLocationPositionComponent(t, "Location", "position", element.getPosition(), -1);
7607    if (element.hasManagingOrganization())
7608      composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1);
7609    if (element.hasPartOf())
7610      composeReference(t, "Location", "partOf", element.getPartOf(), -1);
7611    for (int i = 0; i < element.getEndpoint().size(); i++)
7612      composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i);
7613  }
7614
7615  protected void composeLocationLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) {
7616    if (element == null) 
7617      return;
7618    Complex t;
7619    if (Utilities.noString(parentType))
7620      t = parent;
7621    else {
7622      t = parent.predicate("fhir:"+parentType+'.'+name);
7623    }
7624    composeBackboneElement(t, "position", name, element, index);
7625    if (element.hasLongitudeElement())
7626      composeDecimal(t, "Location", "longitude", element.getLongitudeElement(), -1);
7627    if (element.hasLatitudeElement())
7628      composeDecimal(t, "Location", "latitude", element.getLatitudeElement(), -1);
7629    if (element.hasAltitudeElement())
7630      composeDecimal(t, "Location", "altitude", element.getAltitudeElement(), -1);
7631  }
7632
7633  protected void composeMeasure(Complex parent, String parentType, String name, Measure element, int index) {
7634    if (element == null) 
7635      return;
7636    Complex t;
7637    if (Utilities.noString(parentType))
7638      t = parent;
7639    else {
7640      t = parent.predicate("fhir:"+parentType+'.'+name);
7641    }
7642    composeDomainResource(t, "Measure", name, element, index);
7643    if (element.hasUrlElement())
7644      composeUri(t, "Measure", "url", element.getUrlElement(), -1);
7645    for (int i = 0; i < element.getIdentifier().size(); i++)
7646      composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i);
7647    if (element.hasVersionElement())
7648      composeString(t, "Measure", "version", element.getVersionElement(), -1);
7649    if (element.hasNameElement())
7650      composeString(t, "Measure", "name", element.getNameElement(), -1);
7651    if (element.hasTitleElement())
7652      composeString(t, "Measure", "title", element.getTitleElement(), -1);
7653    if (element.hasStatusElement())
7654      composeEnum(t, "Measure", "status", element.getStatusElement(), -1);
7655    if (element.hasExperimentalElement())
7656      composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1);
7657    if (element.hasDateElement())
7658      composeDateTime(t, "Measure", "date", element.getDateElement(), -1);
7659    if (element.hasPublisherElement())
7660      composeString(t, "Measure", "publisher", element.getPublisherElement(), -1);
7661    if (element.hasDescriptionElement())
7662      composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1);
7663    if (element.hasPurposeElement())
7664      composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1);
7665    if (element.hasUsageElement())
7666      composeString(t, "Measure", "usage", element.getUsageElement(), -1);
7667    if (element.hasApprovalDateElement())
7668      composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1);
7669    if (element.hasLastReviewDateElement())
7670      composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1);
7671    if (element.hasEffectivePeriod())
7672      composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1);
7673    for (int i = 0; i < element.getUseContext().size(); i++)
7674      composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i);
7675    for (int i = 0; i < element.getJurisdiction().size(); i++)
7676      composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i);
7677    for (int i = 0; i < element.getTopic().size(); i++)
7678      composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i);
7679    for (int i = 0; i < element.getContributor().size(); i++)
7680      composeContributor(t, "Measure", "contributor", element.getContributor().get(i), i);
7681    for (int i = 0; i < element.getContact().size(); i++)
7682      composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i);
7683    if (element.hasCopyrightElement())
7684      composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1);
7685    for (int i = 0; i < element.getRelatedArtifact().size(); i++)
7686      composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i);
7687    for (int i = 0; i < element.getLibrary().size(); i++)
7688      composeReference(t, "Measure", "library", element.getLibrary().get(i), i);
7689    if (element.hasDisclaimerElement())
7690      composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1);
7691    if (element.hasScoring())
7692      composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1);
7693    if (element.hasCompositeScoring())
7694      composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1);
7695    for (int i = 0; i < element.getType().size(); i++)
7696      composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i);
7697    if (element.hasRiskAdjustmentElement())
7698      composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1);
7699    if (element.hasRateAggregationElement())
7700      composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1);
7701    if (element.hasRationaleElement())
7702      composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1);
7703    if (element.hasClinicalRecommendationStatementElement())
7704      composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1);
7705    if (element.hasImprovementNotationElement())
7706      composeString(t, "Measure", "improvementNotation", element.getImprovementNotationElement(), -1);
7707    for (int i = 0; i < element.getDefinition().size(); i++)
7708      composeMarkdown(t, "Measure", "definition", element.getDefinition().get(i), i);
7709    if (element.hasGuidanceElement())
7710      composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1);
7711    if (element.hasSetElement())
7712      composeString(t, "Measure", "set", element.getSetElement(), -1);
7713    for (int i = 0; i < element.getGroup().size(); i++)
7714      composeMeasureMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i);
7715    for (int i = 0; i < element.getSupplementalData().size(); i++)
7716      composeMeasureMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i);
7717  }
7718
7719  protected void composeMeasureMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) {
7720    if (element == null) 
7721      return;
7722    Complex t;
7723    if (Utilities.noString(parentType))
7724      t = parent;
7725    else {
7726      t = parent.predicate("fhir:"+parentType+'.'+name);
7727    }
7728    composeBackboneElement(t, "group", name, element, index);
7729    if (element.hasIdentifier())
7730      composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1);
7731    if (element.hasNameElement())
7732      composeString(t, "Measure", "name", element.getNameElement(), -1);
7733    if (element.hasDescriptionElement())
7734      composeString(t, "Measure", "description", element.getDescriptionElement(), -1);
7735    for (int i = 0; i < element.getPopulation().size(); i++)
7736      composeMeasureMeasureGroupPopulationComponent(t, "Measure", "population", element.getPopulation().get(i), i);
7737    for (int i = 0; i < element.getStratifier().size(); i++)
7738      composeMeasureMeasureGroupStratifierComponent(t, "Measure", "stratifier", element.getStratifier().get(i), i);
7739  }
7740
7741  protected void composeMeasureMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) {
7742    if (element == null) 
7743      return;
7744    Complex t;
7745    if (Utilities.noString(parentType))
7746      t = parent;
7747    else {
7748      t = parent.predicate("fhir:"+parentType+'.'+name);
7749    }
7750    composeBackboneElement(t, "population", name, element, index);
7751    if (element.hasIdentifier())
7752      composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1);
7753    if (element.hasCode())
7754      composeCodeableConcept(t, "Measure", "code", element.getCode(), -1);
7755    if (element.hasNameElement())
7756      composeString(t, "Measure", "name", element.getNameElement(), -1);
7757    if (element.hasDescriptionElement())
7758      composeString(t, "Measure", "description", element.getDescriptionElement(), -1);
7759    if (element.hasCriteriaElement())
7760      composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1);
7761  }
7762
7763  protected void composeMeasureMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) {
7764    if (element == null) 
7765      return;
7766    Complex t;
7767    if (Utilities.noString(parentType))
7768      t = parent;
7769    else {
7770      t = parent.predicate("fhir:"+parentType+'.'+name);
7771    }
7772    composeBackboneElement(t, "stratifier", name, element, index);
7773    if (element.hasIdentifier())
7774      composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1);
7775    if (element.hasCriteriaElement())
7776      composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1);
7777    if (element.hasPathElement())
7778      composeString(t, "Measure", "path", element.getPathElement(), -1);
7779  }
7780
7781  protected void composeMeasureMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) {
7782    if (element == null) 
7783      return;
7784    Complex t;
7785    if (Utilities.noString(parentType))
7786      t = parent;
7787    else {
7788      t = parent.predicate("fhir:"+parentType+'.'+name);
7789    }
7790    composeBackboneElement(t, "supplementalData", name, element, index);
7791    if (element.hasIdentifier())
7792      composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1);
7793    for (int i = 0; i < element.getUsage().size(); i++)
7794      composeCodeableConcept(t, "Measure", "usage", element.getUsage().get(i), i);
7795    if (element.hasCriteriaElement())
7796      composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1);
7797    if (element.hasPathElement())
7798      composeString(t, "Measure", "path", element.getPathElement(), -1);
7799  }
7800
7801  protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport element, int index) {
7802    if (element == null) 
7803      return;
7804    Complex t;
7805    if (Utilities.noString(parentType))
7806      t = parent;
7807    else {
7808      t = parent.predicate("fhir:"+parentType+'.'+name);
7809    }
7810    composeDomainResource(t, "MeasureReport", name, element, index);
7811    if (element.hasIdentifier())
7812      composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1);
7813    if (element.hasStatusElement())
7814      composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1);
7815    if (element.hasTypeElement())
7816      composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1);
7817    if (element.hasMeasure())
7818      composeReference(t, "MeasureReport", "measure", element.getMeasure(), -1);
7819    if (element.hasPatient())
7820      composeReference(t, "MeasureReport", "patient", element.getPatient(), -1);
7821    if (element.hasDateElement())
7822      composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1);
7823    if (element.hasReportingOrganization())
7824      composeReference(t, "MeasureReport", "reportingOrganization", element.getReportingOrganization(), -1);
7825    if (element.hasPeriod())
7826      composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1);
7827    for (int i = 0; i < element.getGroup().size(); i++)
7828      composeMeasureReportMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i);
7829    if (element.hasEvaluatedResources())
7830      composeReference(t, "MeasureReport", "evaluatedResources", element.getEvaluatedResources(), -1);
7831  }
7832
7833  protected void composeMeasureReportMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) {
7834    if (element == null) 
7835      return;
7836    Complex t;
7837    if (Utilities.noString(parentType))
7838      t = parent;
7839    else {
7840      t = parent.predicate("fhir:"+parentType+'.'+name);
7841    }
7842    composeBackboneElement(t, "group", name, element, index);
7843    if (element.hasIdentifier())
7844      composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1);
7845    for (int i = 0; i < element.getPopulation().size(); i++)
7846      composeMeasureReportMeasureReportGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i);
7847    if (element.hasMeasureScoreElement())
7848      composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1);
7849    for (int i = 0; i < element.getStratifier().size(); i++)
7850      composeMeasureReportMeasureReportGroupStratifierComponent(t, "MeasureReport", "stratifier", element.getStratifier().get(i), i);
7851  }
7852
7853  protected void composeMeasureReportMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent element, int index) {
7854    if (element == null) 
7855      return;
7856    Complex t;
7857    if (Utilities.noString(parentType))
7858      t = parent;
7859    else {
7860      t = parent.predicate("fhir:"+parentType+'.'+name);
7861    }
7862    composeBackboneElement(t, "population", name, element, index);
7863    if (element.hasIdentifier())
7864      composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1);
7865    if (element.hasCode())
7866      composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1);
7867    if (element.hasCountElement())
7868      composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1);
7869    if (element.hasPatients())
7870      composeReference(t, "MeasureReport", "patients", element.getPatients(), -1);
7871  }
7872
7873  protected void composeMeasureReportMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent element, int index) {
7874    if (element == null) 
7875      return;
7876    Complex t;
7877    if (Utilities.noString(parentType))
7878      t = parent;
7879    else {
7880      t = parent.predicate("fhir:"+parentType+'.'+name);
7881    }
7882    composeBackboneElement(t, "stratifier", name, element, index);
7883    if (element.hasIdentifier())
7884      composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1);
7885    for (int i = 0; i < element.getStratum().size(); i++)
7886      composeMeasureReportStratifierGroupComponent(t, "MeasureReport", "stratum", element.getStratum().get(i), i);
7887  }
7888
7889  protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent element, int index) {
7890    if (element == null) 
7891      return;
7892    Complex t;
7893    if (Utilities.noString(parentType))
7894      t = parent;
7895    else {
7896      t = parent.predicate("fhir:"+parentType+'.'+name);
7897    }
7898    composeBackboneElement(t, "stratum", name, element, index);
7899    if (element.hasValueElement())
7900      composeString(t, "MeasureReport", "value", element.getValueElement(), -1);
7901    for (int i = 0; i < element.getPopulation().size(); i++)
7902      composeMeasureReportStratifierGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i);
7903    if (element.hasMeasureScoreElement())
7904      composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1);
7905  }
7906
7907  protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent element, int index) {
7908    if (element == null) 
7909      return;
7910    Complex t;
7911    if (Utilities.noString(parentType))
7912      t = parent;
7913    else {
7914      t = parent.predicate("fhir:"+parentType+'.'+name);
7915    }
7916    composeBackboneElement(t, "population", name, element, index);
7917    if (element.hasIdentifier())
7918      composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1);
7919    if (element.hasCode())
7920      composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1);
7921    if (element.hasCountElement())
7922      composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1);
7923    if (element.hasPatients())
7924      composeReference(t, "MeasureReport", "patients", element.getPatients(), -1);
7925  }
7926
7927  protected void composeMedia(Complex parent, String parentType, String name, Media element, int index) {
7928    if (element == null) 
7929      return;
7930    Complex t;
7931    if (Utilities.noString(parentType))
7932      t = parent;
7933    else {
7934      t = parent.predicate("fhir:"+parentType+'.'+name);
7935    }
7936    composeDomainResource(t, "Media", name, element, index);
7937    for (int i = 0; i < element.getIdentifier().size(); i++)
7938      composeIdentifier(t, "Media", "identifier", element.getIdentifier().get(i), i);
7939    for (int i = 0; i < element.getBasedOn().size(); i++)
7940      composeReference(t, "Media", "basedOn", element.getBasedOn().get(i), i);
7941    if (element.hasTypeElement())
7942      composeEnum(t, "Media", "type", element.getTypeElement(), -1);
7943    if (element.hasSubtype())
7944      composeCodeableConcept(t, "Media", "subtype", element.getSubtype(), -1);
7945    if (element.hasView())
7946      composeCodeableConcept(t, "Media", "view", element.getView(), -1);
7947    if (element.hasSubject())
7948      composeReference(t, "Media", "subject", element.getSubject(), -1);
7949    if (element.hasContext())
7950      composeReference(t, "Media", "context", element.getContext(), -1);
7951    if (element.hasOccurrence())
7952      composeType(t, "Media", "occurrence", element.getOccurrence(), -1);
7953    if (element.hasOperator())
7954      composeReference(t, "Media", "operator", element.getOperator(), -1);
7955    for (int i = 0; i < element.getReasonCode().size(); i++)
7956      composeCodeableConcept(t, "Media", "reasonCode", element.getReasonCode().get(i), i);
7957    if (element.hasBodySite())
7958      composeCodeableConcept(t, "Media", "bodySite", element.getBodySite(), -1);
7959    if (element.hasDevice())
7960      composeReference(t, "Media", "device", element.getDevice(), -1);
7961    if (element.hasHeightElement())
7962      composePositiveInt(t, "Media", "height", element.getHeightElement(), -1);
7963    if (element.hasWidthElement())
7964      composePositiveInt(t, "Media", "width", element.getWidthElement(), -1);
7965    if (element.hasFramesElement())
7966      composePositiveInt(t, "Media", "frames", element.getFramesElement(), -1);
7967    if (element.hasDurationElement())
7968      composeUnsignedInt(t, "Media", "duration", element.getDurationElement(), -1);
7969    if (element.hasContent())
7970      composeAttachment(t, "Media", "content", element.getContent(), -1);
7971    for (int i = 0; i < element.getNote().size(); i++)
7972      composeAnnotation(t, "Media", "note", element.getNote().get(i), i);
7973  }
7974
7975  protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) {
7976    if (element == null) 
7977      return;
7978    Complex t;
7979    if (Utilities.noString(parentType))
7980      t = parent;
7981    else {
7982      t = parent.predicate("fhir:"+parentType+'.'+name);
7983    }
7984    composeDomainResource(t, "Medication", name, element, index);
7985    if (element.hasCode())
7986      composeCodeableConcept(t, "Medication", "code", element.getCode(), -1);
7987    if (element.hasStatusElement())
7988      composeEnum(t, "Medication", "status", element.getStatusElement(), -1);
7989    if (element.hasIsBrandElement())
7990      composeBoolean(t, "Medication", "isBrand", element.getIsBrandElement(), -1);
7991    if (element.hasIsOverTheCounterElement())
7992      composeBoolean(t, "Medication", "isOverTheCounter", element.getIsOverTheCounterElement(), -1);
7993    if (element.hasManufacturer())
7994      composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1);
7995    if (element.hasForm())
7996      composeCodeableConcept(t, "Medication", "form", element.getForm(), -1);
7997    for (int i = 0; i < element.getIngredient().size(); i++)
7998      composeMedicationMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i);
7999    if (element.hasPackage())
8000      composeMedicationMedicationPackageComponent(t, "Medication", "package", element.getPackage(), -1);
8001    for (int i = 0; i < element.getImage().size(); i++)
8002      composeAttachment(t, "Medication", "image", element.getImage().get(i), i);
8003  }
8004
8005  protected void composeMedicationMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent element, int index) {
8006    if (element == null) 
8007      return;
8008    Complex t;
8009    if (Utilities.noString(parentType))
8010      t = parent;
8011    else {
8012      t = parent.predicate("fhir:"+parentType+'.'+name);
8013    }
8014    composeBackboneElement(t, "ingredient", name, element, index);
8015    if (element.hasItem())
8016      composeType(t, "Medication", "item", element.getItem(), -1);
8017    if (element.hasIsActiveElement())
8018      composeBoolean(t, "Medication", "isActive", element.getIsActiveElement(), -1);
8019    if (element.hasAmount())
8020      composeRatio(t, "Medication", "amount", element.getAmount(), -1);
8021  }
8022
8023  protected void composeMedicationMedicationPackageComponent(Complex parent, String parentType, String name, Medication.MedicationPackageComponent element, int index) {
8024    if (element == null) 
8025      return;
8026    Complex t;
8027    if (Utilities.noString(parentType))
8028      t = parent;
8029    else {
8030      t = parent.predicate("fhir:"+parentType+'.'+name);
8031    }
8032    composeBackboneElement(t, "package", name, element, index);
8033    if (element.hasContainer())
8034      composeCodeableConcept(t, "Medication", "container", element.getContainer(), -1);
8035    for (int i = 0; i < element.getContent().size(); i++)
8036      composeMedicationMedicationPackageContentComponent(t, "Medication", "content", element.getContent().get(i), i);
8037    for (int i = 0; i < element.getBatch().size(); i++)
8038      composeMedicationMedicationPackageBatchComponent(t, "Medication", "batch", element.getBatch().get(i), i);
8039  }
8040
8041  protected void composeMedicationMedicationPackageContentComponent(Complex parent, String parentType, String name, Medication.MedicationPackageContentComponent element, int index) {
8042    if (element == null) 
8043      return;
8044    Complex t;
8045    if (Utilities.noString(parentType))
8046      t = parent;
8047    else {
8048      t = parent.predicate("fhir:"+parentType+'.'+name);
8049    }
8050    composeBackboneElement(t, "content", name, element, index);
8051    if (element.hasItem())
8052      composeType(t, "Medication", "item", element.getItem(), -1);
8053    if (element.hasAmount())
8054      composeQuantity(t, "Medication", "amount", element.getAmount(), -1);
8055  }
8056
8057  protected void composeMedicationMedicationPackageBatchComponent(Complex parent, String parentType, String name, Medication.MedicationPackageBatchComponent element, int index) {
8058    if (element == null) 
8059      return;
8060    Complex t;
8061    if (Utilities.noString(parentType))
8062      t = parent;
8063    else {
8064      t = parent.predicate("fhir:"+parentType+'.'+name);
8065    }
8066    composeBackboneElement(t, "batch", name, element, index);
8067    if (element.hasLotNumberElement())
8068      composeString(t, "Medication", "lotNumber", element.getLotNumberElement(), -1);
8069    if (element.hasExpirationDateElement())
8070      composeDateTime(t, "Medication", "expirationDate", element.getExpirationDateElement(), -1);
8071  }
8072
8073  protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) {
8074    if (element == null) 
8075      return;
8076    Complex t;
8077    if (Utilities.noString(parentType))
8078      t = parent;
8079    else {
8080      t = parent.predicate("fhir:"+parentType+'.'+name);
8081    }
8082    composeDomainResource(t, "MedicationAdministration", name, element, index);
8083    for (int i = 0; i < element.getIdentifier().size(); i++)
8084      composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i);
8085    for (int i = 0; i < element.getDefinition().size(); i++)
8086      composeReference(t, "MedicationAdministration", "definition", element.getDefinition().get(i), i);
8087    for (int i = 0; i < element.getPartOf().size(); i++)
8088      composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i);
8089    if (element.hasStatusElement())
8090      composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1);
8091    if (element.hasCategory())
8092      composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory(), -1);
8093    if (element.hasMedication())
8094      composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1);
8095    if (element.hasSubject())
8096      composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1);
8097    if (element.hasContext())
8098      composeReference(t, "MedicationAdministration", "context", element.getContext(), -1);
8099    for (int i = 0; i < element.getSupportingInformation().size(); i++)
8100      composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i);
8101    if (element.hasEffective())
8102      composeType(t, "MedicationAdministration", "effective", element.getEffective(), -1);
8103    for (int i = 0; i < element.getPerformer().size(); i++)
8104      composeMedicationAdministrationMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i);
8105    if (element.hasNotGivenElement())
8106      composeBoolean(t, "MedicationAdministration", "notGiven", element.getNotGivenElement(), -1);
8107    for (int i = 0; i < element.getReasonNotGiven().size(); i++)
8108      composeCodeableConcept(t, "MedicationAdministration", "reasonNotGiven", element.getReasonNotGiven().get(i), i);
8109    for (int i = 0; i < element.getReasonCode().size(); i++)
8110      composeCodeableConcept(t, "MedicationAdministration", "reasonCode", element.getReasonCode().get(i), i);
8111    for (int i = 0; i < element.getReasonReference().size(); i++)
8112      composeReference(t, "MedicationAdministration", "reasonReference", element.getReasonReference().get(i), i);
8113    if (element.hasPrescription())
8114      composeReference(t, "MedicationAdministration", "prescription", element.getPrescription(), -1);
8115    for (int i = 0; i < element.getDevice().size(); i++)
8116      composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i);
8117    for (int i = 0; i < element.getNote().size(); i++)
8118      composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i);
8119    if (element.hasDosage())
8120      composeMedicationAdministrationMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1);
8121    for (int i = 0; i < element.getEventHistory().size(); i++)
8122      composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i);
8123  }
8124
8125  protected void composeMedicationAdministrationMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent element, int index) {
8126    if (element == null) 
8127      return;
8128    Complex t;
8129    if (Utilities.noString(parentType))
8130      t = parent;
8131    else {
8132      t = parent.predicate("fhir:"+parentType+'.'+name);
8133    }
8134    composeBackboneElement(t, "performer", name, element, index);
8135    if (element.hasActor())
8136      composeReference(t, "MedicationAdministration", "actor", element.getActor(), -1);
8137    if (element.hasOnBehalfOf())
8138      composeReference(t, "MedicationAdministration", "onBehalfOf", element.getOnBehalfOf(), -1);
8139  }
8140
8141  protected void composeMedicationAdministrationMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent element, int index) {
8142    if (element == null) 
8143      return;
8144    Complex t;
8145    if (Utilities.noString(parentType))
8146      t = parent;
8147    else {
8148      t = parent.predicate("fhir:"+parentType+'.'+name);
8149    }
8150    composeBackboneElement(t, "dosage", name, element, index);
8151    if (element.hasTextElement())
8152      composeString(t, "MedicationAdministration", "text", element.getTextElement(), -1);
8153    if (element.hasSite())
8154      composeCodeableConcept(t, "MedicationAdministration", "site", element.getSite(), -1);
8155    if (element.hasRoute())
8156      composeCodeableConcept(t, "MedicationAdministration", "route", element.getRoute(), -1);
8157    if (element.hasMethod())
8158      composeCodeableConcept(t, "MedicationAdministration", "method", element.getMethod(), -1);
8159    if (element.hasDose())
8160      composeQuantity(t, "MedicationAdministration", "dose", element.getDose(), -1);
8161    if (element.hasRate())
8162      composeType(t, "MedicationAdministration", "rate", element.getRate(), -1);
8163  }
8164
8165  protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) {
8166    if (element == null) 
8167      return;
8168    Complex t;
8169    if (Utilities.noString(parentType))
8170      t = parent;
8171    else {
8172      t = parent.predicate("fhir:"+parentType+'.'+name);
8173    }
8174    composeDomainResource(t, "MedicationDispense", name, element, index);
8175    for (int i = 0; i < element.getIdentifier().size(); i++)
8176      composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i);
8177    for (int i = 0; i < element.getPartOf().size(); i++)
8178      composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i);
8179    if (element.hasStatusElement())
8180      composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1);
8181    if (element.hasCategory())
8182      composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory(), -1);
8183    if (element.hasMedication())
8184      composeType(t, "MedicationDispense", "medication", element.getMedication(), -1);
8185    if (element.hasSubject())
8186      composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1);
8187    if (element.hasContext())
8188      composeReference(t, "MedicationDispense", "context", element.getContext(), -1);
8189    for (int i = 0; i < element.getSupportingInformation().size(); i++)
8190      composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i);
8191    for (int i = 0; i < element.getPerformer().size(); i++)
8192      composeMedicationDispenseMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i);
8193    for (int i = 0; i < element.getAuthorizingPrescription().size(); i++)
8194      composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i);
8195    if (element.hasType())
8196      composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1);
8197    if (element.hasQuantity())
8198      composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1);
8199    if (element.hasDaysSupply())
8200      composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1);
8201    if (element.hasWhenPreparedElement())
8202      composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1);
8203    if (element.hasWhenHandedOverElement())
8204      composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1);
8205    if (element.hasDestination())
8206      composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1);
8207    for (int i = 0; i < element.getReceiver().size(); i++)
8208      composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i);
8209    for (int i = 0; i < element.getNote().size(); i++)
8210      composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i);
8211    for (int i = 0; i < element.getDosageInstruction().size(); i++)
8212      composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i);
8213    if (element.hasSubstitution())
8214      composeMedicationDispenseMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1);
8215    for (int i = 0; i < element.getDetectedIssue().size(); i++)
8216      composeReference(t, "MedicationDispense", "detectedIssue", element.getDetectedIssue().get(i), i);
8217    if (element.hasNotDoneElement())
8218      composeBoolean(t, "MedicationDispense", "notDone", element.getNotDoneElement(), -1);
8219    if (element.hasNotDoneReason())
8220      composeType(t, "MedicationDispense", "notDoneReason", element.getNotDoneReason(), -1);
8221    for (int i = 0; i < element.getEventHistory().size(); i++)
8222      composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i);
8223  }
8224
8225  protected void composeMedicationDispenseMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent element, int index) {
8226    if (element == null) 
8227      return;
8228    Complex t;
8229    if (Utilities.noString(parentType))
8230      t = parent;
8231    else {
8232      t = parent.predicate("fhir:"+parentType+'.'+name);
8233    }
8234    composeBackboneElement(t, "performer", name, element, index);
8235    if (element.hasActor())
8236      composeReference(t, "MedicationDispense", "actor", element.getActor(), -1);
8237    if (element.hasOnBehalfOf())
8238      composeReference(t, "MedicationDispense", "onBehalfOf", element.getOnBehalfOf(), -1);
8239  }
8240
8241  protected void composeMedicationDispenseMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) {
8242    if (element == null) 
8243      return;
8244    Complex t;
8245    if (Utilities.noString(parentType))
8246      t = parent;
8247    else {
8248      t = parent.predicate("fhir:"+parentType+'.'+name);
8249    }
8250    composeBackboneElement(t, "substitution", name, element, index);
8251    if (element.hasWasSubstitutedElement())
8252      composeBoolean(t, "MedicationDispense", "wasSubstituted", element.getWasSubstitutedElement(), -1);
8253    if (element.hasType())
8254      composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1);
8255    for (int i = 0; i < element.getReason().size(); i++)
8256      composeCodeableConcept(t, "MedicationDispense", "reason", element.getReason().get(i), i);
8257    for (int i = 0; i < element.getResponsibleParty().size(); i++)
8258      composeReference(t, "MedicationDispense", "responsibleParty", element.getResponsibleParty().get(i), i);
8259  }
8260
8261  protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest element, int index) {
8262    if (element == null) 
8263      return;
8264    Complex t;
8265    if (Utilities.noString(parentType))
8266      t = parent;
8267    else {
8268      t = parent.predicate("fhir:"+parentType+'.'+name);
8269    }
8270    composeDomainResource(t, "MedicationRequest", name, element, index);
8271    for (int i = 0; i < element.getIdentifier().size(); i++)
8272      composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i);
8273    for (int i = 0; i < element.getDefinition().size(); i++)
8274      composeReference(t, "MedicationRequest", "definition", element.getDefinition().get(i), i);
8275    for (int i = 0; i < element.getBasedOn().size(); i++)
8276      composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i);
8277    if (element.hasGroupIdentifier())
8278      composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
8279    if (element.hasStatusElement())
8280      composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1);
8281    if (element.hasIntentElement())
8282      composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1);
8283    if (element.hasCategory())
8284      composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory(), -1);
8285    if (element.hasPriorityElement())
8286      composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1);
8287    if (element.hasMedication())
8288      composeType(t, "MedicationRequest", "medication", element.getMedication(), -1);
8289    if (element.hasSubject())
8290      composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1);
8291    if (element.hasContext())
8292      composeReference(t, "MedicationRequest", "context", element.getContext(), -1);
8293    for (int i = 0; i < element.getSupportingInformation().size(); i++)
8294      composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i);
8295    if (element.hasAuthoredOnElement())
8296      composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
8297    if (element.hasRequester())
8298      composeMedicationRequestMedicationRequestRequesterComponent(t, "MedicationRequest", "requester", element.getRequester(), -1);
8299    if (element.hasRecorder())
8300      composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1);
8301    for (int i = 0; i < element.getReasonCode().size(); i++)
8302      composeCodeableConcept(t, "MedicationRequest", "reasonCode", element.getReasonCode().get(i), i);
8303    for (int i = 0; i < element.getReasonReference().size(); i++)
8304      composeReference(t, "MedicationRequest", "reasonReference", element.getReasonReference().get(i), i);
8305    for (int i = 0; i < element.getNote().size(); i++)
8306      composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i);
8307    for (int i = 0; i < element.getDosageInstruction().size(); i++)
8308      composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i);
8309    if (element.hasDispenseRequest())
8310      composeMedicationRequestMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1);
8311    if (element.hasSubstitution())
8312      composeMedicationRequestMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1);
8313    if (element.hasPriorPrescription())
8314      composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1);
8315    for (int i = 0; i < element.getDetectedIssue().size(); i++)
8316      composeReference(t, "MedicationRequest", "detectedIssue", element.getDetectedIssue().get(i), i);
8317    for (int i = 0; i < element.getEventHistory().size(); i++)
8318      composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i);
8319  }
8320
8321  protected void composeMedicationRequestMedicationRequestRequesterComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestRequesterComponent element, int index) {
8322    if (element == null) 
8323      return;
8324    Complex t;
8325    if (Utilities.noString(parentType))
8326      t = parent;
8327    else {
8328      t = parent.predicate("fhir:"+parentType+'.'+name);
8329    }
8330    composeBackboneElement(t, "requester", name, element, index);
8331    if (element.hasAgent())
8332      composeReference(t, "MedicationRequest", "agent", element.getAgent(), -1);
8333    if (element.hasOnBehalfOf())
8334      composeReference(t, "MedicationRequest", "onBehalfOf", element.getOnBehalfOf(), -1);
8335  }
8336
8337  protected void composeMedicationRequestMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent element, int index) {
8338    if (element == null) 
8339      return;
8340    Complex t;
8341    if (Utilities.noString(parentType))
8342      t = parent;
8343    else {
8344      t = parent.predicate("fhir:"+parentType+'.'+name);
8345    }
8346    composeBackboneElement(t, "dispenseRequest", name, element, index);
8347    if (element.hasValidityPeriod())
8348      composePeriod(t, "MedicationRequest", "validityPeriod", element.getValidityPeriod(), -1);
8349    if (element.hasNumberOfRepeatsAllowedElement())
8350      composePositiveInt(t, "MedicationRequest", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1);
8351    if (element.hasQuantity())
8352      composeQuantity(t, "MedicationRequest", "quantity", element.getQuantity(), -1);
8353    if (element.hasExpectedSupplyDuration())
8354      composeDuration(t, "MedicationRequest", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1);
8355    if (element.hasPerformer())
8356      composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1);
8357  }
8358
8359  protected void composeMedicationRequestMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent element, int index) {
8360    if (element == null) 
8361      return;
8362    Complex t;
8363    if (Utilities.noString(parentType))
8364      t = parent;
8365    else {
8366      t = parent.predicate("fhir:"+parentType+'.'+name);
8367    }
8368    composeBackboneElement(t, "substitution", name, element, index);
8369    if (element.hasAllowedElement())
8370      composeBoolean(t, "MedicationRequest", "allowed", element.getAllowedElement(), -1);
8371    if (element.hasReason())
8372      composeCodeableConcept(t, "MedicationRequest", "reason", element.getReason(), -1);
8373  }
8374
8375  protected void composeMedicationStatement(Complex parent, String parentType, String name, MedicationStatement element, int index) {
8376    if (element == null) 
8377      return;
8378    Complex t;
8379    if (Utilities.noString(parentType))
8380      t = parent;
8381    else {
8382      t = parent.predicate("fhir:"+parentType+'.'+name);
8383    }
8384    composeDomainResource(t, "MedicationStatement", name, element, index);
8385    for (int i = 0; i < element.getIdentifier().size(); i++)
8386      composeIdentifier(t, "MedicationStatement", "identifier", element.getIdentifier().get(i), i);
8387    for (int i = 0; i < element.getBasedOn().size(); i++)
8388      composeReference(t, "MedicationStatement", "basedOn", element.getBasedOn().get(i), i);
8389    for (int i = 0; i < element.getPartOf().size(); i++)
8390      composeReference(t, "MedicationStatement", "partOf", element.getPartOf().get(i), i);
8391    if (element.hasContext())
8392      composeReference(t, "MedicationStatement", "context", element.getContext(), -1);
8393    if (element.hasStatusElement())
8394      composeEnum(t, "MedicationStatement", "status", element.getStatusElement(), -1);
8395    if (element.hasCategory())
8396      composeCodeableConcept(t, "MedicationStatement", "category", element.getCategory(), -1);
8397    if (element.hasMedication())
8398      composeType(t, "MedicationStatement", "medication", element.getMedication(), -1);
8399    if (element.hasEffective())
8400      composeType(t, "MedicationStatement", "effective", element.getEffective(), -1);
8401    if (element.hasDateAssertedElement())
8402      composeDateTime(t, "MedicationStatement", "dateAsserted", element.getDateAssertedElement(), -1);
8403    if (element.hasInformationSource())
8404      composeReference(t, "MedicationStatement", "informationSource", element.getInformationSource(), -1);
8405    if (element.hasSubject())
8406      composeReference(t, "MedicationStatement", "subject", element.getSubject(), -1);
8407    for (int i = 0; i < element.getDerivedFrom().size(); i++)
8408      composeReference(t, "MedicationStatement", "derivedFrom", element.getDerivedFrom().get(i), i);
8409    if (element.hasTakenElement())
8410      composeEnum(t, "MedicationStatement", "taken", element.getTakenElement(), -1);
8411    for (int i = 0; i < element.getReasonNotTaken().size(); i++)
8412      composeCodeableConcept(t, "MedicationStatement", "reasonNotTaken", element.getReasonNotTaken().get(i), i);
8413    for (int i = 0; i < element.getReasonCode().size(); i++)
8414      composeCodeableConcept(t, "MedicationStatement", "reasonCode", element.getReasonCode().get(i), i);
8415    for (int i = 0; i < element.getReasonReference().size(); i++)
8416      composeReference(t, "MedicationStatement", "reasonReference", element.getReasonReference().get(i), i);
8417    for (int i = 0; i < element.getNote().size(); i++)
8418      composeAnnotation(t, "MedicationStatement", "note", element.getNote().get(i), i);
8419    for (int i = 0; i < element.getDosage().size(); i++)
8420      composeDosage(t, "MedicationStatement", "dosage", element.getDosage().get(i), i);
8421  }
8422
8423  protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition element, int index) {
8424    if (element == null) 
8425      return;
8426    Complex t;
8427    if (Utilities.noString(parentType))
8428      t = parent;
8429    else {
8430      t = parent.predicate("fhir:"+parentType+'.'+name);
8431    }
8432    composeDomainResource(t, "MessageDefinition", name, element, index);
8433    if (element.hasUrlElement())
8434      composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1);
8435    if (element.hasIdentifier())
8436      composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier(), -1);
8437    if (element.hasVersionElement())
8438      composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1);
8439    if (element.hasNameElement())
8440      composeString(t, "MessageDefinition", "name", element.getNameElement(), -1);
8441    if (element.hasTitleElement())
8442      composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1);
8443    if (element.hasStatusElement())
8444      composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1);
8445    if (element.hasExperimentalElement())
8446      composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1);
8447    if (element.hasDateElement())
8448      composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1);
8449    if (element.hasPublisherElement())
8450      composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1);
8451    for (int i = 0; i < element.getContact().size(); i++)
8452      composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i);
8453    if (element.hasDescriptionElement())
8454      composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1);
8455    for (int i = 0; i < element.getUseContext().size(); i++)
8456      composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i);
8457    for (int i = 0; i < element.getJurisdiction().size(); i++)
8458      composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
8459    if (element.hasPurposeElement())
8460      composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1);
8461    if (element.hasCopyrightElement())
8462      composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1);
8463    if (element.hasBase())
8464      composeReference(t, "MessageDefinition", "base", element.getBase(), -1);
8465    for (int i = 0; i < element.getParent().size(); i++)
8466      composeReference(t, "MessageDefinition", "parent", element.getParent().get(i), i);
8467    for (int i = 0; i < element.getReplaces().size(); i++)
8468      composeReference(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i);
8469    if (element.hasEvent())
8470      composeCoding(t, "MessageDefinition", "event", element.getEvent(), -1);
8471    if (element.hasCategoryElement())
8472      composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1);
8473    for (int i = 0; i < element.getFocus().size(); i++)
8474      composeMessageDefinitionMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i);
8475    if (element.hasResponseRequiredElement())
8476      composeBoolean(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1);
8477    for (int i = 0; i < element.getAllowedResponse().size(); i++)
8478      composeMessageDefinitionMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i);
8479  }
8480
8481  protected void composeMessageDefinitionMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent element, int index) {
8482    if (element == null) 
8483      return;
8484    Complex t;
8485    if (Utilities.noString(parentType))
8486      t = parent;
8487    else {
8488      t = parent.predicate("fhir:"+parentType+'.'+name);
8489    }
8490    composeBackboneElement(t, "focus", name, element, index);
8491    if (element.hasCodeElement())
8492      composeCode(t, "MessageDefinition", "code", element.getCodeElement(), -1);
8493    if (element.hasProfile())
8494      composeReference(t, "MessageDefinition", "profile", element.getProfile(), -1);
8495    if (element.hasMinElement())
8496      composeUnsignedInt(t, "MessageDefinition", "min", element.getMinElement(), -1);
8497    if (element.hasMaxElement())
8498      composeString(t, "MessageDefinition", "max", element.getMaxElement(), -1);
8499  }
8500
8501  protected void composeMessageDefinitionMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent element, int index) {
8502    if (element == null) 
8503      return;
8504    Complex t;
8505    if (Utilities.noString(parentType))
8506      t = parent;
8507    else {
8508      t = parent.predicate("fhir:"+parentType+'.'+name);
8509    }
8510    composeBackboneElement(t, "allowedResponse", name, element, index);
8511    if (element.hasMessage())
8512      composeReference(t, "MessageDefinition", "message", element.getMessage(), -1);
8513    if (element.hasSituationElement())
8514      composeMarkdown(t, "MessageDefinition", "situation", element.getSituationElement(), -1);
8515  }
8516
8517  protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) {
8518    if (element == null) 
8519      return;
8520    Complex t;
8521    if (Utilities.noString(parentType))
8522      t = parent;
8523    else {
8524      t = parent.predicate("fhir:"+parentType+'.'+name);
8525    }
8526    composeDomainResource(t, "MessageHeader", name, element, index);
8527    if (element.hasEvent())
8528      composeCoding(t, "MessageHeader", "event", element.getEvent(), -1);
8529    for (int i = 0; i < element.getDestination().size(); i++)
8530      composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i);
8531    if (element.hasReceiver())
8532      composeReference(t, "MessageHeader", "receiver", element.getReceiver(), -1);
8533    if (element.hasSender())
8534      composeReference(t, "MessageHeader", "sender", element.getSender(), -1);
8535    if (element.hasTimestampElement())
8536      composeInstant(t, "MessageHeader", "timestamp", element.getTimestampElement(), -1);
8537    if (element.hasEnterer())
8538      composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1);
8539    if (element.hasAuthor())
8540      composeReference(t, "MessageHeader", "author", element.getAuthor(), -1);
8541    if (element.hasSource())
8542      composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1);
8543    if (element.hasResponsible())
8544      composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1);
8545    if (element.hasReason())
8546      composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1);
8547    if (element.hasResponse())
8548      composeMessageHeaderMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1);
8549    for (int i = 0; i < element.getFocus().size(); i++)
8550      composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i);
8551  }
8552
8553  protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) {
8554    if (element == null) 
8555      return;
8556    Complex t;
8557    if (Utilities.noString(parentType))
8558      t = parent;
8559    else {
8560      t = parent.predicate("fhir:"+parentType+'.'+name);
8561    }
8562    composeBackboneElement(t, "destination", name, element, index);
8563    if (element.hasNameElement())
8564      composeString(t, "MessageHeader", "name", element.getNameElement(), -1);
8565    if (element.hasTarget())
8566      composeReference(t, "MessageHeader", "target", element.getTarget(), -1);
8567    if (element.hasEndpointElement())
8568      composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1);
8569  }
8570
8571  protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) {
8572    if (element == null) 
8573      return;
8574    Complex t;
8575    if (Utilities.noString(parentType))
8576      t = parent;
8577    else {
8578      t = parent.predicate("fhir:"+parentType+'.'+name);
8579    }
8580    composeBackboneElement(t, "source", name, element, index);
8581    if (element.hasNameElement())
8582      composeString(t, "MessageHeader", "name", element.getNameElement(), -1);
8583    if (element.hasSoftwareElement())
8584      composeString(t, "MessageHeader", "software", element.getSoftwareElement(), -1);
8585    if (element.hasVersionElement())
8586      composeString(t, "MessageHeader", "version", element.getVersionElement(), -1);
8587    if (element.hasContact())
8588      composeContactPoint(t, "MessageHeader", "contact", element.getContact(), -1);
8589    if (element.hasEndpointElement())
8590      composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1);
8591  }
8592
8593  protected void composeMessageHeaderMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) {
8594    if (element == null) 
8595      return;
8596    Complex t;
8597    if (Utilities.noString(parentType))
8598      t = parent;
8599    else {
8600      t = parent.predicate("fhir:"+parentType+'.'+name);
8601    }
8602    composeBackboneElement(t, "response", name, element, index);
8603    if (element.hasIdentifierElement())
8604      composeId(t, "MessageHeader", "identifier", element.getIdentifierElement(), -1);
8605    if (element.hasCodeElement())
8606      composeEnum(t, "MessageHeader", "code", element.getCodeElement(), -1);
8607    if (element.hasDetails())
8608      composeReference(t, "MessageHeader", "details", element.getDetails(), -1);
8609  }
8610
8611  protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) {
8612    if (element == null) 
8613      return;
8614    Complex t;
8615    if (Utilities.noString(parentType))
8616      t = parent;
8617    else {
8618      t = parent.predicate("fhir:"+parentType+'.'+name);
8619    }
8620    composeDomainResource(t, "NamingSystem", name, element, index);
8621    if (element.hasNameElement())
8622      composeString(t, "NamingSystem", "name", element.getNameElement(), -1);
8623    if (element.hasStatusElement())
8624      composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1);
8625    if (element.hasKindElement())
8626      composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1);
8627    if (element.hasDateElement())
8628      composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1);
8629    if (element.hasPublisherElement())
8630      composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1);
8631    for (int i = 0; i < element.getContact().size(); i++)
8632      composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i);
8633    if (element.hasResponsibleElement())
8634      composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1);
8635    if (element.hasType())
8636      composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1);
8637    if (element.hasDescriptionElement())
8638      composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1);
8639    for (int i = 0; i < element.getUseContext().size(); i++)
8640      composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i);
8641    for (int i = 0; i < element.getJurisdiction().size(); i++)
8642      composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i);
8643    if (element.hasUsageElement())
8644      composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1);
8645    for (int i = 0; i < element.getUniqueId().size(); i++)
8646      composeNamingSystemNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i);
8647    if (element.hasReplacedBy())
8648      composeReference(t, "NamingSystem", "replacedBy", element.getReplacedBy(), -1);
8649  }
8650
8651  protected void composeNamingSystemNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) {
8652    if (element == null) 
8653      return;
8654    Complex t;
8655    if (Utilities.noString(parentType))
8656      t = parent;
8657    else {
8658      t = parent.predicate("fhir:"+parentType+'.'+name);
8659    }
8660    composeBackboneElement(t, "uniqueId", name, element, index);
8661    if (element.hasTypeElement())
8662      composeEnum(t, "NamingSystem", "type", element.getTypeElement(), -1);
8663    if (element.hasValueElement())
8664      composeString(t, "NamingSystem", "value", element.getValueElement(), -1);
8665    if (element.hasPreferredElement())
8666      composeBoolean(t, "NamingSystem", "preferred", element.getPreferredElement(), -1);
8667    if (element.hasCommentElement())
8668      composeString(t, "NamingSystem", "comment", element.getCommentElement(), -1);
8669    if (element.hasPeriod())
8670      composePeriod(t, "NamingSystem", "period", element.getPeriod(), -1);
8671  }
8672
8673  protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder element, int index) {
8674    if (element == null) 
8675      return;
8676    Complex t;
8677    if (Utilities.noString(parentType))
8678      t = parent;
8679    else {
8680      t = parent.predicate("fhir:"+parentType+'.'+name);
8681    }
8682    composeDomainResource(t, "NutritionOrder", name, element, index);
8683    for (int i = 0; i < element.getIdentifier().size(); i++)
8684      composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i);
8685    if (element.hasStatusElement())
8686      composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1);
8687    if (element.hasPatient())
8688      composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1);
8689    if (element.hasEncounter())
8690      composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1);
8691    if (element.hasDateTimeElement())
8692      composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1);
8693    if (element.hasOrderer())
8694      composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1);
8695    for (int i = 0; i < element.getAllergyIntolerance().size(); i++)
8696      composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i);
8697    for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++)
8698      composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i);
8699    for (int i = 0; i < element.getExcludeFoodModifier().size(); i++)
8700      composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i);
8701    if (element.hasOralDiet())
8702      composeNutritionOrderNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1);
8703    for (int i = 0; i < element.getSupplement().size(); i++)
8704      composeNutritionOrderNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i);
8705    if (element.hasEnteralFormula())
8706      composeNutritionOrderNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1);
8707  }
8708
8709  protected void composeNutritionOrderNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent element, int index) {
8710    if (element == null) 
8711      return;
8712    Complex t;
8713    if (Utilities.noString(parentType))
8714      t = parent;
8715    else {
8716      t = parent.predicate("fhir:"+parentType+'.'+name);
8717    }
8718    composeBackboneElement(t, "oralDiet", name, element, index);
8719    for (int i = 0; i < element.getType().size(); i++)
8720      composeCodeableConcept(t, "NutritionOrder", "type", element.getType().get(i), i);
8721    for (int i = 0; i < element.getSchedule().size(); i++)
8722      composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i);
8723    for (int i = 0; i < element.getNutrient().size(); i++)
8724      composeNutritionOrderNutritionOrderOralDietNutrientComponent(t, "NutritionOrder", "nutrient", element.getNutrient().get(i), i);
8725    for (int i = 0; i < element.getTexture().size(); i++)
8726      composeNutritionOrderNutritionOrderOralDietTextureComponent(t, "NutritionOrder", "texture", element.getTexture().get(i), i);
8727    for (int i = 0; i < element.getFluidConsistencyType().size(); i++)
8728      composeCodeableConcept(t, "NutritionOrder", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i);
8729    if (element.hasInstructionElement())
8730      composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1);
8731  }
8732
8733  protected void composeNutritionOrderNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) {
8734    if (element == null) 
8735      return;
8736    Complex t;
8737    if (Utilities.noString(parentType))
8738      t = parent;
8739    else {
8740      t = parent.predicate("fhir:"+parentType+'.'+name);
8741    }
8742    composeBackboneElement(t, "nutrient", name, element, index);
8743    if (element.hasModifier())
8744      composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1);
8745    if (element.hasAmount())
8746      composeQuantity(t, "NutritionOrder", "amount", element.getAmount(), -1);
8747  }
8748
8749  protected void composeNutritionOrderNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) {
8750    if (element == null) 
8751      return;
8752    Complex t;
8753    if (Utilities.noString(parentType))
8754      t = parent;
8755    else {
8756      t = parent.predicate("fhir:"+parentType+'.'+name);
8757    }
8758    composeBackboneElement(t, "texture", name, element, index);
8759    if (element.hasModifier())
8760      composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1);
8761    if (element.hasFoodType())
8762      composeCodeableConcept(t, "NutritionOrder", "foodType", element.getFoodType(), -1);
8763  }
8764
8765  protected void composeNutritionOrderNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) {
8766    if (element == null) 
8767      return;
8768    Complex t;
8769    if (Utilities.noString(parentType))
8770      t = parent;
8771    else {
8772