001package org.hl7.fhir.r4.formats;
002
003
004
005/*
006  Copyright (c) 2011+, HL7, Inc.
007  All rights reserved.
008  
009  Redistribution and use in source and binary forms, with or without modification, 
010  are permitted provided that the following conditions are met:
011  
012   * Redistributions of source code must retain the above copyright notice, this 
013     list of conditions and the following disclaimer.
014   * Redistributions in binary form must reproduce the above copyright notice, 
015     this list of conditions and the following disclaimer in the documentation 
016     and/or other materials provided with the distribution.
017   * Neither the name of HL7 nor the names of its contributors may be used to 
018     endorse or promote products derived from this software without specific 
019     prior written permission.
020  
021  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
022  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
023  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
024  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
025  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
026  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
027  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
028  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
029  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
030  POSSIBILITY OF SUCH DAMAGE.
031  
032*/
033
034
035// Generated on Tue, May 12, 2020 07:48+1000 for FHIR v4.0.1
036
037import org.hl7.fhir.r4.model.DateType;
038import org.hl7.fhir.r4.model.DateTimeType;
039import org.hl7.fhir.r4.model.CodeType;
040import org.hl7.fhir.r4.model.StringType;
041import org.hl7.fhir.r4.model.IntegerType;
042import org.hl7.fhir.r4.model.OidType;
043import org.hl7.fhir.r4.model.CanonicalType;
044import org.hl7.fhir.r4.model.UriType;
045import org.hl7.fhir.r4.model.UuidType;
046import org.hl7.fhir.r4.model.UrlType;
047import org.hl7.fhir.r4.model.InstantType;
048import org.hl7.fhir.r4.model.BooleanType;
049import org.hl7.fhir.r4.model.Base64BinaryType;
050import org.hl7.fhir.r4.model.UnsignedIntType;
051import org.hl7.fhir.r4.model.MarkdownType;
052import org.hl7.fhir.r4.model.TimeType;
053import org.hl7.fhir.r4.model.IdType;
054import org.hl7.fhir.r4.model.PositiveIntType;
055import org.hl7.fhir.r4.model.DecimalType;
056import org.hl7.fhir.r4.model.*;
057import org.xmlpull.v1.*;
058import org.hl7.fhir.utilities.Utilities;
059import org.hl7.fhir.exceptions.FHIRFormatError;
060import org.hl7.fhir.exceptions.FHIRException;
061import org.hl7.fhir.r4.utils.formats.Turtle.Complex;
062import java.io.IOException;
063
064public class RdfParser extends RdfParserBase {
065
066  public RdfParser() {
067    super();
068  }
069
070  public RdfParser(boolean allowUnknownContent) {
071    super();
072    setAllowUnknownContent(allowUnknownContent);
073  }
074
075
076  protected void composeElement(Complex t, String parentType, String name, Element element, int index) {
077    if (element == null) 
078      return;
079    if (index > -1)
080      t.predicate("fhir:index", Integer.toString(index));
081    if (element.hasIdElement())
082      composeString(t, "Element", "id", element.getIdElement(), -1);
083    for (int i = 0; i < element.getExtension().size(); i++)
084      composeExtension(t, "Element", "extension", element.getExtension().get(i), i);
085  }
086
087  protected void composeBackboneElement(Complex t, String tType, String name, BackboneElement element, int index) {
088    composeElement(t, tType, name, element, index);
089    for (int i = 0; i < element.getModifierExtension().size(); i++)
090      composeExtension(t, "Element", "modifierExtension", element.getModifierExtension().get(i), i);
091  }
092
093  private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) {
094    if (value == null)
095      return;
096    Complex t = parent.predicate("fhir:"+parentType+"."+name);
097    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
098    composeElement(t, parentType, name, value, index);
099    decorateCode(t, value);
100  }
101
102
103  protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) {
104    if (value == null)
105      return;
106    Complex t = parent.predicate("fhir:"+parentType+"."+name);
107    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
108    composeElement(t, parentType, name, value, index);
109  }
110
111  protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) {
112    if (value == null)
113      return;
114    Complex t = parent.predicate("fhir:"+parentType+"."+name);
115    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
116    composeElement(t, parentType, name, value, index);
117  }
118
119  protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) {
120    if (value == null)
121      return;
122    Complex t = parent.predicate("fhir:"+parentType+"."+name);
123    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
124    composeElement(t, parentType, name, value, index);
125    decorateCode(t, value);
126  }
127
128  protected void composeString(Complex parent, String parentType, String name, StringType 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 composeInteger(Complex parent, String parentType, String name, IntegerType 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 composeOid(Complex parent, String parentType, String name, OidType 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 composeCanonical(Complex parent, String parentType, String name, CanonicalType 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 composeUri(Complex parent, String parentType, String name, UriType 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 composeUuid(Complex parent, String parentType, String name, UuidType 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 composeUrl(Complex parent, String parentType, String name, UrlType 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 composeInstant(Complex parent, String parentType, String name, InstantType 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 composeBoolean(Complex parent, String parentType, String name, BooleanType 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 composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType 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 composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType 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 composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) {
217    if (value == null)
218      return;
219    Complex t = parent.predicate("fhir:"+parentType+"."+name);
220    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
221    composeElement(t, parentType, name, value, index);
222  }
223
224  protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) {
225    if (value == null)
226      return;
227    Complex t = parent.predicate("fhir:"+parentType+"."+name);
228    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
229    composeElement(t, parentType, name, value, index);
230  }
231
232  protected void composeId(Complex parent, String parentType, String name, IdType value, int index) {
233    if (value == null)
234      return;
235    Complex t = parent.predicate("fhir:"+parentType+"."+name);
236    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
237    composeElement(t, parentType, name, value, index);
238  }
239
240  protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) {
241    if (value == null)
242      return;
243    Complex t = parent.predicate("fhir:"+parentType+"."+name);
244    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
245    composeElement(t, parentType, name, value, index);
246  }
247
248  protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) {
249    if (value == null)
250      return;
251    Complex t = parent.predicate("fhir:"+parentType+"."+name);
252    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
253    composeElement(t, parentType, name, value, index);
254  }
255
256  protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) {
257    if (element == null) 
258      return;
259    Complex t;
260    if (Utilities.noString(parentType))
261      t = parent;
262    else {
263      t = parent.predicate("fhir:"+parentType+'.'+name);
264    }
265    composeElement(t, "Extension", name, element, index);
266    if (element.hasUrlElement())
267      composeUri(t, "Extension", "url", element.getUrlElement(), -1);
268    if (element.hasValue())
269      composeType(t, "Extension", "value", element.getValue(), -1);
270  }
271
272  protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) {
273    if (element == null) 
274      return;
275    Complex t;
276    if (Utilities.noString(parentType))
277      t = parent;
278    else {
279      t = parent.predicate("fhir:"+parentType+'.'+name);
280    }
281    composeElement(t, "Narrative", name, element, index);
282    if (element.hasStatusElement())
283      composeEnum(t, "Narrative", "status", element.getStatusElement(), -1);
284    if (element.hasDiv())
285      composeXhtml(t, "Narrative", "div", element.getDiv(), -1);
286  }
287
288  protected void composeMeta(Complex parent, String parentType, String name, Meta 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, "Meta", name, element, index);
298    if (element.hasVersionIdElement())
299      composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1);
300    if (element.hasLastUpdatedElement())
301      composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1);
302    if (element.hasSourceElement())
303      composeUri(t, "Meta", "source", element.getSourceElement(), -1);
304    for (int i = 0; i < element.getProfile().size(); i++)
305      composeCanonical(t, "Meta", "profile", element.getProfile().get(i), i);
306    for (int i = 0; i < element.getSecurity().size(); i++)
307      composeCoding(t, "Meta", "security", element.getSecurity().get(i), i);
308    for (int i = 0; i < element.getTag().size(); i++)
309      composeCoding(t, "Meta", "tag", element.getTag().get(i), i);
310  }
311
312  protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) {
313    if (element == null) 
314      return;
315    Complex t;
316    if (Utilities.noString(parentType))
317      t = parent;
318    else {
319      t = parent.predicate("fhir:"+parentType+'.'+name);
320    }
321    composeElement(t, "Address", name, element, index);
322    if (element.hasUseElement())
323      composeEnum(t, "Address", "use", element.getUseElement(), -1);
324    if (element.hasTypeElement())
325      composeEnum(t, "Address", "type", element.getTypeElement(), -1);
326    if (element.hasTextElement())
327      composeString(t, "Address", "text", element.getTextElement(), -1);
328    for (int i = 0; i < element.getLine().size(); i++)
329      composeString(t, "Address", "line", element.getLine().get(i), i);
330    if (element.hasCityElement())
331      composeString(t, "Address", "city", element.getCityElement(), -1);
332    if (element.hasDistrictElement())
333      composeString(t, "Address", "district", element.getDistrictElement(), -1);
334    if (element.hasStateElement())
335      composeString(t, "Address", "state", element.getStateElement(), -1);
336    if (element.hasPostalCodeElement())
337      composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1);
338    if (element.hasCountryElement())
339      composeString(t, "Address", "country", element.getCountryElement(), -1);
340    if (element.hasPeriod())
341      composePeriod(t, "Address", "period", element.getPeriod(), -1);
342  }
343
344  protected void composeContributor(Complex parent, String parentType, String name, Contributor 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, "Contributor", name, element, index);
354    if (element.hasTypeElement())
355      composeEnum(t, "Contributor", "type", element.getTypeElement(), -1);
356    if (element.hasNameElement())
357      composeString(t, "Contributor", "name", element.getNameElement(), -1);
358    for (int i = 0; i < element.getContact().size(); i++)
359      composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i);
360  }
361
362  protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) {
363    if (element == null) 
364      return;
365    Complex t;
366    if (Utilities.noString(parentType))
367      t = parent;
368    else {
369      t = parent.predicate("fhir:"+parentType+'.'+name);
370    }
371    composeElement(t, "Attachment", name, element, index);
372    if (element.hasContentTypeElement())
373      composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1);
374    if (element.hasLanguageElement())
375      composeCode(t, "Attachment", "language", element.getLanguageElement(), -1);
376    if (element.hasDataElement())
377      composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1);
378    if (element.hasUrlElement())
379      composeUrl(t, "Attachment", "url", element.getUrlElement(), -1);
380    if (element.hasSizeElement())
381      composeUnsignedInt(t, "Attachment", "size", element.getSizeElement(), -1);
382    if (element.hasHashElement())
383      composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1);
384    if (element.hasTitleElement())
385      composeString(t, "Attachment", "title", element.getTitleElement(), -1);
386    if (element.hasCreationElement())
387      composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1);
388  }
389
390  protected void composeCount(Complex parent, String parentType, String name, Count 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, "Count", name, element, index);
400  }
401
402  protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement 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, "DataRequirement", name, element, index);
412    if (element.hasTypeElement())
413      composeCode(t, "DataRequirement", "type", element.getTypeElement(), -1);
414    for (int i = 0; i < element.getProfile().size(); i++)
415      composeCanonical(t, "DataRequirement", "profile", element.getProfile().get(i), i);
416    if (element.hasSubject())
417      composeType(t, "DataRequirement", "subject", element.getSubject(), -1);
418    for (int i = 0; i < element.getMustSupport().size(); i++)
419      composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i);
420    for (int i = 0; i < element.getCodeFilter().size(); i++)
421      composeDataRequirementDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i);
422    for (int i = 0; i < element.getDateFilter().size(); i++)
423      composeDataRequirementDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i);
424    if (element.hasLimitElement())
425      composePositiveInt(t, "DataRequirement", "limit", element.getLimitElement(), -1);
426    for (int i = 0; i < element.getSort().size(); i++)
427      composeDataRequirementDataRequirementSortComponent(t, "DataRequirement", "sort", element.getSort().get(i), i);
428  }
429
430  protected void composeDataRequirementDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) {
431    if (element == null) 
432      return;
433    Complex t;
434    if (Utilities.noString(parentType))
435      t = parent;
436    else {
437      t = parent.predicate("fhir:"+parentType+'.'+name);
438    }
439    composeElement(t, "codeFilter", name, element, index);
440    if (element.hasPathElement())
441      composeString(t, "DataRequirement", "path", element.getPathElement(), -1);
442    if (element.hasSearchParamElement())
443      composeString(t, "DataRequirement", "searchParam", element.getSearchParamElement(), -1);
444    if (element.hasValueSetElement())
445      composeCanonical(t, "DataRequirement", "valueSet", element.getValueSetElement(), -1);
446    for (int i = 0; i < element.getCode().size(); i++)
447      composeCoding(t, "DataRequirement", "code", element.getCode().get(i), i);
448  }
449
450  protected void composeDataRequirementDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) {
451    if (element == null) 
452      return;
453    Complex t;
454    if (Utilities.noString(parentType))
455      t = parent;
456    else {
457      t = parent.predicate("fhir:"+parentType+'.'+name);
458    }
459    composeElement(t, "dateFilter", name, element, index);
460    if (element.hasPathElement())
461      composeString(t, "DataRequirement", "path", element.getPathElement(), -1);
462    if (element.hasSearchParamElement())
463      composeString(t, "DataRequirement", "searchParam", element.getSearchParamElement(), -1);
464    if (element.hasValue())
465      composeType(t, "DataRequirement", "value", element.getValue(), -1);
466  }
467
468  protected void composeDataRequirementDataRequirementSortComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementSortComponent element, int index) {
469    if (element == null) 
470      return;
471    Complex t;
472    if (Utilities.noString(parentType))
473      t = parent;
474    else {
475      t = parent.predicate("fhir:"+parentType+'.'+name);
476    }
477    composeElement(t, "sort", name, element, index);
478    if (element.hasPathElement())
479      composeString(t, "DataRequirement", "path", element.getPathElement(), -1);
480    if (element.hasDirectionElement())
481      composeEnum(t, "DataRequirement", "direction", element.getDirectionElement(), -1);
482  }
483
484  protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) {
485    if (element == null) 
486      return;
487    Complex t;
488    if (Utilities.noString(parentType))
489      t = parent;
490    else {
491      t = parent.predicate("fhir:"+parentType+'.'+name);
492    }
493    composeElement(t, "Dosage", name, element, index);
494    if (element.hasSequenceElement())
495      composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1);
496    if (element.hasTextElement())
497      composeString(t, "Dosage", "text", element.getTextElement(), -1);
498    for (int i = 0; i < element.getAdditionalInstruction().size(); i++)
499      composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i);
500    if (element.hasPatientInstructionElement())
501      composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1);
502    if (element.hasTiming())
503      composeTiming(t, "Dosage", "timing", element.getTiming(), -1);
504    if (element.hasAsNeeded())
505      composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1);
506    if (element.hasSite())
507      composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1);
508    if (element.hasRoute())
509      composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1);
510    if (element.hasMethod())
511      composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1);
512    for (int i = 0; i < element.getDoseAndRate().size(); i++)
513      composeDosageDosageDoseAndRateComponent(t, "Dosage", "doseAndRate", element.getDoseAndRate().get(i), i);
514    if (element.hasMaxDosePerPeriod())
515      composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1);
516    if (element.hasMaxDosePerAdministration())
517      composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1);
518    if (element.hasMaxDosePerLifetime())
519      composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1);
520  }
521
522  protected void composeDosageDosageDoseAndRateComponent(Complex parent, String parentType, String name, Dosage.DosageDoseAndRateComponent element, int index) {
523    if (element == null) 
524      return;
525    Complex t;
526    if (Utilities.noString(parentType))
527      t = parent;
528    else {
529      t = parent.predicate("fhir:"+parentType+'.'+name);
530    }
531    composeElement(t, "doseAndRate", name, element, index);
532    if (element.hasType())
533      composeCodeableConcept(t, "Dosage", "type", element.getType(), -1);
534    if (element.hasDose())
535      composeType(t, "Dosage", "dose", element.getDose(), -1);
536    if (element.hasRate())
537      composeType(t, "Dosage", "rate", element.getRate(), -1);
538  }
539
540  protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) {
541    if (element == null) 
542      return;
543    Complex t;
544    if (Utilities.noString(parentType))
545      t = parent;
546    else {
547      t = parent.predicate("fhir:"+parentType+'.'+name);
548    }
549    composeElement(t, "Money", name, element, index);
550    if (element.hasValueElement())
551      composeDecimal(t, "Money", "value", element.getValueElement(), -1);
552    if (element.hasCurrencyElement())
553      composeCode(t, "Money", "currency", element.getCurrencyElement(), -1);
554  }
555
556  protected void composeHumanName(Complex parent, String parentType, String name, HumanName 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, "HumanName", name, element, index);
566    if (element.hasUseElement())
567      composeEnum(t, "HumanName", "use", element.getUseElement(), -1);
568    if (element.hasTextElement())
569      composeString(t, "HumanName", "text", element.getTextElement(), -1);
570    if (element.hasFamilyElement())
571      composeString(t, "HumanName", "family", element.getFamilyElement(), -1);
572    for (int i = 0; i < element.getGiven().size(); i++)
573      composeString(t, "HumanName", "given", element.getGiven().get(i), i);
574    for (int i = 0; i < element.getPrefix().size(); i++)
575      composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i);
576    for (int i = 0; i < element.getSuffix().size(); i++)
577      composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i);
578    if (element.hasPeriod())
579      composePeriod(t, "HumanName", "period", element.getPeriod(), -1);
580  }
581
582  protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) {
583    if (element == null) 
584      return;
585    Complex t;
586    if (Utilities.noString(parentType))
587      t = parent;
588    else {
589      t = parent.predicate("fhir:"+parentType+'.'+name);
590    }
591    composeElement(t, "ContactPoint", name, element, index);
592    if (element.hasSystemElement())
593      composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1);
594    if (element.hasValueElement())
595      composeString(t, "ContactPoint", "value", element.getValueElement(), -1);
596    if (element.hasUseElement())
597      composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1);
598    if (element.hasRankElement())
599      composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1);
600    if (element.hasPeriod())
601      composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1);
602  }
603
604  protected void composeMarketingStatus(Complex parent, String parentType, String name, MarketingStatus element, int index) {
605    if (element == null) 
606      return;
607    Complex t;
608    if (Utilities.noString(parentType))
609      t = parent;
610    else {
611      t = parent.predicate("fhir:"+parentType+'.'+name);
612    }
613    composeElement(t, "MarketingStatus", name, element, index);
614    if (element.hasCountry())
615      composeCodeableConcept(t, "MarketingStatus", "country", element.getCountry(), -1);
616    if (element.hasJurisdiction())
617      composeCodeableConcept(t, "MarketingStatus", "jurisdiction", element.getJurisdiction(), -1);
618    if (element.hasStatus())
619      composeCodeableConcept(t, "MarketingStatus", "status", element.getStatus(), -1);
620    if (element.hasDateRange())
621      composePeriod(t, "MarketingStatus", "dateRange", element.getDateRange(), -1);
622    if (element.hasRestoreDateElement())
623      composeDateTime(t, "MarketingStatus", "restoreDate", element.getRestoreDateElement(), -1);
624  }
625
626  protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) {
627    if (element == null) 
628      return;
629    Complex t;
630    if (Utilities.noString(parentType))
631      t = parent;
632    else {
633      t = parent.predicate("fhir:"+parentType+'.'+name);
634    }
635    composeElement(t, "Identifier", name, element, index);
636    if (element.hasUseElement())
637      composeEnum(t, "Identifier", "use", element.getUseElement(), -1);
638    if (element.hasType())
639      composeCodeableConcept(t, "Identifier", "type", element.getType(), -1);
640    if (element.hasSystemElement())
641      composeUri(t, "Identifier", "system", element.getSystemElement(), -1);
642    if (element.hasValueElement())
643      composeString(t, "Identifier", "value", element.getValueElement(), -1);
644    if (element.hasPeriod())
645      composePeriod(t, "Identifier", "period", element.getPeriod(), -1);
646    if (element.hasAssigner())
647      composeReference(t, "Identifier", "assigner", element.getAssigner(), -1);
648  }
649
650  protected void composeSubstanceAmount(Complex parent, String parentType, String name, SubstanceAmount element, int index) {
651    if (element == null) 
652      return;
653    Complex t;
654    if (Utilities.noString(parentType))
655      t = parent;
656    else {
657      t = parent.predicate("fhir:"+parentType+'.'+name);
658    }
659    composeElement(t, "SubstanceAmount", name, element, index);
660    if (element.hasAmount())
661      composeType(t, "SubstanceAmount", "amount", element.getAmount(), -1);
662    if (element.hasAmountType())
663      composeCodeableConcept(t, "SubstanceAmount", "amountType", element.getAmountType(), -1);
664    if (element.hasAmountTextElement())
665      composeString(t, "SubstanceAmount", "amountText", element.getAmountTextElement(), -1);
666    if (element.hasReferenceRange())
667      composeSubstanceAmountSubstanceAmountReferenceRangeComponent(t, "SubstanceAmount", "referenceRange", element.getReferenceRange(), -1);
668  }
669
670  protected void composeSubstanceAmountSubstanceAmountReferenceRangeComponent(Complex parent, String parentType, String name, SubstanceAmount.SubstanceAmountReferenceRangeComponent 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, "referenceRange", name, element, index);
680    if (element.hasLowLimit())
681      composeQuantity(t, "SubstanceAmount", "lowLimit", element.getLowLimit(), -1);
682    if (element.hasHighLimit())
683      composeQuantity(t, "SubstanceAmount", "highLimit", element.getHighLimit(), -1);
684  }
685
686  protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) {
687    if (element == null) 
688      return;
689    Complex t;
690    if (Utilities.noString(parentType))
691      t = parent;
692    else {
693      t = parent.predicate("fhir:"+parentType+'.'+name);
694    }
695    composeElement(t, "Coding", name, element, index);
696    decorateCoding(t, element);
697    if (element.hasSystemElement())
698      composeUri(t, "Coding", "system", element.getSystemElement(), -1);
699    if (element.hasVersionElement())
700      composeString(t, "Coding", "version", element.getVersionElement(), -1);
701    if (element.hasCodeElement())
702      composeCode(t, "Coding", "code", element.getCodeElement(), -1);
703    if (element.hasDisplayElement())
704      composeString(t, "Coding", "display", element.getDisplayElement(), -1);
705    if (element.hasUserSelectedElement())
706      composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1);
707  }
708
709  protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) {
710    if (element == null) 
711      return;
712    Complex t;
713    if (Utilities.noString(parentType))
714      t = parent;
715    else {
716      t = parent.predicate("fhir:"+parentType+'.'+name);
717    }
718    composeElement(t, "SampledData", name, element, index);
719    if (element.hasOrigin())
720      composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1);
721    if (element.hasPeriodElement())
722      composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1);
723    if (element.hasFactorElement())
724      composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1);
725    if (element.hasLowerLimitElement())
726      composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1);
727    if (element.hasUpperLimitElement())
728      composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1);
729    if (element.hasDimensionsElement())
730      composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1);
731    if (element.hasDataElement())
732      composeString(t, "SampledData", "data", element.getDataElement(), -1);
733  }
734
735  protected void composePopulation(Complex parent, String parentType, String name, Population element, int index) {
736    if (element == null) 
737      return;
738    Complex t;
739    if (Utilities.noString(parentType))
740      t = parent;
741    else {
742      t = parent.predicate("fhir:"+parentType+'.'+name);
743    }
744    composeElement(t, "Population", name, element, index);
745    if (element.hasAge())
746      composeType(t, "Population", "age", element.getAge(), -1);
747    if (element.hasGender())
748      composeCodeableConcept(t, "Population", "gender", element.getGender(), -1);
749    if (element.hasRace())
750      composeCodeableConcept(t, "Population", "race", element.getRace(), -1);
751    if (element.hasPhysiologicalCondition())
752      composeCodeableConcept(t, "Population", "physiologicalCondition", element.getPhysiologicalCondition(), -1);
753  }
754
755  protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) {
756    if (element == null) 
757      return;
758    Complex t;
759    if (Utilities.noString(parentType))
760      t = parent;
761    else {
762      t = parent.predicate("fhir:"+parentType+'.'+name);
763    }
764    composeElement(t, "Ratio", name, element, index);
765    if (element.hasNumerator())
766      composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1);
767    if (element.hasDenominator())
768      composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1);
769  }
770
771  protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) {
772    if (element == null) 
773      return;
774    Complex t;
775    if (Utilities.noString(parentType))
776      t = parent;
777    else {
778      t = parent.predicate("fhir:"+parentType+'.'+name);
779    }
780    composeElement(t, "Distance", name, element, index);
781  }
782
783  protected void composeAge(Complex parent, String parentType, String name, Age element, int index) {
784    if (element == null) 
785      return;
786    Complex t;
787    if (Utilities.noString(parentType))
788      t = parent;
789    else {
790      t = parent.predicate("fhir:"+parentType+'.'+name);
791    }
792    composeElement(t, "Age", name, element, index);
793  }
794
795  protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) {
796    if (element == null) 
797      return;
798    Complex t;
799    if (Utilities.noString(parentType))
800      t = parent;
801    else {
802      t = parent.predicate("fhir:"+parentType+'.'+name);
803    }
804    composeElement(t, "Reference", name, element, index);
805    if (element.hasReferenceElement())
806      composeString(t, "Reference", "reference", element.getReferenceElement_(), -1);
807    if (element.hasTypeElement())
808      composeUri(t, "Reference", "type", element.getTypeElement(), -1);
809    if (element.hasIdentifier())
810      composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1);
811    if (element.hasDisplayElement())
812      composeString(t, "Reference", "display", element.getDisplayElement(), -1);
813  }
814
815  protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) {
816    if (element == null) 
817      return;
818    Complex t;
819    if (Utilities.noString(parentType))
820      t = parent;
821    else {
822      t = parent.predicate("fhir:"+parentType+'.'+name);
823    }
824    composeElement(t, "TriggerDefinition", name, element, index);
825    if (element.hasTypeElement())
826      composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1);
827    if (element.hasNameElement())
828      composeString(t, "TriggerDefinition", "name", element.getNameElement(), -1);
829    if (element.hasTiming())
830      composeType(t, "TriggerDefinition", "timing", element.getTiming(), -1);
831    for (int i = 0; i < element.getData().size(); i++)
832      composeDataRequirement(t, "TriggerDefinition", "data", element.getData().get(i), i);
833    if (element.hasCondition())
834      composeExpression(t, "TriggerDefinition", "condition", element.getCondition(), -1);
835  }
836
837  protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) {
838    if (element == null) 
839      return;
840    Complex t;
841    if (Utilities.noString(parentType))
842      t = parent;
843    else {
844      t = parent.predicate("fhir:"+parentType+'.'+name);
845    }
846    composeElement(t, "Quantity", name, element, index);
847    if (element.hasValueElement())
848      composeDecimal(t, "Quantity", "value", element.getValueElement(), -1);
849    if (element.hasComparatorElement())
850      composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1);
851    if (element.hasUnitElement())
852      composeString(t, "Quantity", "unit", element.getUnitElement(), -1);
853    if (element.hasSystemElement())
854      composeUri(t, "Quantity", "system", element.getSystemElement(), -1);
855    if (element.hasCodeElement())
856      composeCode(t, "Quantity", "code", element.getCodeElement(), -1);
857  }
858
859  protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) {
860    if (element == null) 
861      return;
862    Complex t;
863    if (Utilities.noString(parentType))
864      t = parent;
865    else {
866      t = parent.predicate("fhir:"+parentType+'.'+name);
867    }
868    composeElement(t, "Period", name, element, index);
869    if (element.hasStartElement())
870      composeDateTime(t, "Period", "start", element.getStartElement(), -1);
871    if (element.hasEndElement())
872      composeDateTime(t, "Period", "end", element.getEndElement(), -1);
873  }
874
875  protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) {
876    if (element == null) 
877      return;
878    Complex t;
879    if (Utilities.noString(parentType))
880      t = parent;
881    else {
882      t = parent.predicate("fhir:"+parentType+'.'+name);
883    }
884    composeElement(t, "Duration", name, element, index);
885  }
886
887  protected void composeRange(Complex parent, String parentType, String name, Range element, int index) {
888    if (element == null) 
889      return;
890    Complex t;
891    if (Utilities.noString(parentType))
892      t = parent;
893    else {
894      t = parent.predicate("fhir:"+parentType+'.'+name);
895    }
896    composeElement(t, "Range", name, element, index);
897    if (element.hasLow())
898      composeQuantity(t, "Range", "low", element.getLow(), -1);
899    if (element.hasHigh())
900      composeQuantity(t, "Range", "high", element.getHigh(), -1);
901  }
902
903  protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) {
904    if (element == null) 
905      return;
906    Complex t;
907    if (Utilities.noString(parentType))
908      t = parent;
909    else {
910      t = parent.predicate("fhir:"+parentType+'.'+name);
911    }
912    composeElement(t, "RelatedArtifact", name, element, index);
913    if (element.hasTypeElement())
914      composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1);
915    if (element.hasLabelElement())
916      composeString(t, "RelatedArtifact", "label", element.getLabelElement(), -1);
917    if (element.hasDisplayElement())
918      composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1);
919    if (element.hasCitationElement())
920      composeMarkdown(t, "RelatedArtifact", "citation", element.getCitationElement(), -1);
921    if (element.hasUrlElement())
922      composeUrl(t, "RelatedArtifact", "url", element.getUrlElement(), -1);
923    if (element.hasDocument())
924      composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1);
925    if (element.hasResourceElement())
926      composeCanonical(t, "RelatedArtifact", "resource", element.getResourceElement(), -1);
927  }
928
929  protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) {
930    if (element == null) 
931      return;
932    Complex t;
933    if (Utilities.noString(parentType))
934      t = parent;
935    else {
936      t = parent.predicate("fhir:"+parentType+'.'+name);
937    }
938    composeElement(t, "Annotation", name, element, index);
939    if (element.hasAuthor())
940      composeType(t, "Annotation", "author", element.getAuthor(), -1);
941    if (element.hasTimeElement())
942      composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1);
943    if (element.hasTextElement())
944      composeMarkdown(t, "Annotation", "text", element.getTextElement(), -1);
945  }
946
947  protected void composeProductShelfLife(Complex parent, String parentType, String name, ProductShelfLife element, int index) {
948    if (element == null) 
949      return;
950    Complex t;
951    if (Utilities.noString(parentType))
952      t = parent;
953    else {
954      t = parent.predicate("fhir:"+parentType+'.'+name);
955    }
956    composeElement(t, "ProductShelfLife", name, element, index);
957    if (element.hasIdentifier())
958      composeIdentifier(t, "ProductShelfLife", "identifier", element.getIdentifier(), -1);
959    if (element.hasType())
960      composeCodeableConcept(t, "ProductShelfLife", "type", element.getType(), -1);
961    if (element.hasPeriod())
962      composeQuantity(t, "ProductShelfLife", "period", element.getPeriod(), -1);
963    for (int i = 0; i < element.getSpecialPrecautionsForStorage().size(); i++)
964      composeCodeableConcept(t, "ProductShelfLife", "specialPrecautionsForStorage", element.getSpecialPrecautionsForStorage().get(i), i);
965  }
966
967  protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) {
968    if (element == null) 
969      return;
970    Complex t;
971    if (Utilities.noString(parentType))
972      t = parent;
973    else {
974      t = parent.predicate("fhir:"+parentType+'.'+name);
975    }
976    composeElement(t, "ContactDetail", name, element, index);
977    if (element.hasNameElement())
978      composeString(t, "ContactDetail", "name", element.getNameElement(), -1);
979    for (int i = 0; i < element.getTelecom().size(); i++)
980      composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i);
981  }
982
983  protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) {
984    if (element == null) 
985      return;
986    Complex t;
987    if (Utilities.noString(parentType))
988      t = parent;
989    else {
990      t = parent.predicate("fhir:"+parentType+'.'+name);
991    }
992    composeElement(t, "UsageContext", name, element, index);
993    if (element.hasCode())
994      composeCoding(t, "UsageContext", "code", element.getCode(), -1);
995    if (element.hasValue())
996      composeType(t, "UsageContext", "value", element.getValue(), -1);
997  }
998
999  protected void composeExpression(Complex parent, String parentType, String name, Expression element, int index) {
1000    if (element == null) 
1001      return;
1002    Complex t;
1003    if (Utilities.noString(parentType))
1004      t = parent;
1005    else {
1006      t = parent.predicate("fhir:"+parentType+'.'+name);
1007    }
1008    composeElement(t, "Expression", name, element, index);
1009    if (element.hasDescriptionElement())
1010      composeString(t, "Expression", "description", element.getDescriptionElement(), -1);
1011    if (element.hasNameElement())
1012      composeId(t, "Expression", "name", element.getNameElement(), -1);
1013    if (element.hasLanguageElement())
1014      composeCode(t, "Expression", "language", element.getLanguageElement(), -1);
1015    if (element.hasExpressionElement())
1016      composeString(t, "Expression", "expression", element.getExpressionElement(), -1);
1017    if (element.hasReferenceElement())
1018      composeUri(t, "Expression", "reference", element.getReferenceElement(), -1);
1019  }
1020
1021  protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) {
1022    if (element == null) 
1023      return;
1024    Complex t;
1025    if (Utilities.noString(parentType))
1026      t = parent;
1027    else {
1028      t = parent.predicate("fhir:"+parentType+'.'+name);
1029    }
1030    composeElement(t, "Signature", name, element, index);
1031    for (int i = 0; i < element.getType().size(); i++)
1032      composeCoding(t, "Signature", "type", element.getType().get(i), i);
1033    if (element.hasWhenElement())
1034      composeInstant(t, "Signature", "when", element.getWhenElement(), -1);
1035    if (element.hasWho())
1036      composeReference(t, "Signature", "who", element.getWho(), -1);
1037    if (element.hasOnBehalfOf())
1038      composeReference(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1);
1039    if (element.hasTargetFormatElement())
1040      composeCode(t, "Signature", "targetFormat", element.getTargetFormatElement(), -1);
1041    if (element.hasSigFormatElement())
1042      composeCode(t, "Signature", "sigFormat", element.getSigFormatElement(), -1);
1043    if (element.hasDataElement())
1044      composeBase64Binary(t, "Signature", "data", element.getDataElement(), -1);
1045  }
1046
1047  protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) {
1048    if (element == null) 
1049      return;
1050    Complex t;
1051    if (Utilities.noString(parentType))
1052      t = parent;
1053    else {
1054      t = parent.predicate("fhir:"+parentType+'.'+name);
1055    }
1056    composeElement(t, "Timing", name, element, index);
1057    for (int i = 0; i < element.getEvent().size(); i++)
1058      composeDateTime(t, "Timing", "event", element.getEvent().get(i), i);
1059    if (element.hasRepeat())
1060      composeTimingTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1);
1061    if (element.hasCode())
1062      composeCodeableConcept(t, "Timing", "code", element.getCode(), -1);
1063  }
1064
1065  protected void composeTimingTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) {
1066    if (element == null) 
1067      return;
1068    Complex t;
1069    if (Utilities.noString(parentType))
1070      t = parent;
1071    else {
1072      t = parent.predicate("fhir:"+parentType+'.'+name);
1073    }
1074    composeElement(t, "repeat", name, element, index);
1075    if (element.hasBounds())
1076      composeType(t, "Timing", "bounds", element.getBounds(), -1);
1077    if (element.hasCountElement())
1078      composePositiveInt(t, "Timing", "count", element.getCountElement(), -1);
1079    if (element.hasCountMaxElement())
1080      composePositiveInt(t, "Timing", "countMax", element.getCountMaxElement(), -1);
1081    if (element.hasDurationElement())
1082      composeDecimal(t, "Timing", "duration", element.getDurationElement(), -1);
1083    if (element.hasDurationMaxElement())
1084      composeDecimal(t, "Timing", "durationMax", element.getDurationMaxElement(), -1);
1085    if (element.hasDurationUnitElement())
1086      composeEnum(t, "Timing", "durationUnit", element.getDurationUnitElement(), -1);
1087    if (element.hasFrequencyElement())
1088      composePositiveInt(t, "Timing", "frequency", element.getFrequencyElement(), -1);
1089    if (element.hasFrequencyMaxElement())
1090      composePositiveInt(t, "Timing", "frequencyMax", element.getFrequencyMaxElement(), -1);
1091    if (element.hasPeriodElement())
1092      composeDecimal(t, "Timing", "period", element.getPeriodElement(), -1);
1093    if (element.hasPeriodMaxElement())
1094      composeDecimal(t, "Timing", "periodMax", element.getPeriodMaxElement(), -1);
1095    if (element.hasPeriodUnitElement())
1096      composeEnum(t, "Timing", "periodUnit", element.getPeriodUnitElement(), -1);
1097    for (int i = 0; i < element.getDayOfWeek().size(); i++)
1098      composeEnum(t, "Timing", "dayOfWeek", element.getDayOfWeek().get(i), i);
1099    for (int i = 0; i < element.getTimeOfDay().size(); i++)
1100      composeTime(t, "Timing", "timeOfDay", element.getTimeOfDay().get(i), i);
1101    for (int i = 0; i < element.getWhen().size(); i++)
1102      composeEnum(t, "Timing", "when", element.getWhen().get(i), i);
1103    if (element.hasOffsetElement())
1104      composeUnsignedInt(t, "Timing", "offset", element.getOffsetElement(), -1);
1105  }
1106
1107  protected void composeProdCharacteristic(Complex parent, String parentType, String name, ProdCharacteristic element, int index) {
1108    if (element == null) 
1109      return;
1110    Complex t;
1111    if (Utilities.noString(parentType))
1112      t = parent;
1113    else {
1114      t = parent.predicate("fhir:"+parentType+'.'+name);
1115    }
1116    composeElement(t, "ProdCharacteristic", name, element, index);
1117    if (element.hasHeight())
1118      composeQuantity(t, "ProdCharacteristic", "height", element.getHeight(), -1);
1119    if (element.hasWidth())
1120      composeQuantity(t, "ProdCharacteristic", "width", element.getWidth(), -1);
1121    if (element.hasDepth())
1122      composeQuantity(t, "ProdCharacteristic", "depth", element.getDepth(), -1);
1123    if (element.hasWeight())
1124      composeQuantity(t, "ProdCharacteristic", "weight", element.getWeight(), -1);
1125    if (element.hasNominalVolume())
1126      composeQuantity(t, "ProdCharacteristic", "nominalVolume", element.getNominalVolume(), -1);
1127    if (element.hasExternalDiameter())
1128      composeQuantity(t, "ProdCharacteristic", "externalDiameter", element.getExternalDiameter(), -1);
1129    if (element.hasShapeElement())
1130      composeString(t, "ProdCharacteristic", "shape", element.getShapeElement(), -1);
1131    for (int i = 0; i < element.getColor().size(); i++)
1132      composeString(t, "ProdCharacteristic", "color", element.getColor().get(i), i);
1133    for (int i = 0; i < element.getImprint().size(); i++)
1134      composeString(t, "ProdCharacteristic", "imprint", element.getImprint().get(i), i);
1135    for (int i = 0; i < element.getImage().size(); i++)
1136      composeAttachment(t, "ProdCharacteristic", "image", element.getImage().get(i), i);
1137    if (element.hasScoring())
1138      composeCodeableConcept(t, "ProdCharacteristic", "scoring", element.getScoring(), -1);
1139  }
1140
1141  protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) {
1142    if (element == null) 
1143      return;
1144    Complex t;
1145    if (Utilities.noString(parentType))
1146      t = parent;
1147    else {
1148      t = parent.predicate("fhir:"+parentType+'.'+name);
1149    }
1150    composeElement(t, "CodeableConcept", name, element, index);
1151    decorateCodeableConcept(t, element);
1152    for (int i = 0; i < element.getCoding().size(); i++)
1153      composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i);
1154    if (element.hasTextElement())
1155      composeString(t, "CodeableConcept", "text", element.getTextElement(), -1);
1156  }
1157
1158  protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) {
1159    if (element == null) 
1160      return;
1161    Complex t;
1162    if (Utilities.noString(parentType))
1163      t = parent;
1164    else {
1165      t = parent.predicate("fhir:"+parentType+'.'+name);
1166    }
1167    composeElement(t, "ParameterDefinition", name, element, index);
1168    if (element.hasNameElement())
1169      composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1);
1170    if (element.hasUseElement())
1171      composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1);
1172    if (element.hasMinElement())
1173      composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1);
1174    if (element.hasMaxElement())
1175      composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1);
1176    if (element.hasDocumentationElement())
1177      composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1);
1178    if (element.hasTypeElement())
1179      composeCode(t, "ParameterDefinition", "type", element.getTypeElement(), -1);
1180    if (element.hasProfileElement())
1181      composeCanonical(t, "ParameterDefinition", "profile", element.getProfileElement(), -1);
1182  }
1183
1184  protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) {
1185    if (element == null) 
1186      return;
1187    Complex t;
1188    if (Utilities.noString(parentType))
1189      t = parent;
1190    else {
1191      t = parent.predicate("fhir:"+parentType+'.'+name);
1192    }
1193    composeElement(t, "ElementDefinition", name, element, index);
1194    if (element.hasPathElement())
1195      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
1196    for (int i = 0; i < element.getRepresentation().size(); i++)
1197      composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i);
1198    if (element.hasSliceNameElement())
1199      composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1);
1200    if (element.hasSliceIsConstrainingElement())
1201      composeBoolean(t, "ElementDefinition", "sliceIsConstraining", element.getSliceIsConstrainingElement(), -1);
1202    if (element.hasLabelElement())
1203      composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1);
1204    for (int i = 0; i < element.getCode().size(); i++)
1205      composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i);
1206    if (element.hasSlicing())
1207      composeElementDefinitionElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1);
1208    if (element.hasShortElement())
1209      composeString(t, "ElementDefinition", "short", element.getShortElement(), -1);
1210    if (element.hasDefinitionElement())
1211      composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1);
1212    if (element.hasCommentElement())
1213      composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1);
1214    if (element.hasRequirementsElement())
1215      composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1);
1216    for (int i = 0; i < element.getAlias().size(); i++)
1217      composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i);
1218    if (element.hasMinElement())
1219      composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1);
1220    if (element.hasMaxElement())
1221      composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1);
1222    if (element.hasBase())
1223      composeElementDefinitionElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1);
1224    if (element.hasContentReferenceElement())
1225      composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1);
1226    for (int i = 0; i < element.getType().size(); i++)
1227      composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i);
1228    if (element.hasDefaultValue())
1229      composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1);
1230    if (element.hasMeaningWhenMissingElement())
1231      composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1);
1232    if (element.hasOrderMeaningElement())
1233      composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1);
1234    if (element.hasFixed())
1235      composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1);
1236    if (element.hasPattern())
1237      composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1);
1238    for (int i = 0; i < element.getExample().size(); i++)
1239      composeElementDefinitionElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i);
1240    if (element.hasMinValue())
1241      composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1);
1242    if (element.hasMaxValue())
1243      composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1);
1244    if (element.hasMaxLengthElement())
1245      composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1);
1246    for (int i = 0; i < element.getCondition().size(); i++)
1247      composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i);
1248    for (int i = 0; i < element.getConstraint().size(); i++)
1249      composeElementDefinitionElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i);
1250    if (element.hasMustSupportElement())
1251      composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1);
1252    if (element.hasIsModifierElement())
1253      composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1);
1254    if (element.hasIsModifierReasonElement())
1255      composeString(t, "ElementDefinition", "isModifierReason", element.getIsModifierReasonElement(), -1);
1256    if (element.hasIsSummaryElement())
1257      composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1);
1258    if (element.hasBinding())
1259      composeElementDefinitionElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1);
1260    for (int i = 0; i < element.getMapping().size(); i++)
1261      composeElementDefinitionElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i);
1262  }
1263
1264  protected void composeElementDefinitionElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) {
1265    if (element == null) 
1266      return;
1267    Complex t;
1268    if (Utilities.noString(parentType))
1269      t = parent;
1270    else {
1271      t = parent.predicate("fhir:"+parentType+'.'+name);
1272    }
1273    composeElement(t, "slicing", name, element, index);
1274    for (int i = 0; i < element.getDiscriminator().size(); i++)
1275      composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinition", "discriminator", element.getDiscriminator().get(i), i);
1276    if (element.hasDescriptionElement())
1277      composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1);
1278    if (element.hasOrderedElement())
1279      composeBoolean(t, "ElementDefinition", "ordered", element.getOrderedElement(), -1);
1280    if (element.hasRulesElement())
1281      composeEnum(t, "ElementDefinition", "rules", element.getRulesElement(), -1);
1282  }
1283
1284  protected void composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) {
1285    if (element == null) 
1286      return;
1287    Complex t;
1288    if (Utilities.noString(parentType))
1289      t = parent;
1290    else {
1291      t = parent.predicate("fhir:"+parentType+'.'+name);
1292    }
1293    composeElement(t, "discriminator", name, element, index);
1294    if (element.hasTypeElement())
1295      composeEnum(t, "ElementDefinition", "type", element.getTypeElement(), -1);
1296    if (element.hasPathElement())
1297      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
1298  }
1299
1300  protected void composeElementDefinitionElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) {
1301    if (element == null) 
1302      return;
1303    Complex t;
1304    if (Utilities.noString(parentType))
1305      t = parent;
1306    else {
1307      t = parent.predicate("fhir:"+parentType+'.'+name);
1308    }
1309    composeElement(t, "base", name, element, index);
1310    if (element.hasPathElement())
1311      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
1312    if (element.hasMinElement())
1313      composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1);
1314    if (element.hasMaxElement())
1315      composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1);
1316  }
1317
1318  protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) {
1319    if (element == null) 
1320      return;
1321    Complex t;
1322    if (Utilities.noString(parentType))
1323      t = parent;
1324    else {
1325      t = parent.predicate("fhir:"+parentType+'.'+name);
1326    }
1327    composeElement(t, "type", name, element, index);
1328    if (element.hasCodeElement())
1329      composeUri(t, "ElementDefinition", "code", element.getCodeElement(), -1);
1330    for (int i = 0; i < element.getProfile().size(); i++)
1331      composeCanonical(t, "ElementDefinition", "profile", element.getProfile().get(i), i);
1332    for (int i = 0; i < element.getTargetProfile().size(); i++)
1333      composeCanonical(t, "ElementDefinition", "targetProfile", element.getTargetProfile().get(i), i);
1334    for (int i = 0; i < element.getAggregation().size(); i++)
1335      composeEnum(t, "ElementDefinition", "aggregation", element.getAggregation().get(i), i);
1336    if (element.hasVersioningElement())
1337      composeEnum(t, "ElementDefinition", "versioning", element.getVersioningElement(), -1);
1338  }
1339
1340  protected void composeElementDefinitionElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) {
1341    if (element == null) 
1342      return;
1343    Complex t;
1344    if (Utilities.noString(parentType))
1345      t = parent;
1346    else {
1347      t = parent.predicate("fhir:"+parentType+'.'+name);
1348    }
1349    composeElement(t, "example", name, element, index);
1350    if (element.hasLabelElement())
1351      composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1);
1352    if (element.hasValue())
1353      composeType(t, "ElementDefinition", "value", element.getValue(), -1);
1354  }
1355
1356  protected void composeElementDefinitionElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) {
1357    if (element == null) 
1358      return;
1359    Complex t;
1360    if (Utilities.noString(parentType))
1361      t = parent;
1362    else {
1363      t = parent.predicate("fhir:"+parentType+'.'+name);
1364    }
1365    composeElement(t, "constraint", name, element, index);
1366    if (element.hasKeyElement())
1367      composeId(t, "ElementDefinition", "key", element.getKeyElement(), -1);
1368    if (element.hasRequirementsElement())
1369      composeString(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1);
1370    if (element.hasSeverityElement())
1371      composeEnum(t, "ElementDefinition", "severity", element.getSeverityElement(), -1);
1372    if (element.hasHumanElement())
1373      composeString(t, "ElementDefinition", "human", element.getHumanElement(), -1);
1374    if (element.hasExpressionElement())
1375      composeString(t, "ElementDefinition", "expression", element.getExpressionElement(), -1);
1376    if (element.hasXpathElement())
1377      composeString(t, "ElementDefinition", "xpath", element.getXpathElement(), -1);
1378    if (element.hasSourceElement())
1379      composeCanonical(t, "ElementDefinition", "source", element.getSourceElement(), -1);
1380  }
1381
1382  protected void composeElementDefinitionElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) {
1383    if (element == null) 
1384      return;
1385    Complex t;
1386    if (Utilities.noString(parentType))
1387      t = parent;
1388    else {
1389      t = parent.predicate("fhir:"+parentType+'.'+name);
1390    }
1391    composeElement(t, "binding", name, element, index);
1392    if (element.hasStrengthElement())
1393      composeEnum(t, "ElementDefinition", "strength", element.getStrengthElement(), -1);
1394    if (element.hasDescriptionElement())
1395      composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1);
1396    if (element.hasValueSetElement())
1397      composeCanonical(t, "ElementDefinition", "valueSet", element.getValueSetElement(), -1);
1398  }
1399
1400  protected void composeElementDefinitionElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) {
1401    if (element == null) 
1402      return;
1403    Complex t;
1404    if (Utilities.noString(parentType))
1405      t = parent;
1406    else {
1407      t = parent.predicate("fhir:"+parentType+'.'+name);
1408    }
1409    composeElement(t, "mapping", name, element, index);
1410    if (element.hasIdentityElement())
1411      composeId(t, "ElementDefinition", "identity", element.getIdentityElement(), -1);
1412    if (element.hasLanguageElement())
1413      composeCode(t, "ElementDefinition", "language", element.getLanguageElement(), -1);
1414    if (element.hasMapElement())
1415      composeString(t, "ElementDefinition", "map", element.getMapElement(), -1);
1416    if (element.hasCommentElement())
1417      composeString(t, "ElementDefinition", "comment", element.getCommentElement(), -1);
1418  }
1419
1420  protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) {
1421    composeResource(t, parentType, name, element, index);
1422    if (element.hasText())
1423      composeNarrative(t, "DomainResource", "text", element.getText(), -1);
1424    for (int i = 0; i < element.getContained().size(); i++)
1425      composeResource(t, "DomainResource", "contained", element.getContained().get(i), i);
1426    for (int i = 0; i < element.getExtension().size(); i++)
1427      composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i);
1428    for (int i = 0; i < element.getModifierExtension().size(); i++)
1429      composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i);
1430  }
1431
1432  protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) {
1433    if (element == null) 
1434      return;
1435    Complex t;
1436    if (Utilities.noString(parentType))
1437      t = parent;
1438    else {
1439      t = parent.predicate("fhir:"+parentType+'.'+name);
1440    }
1441    composeResource(t, "Parameters", name, element, index);
1442    for (int i = 0; i < element.getParameter().size(); i++)
1443      composeParametersParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i);
1444  }
1445
1446  protected void composeParametersParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) {
1447    if (element == null) 
1448      return;
1449    Complex t;
1450    if (Utilities.noString(parentType))
1451      t = parent;
1452    else {
1453      t = parent.predicate("fhir:"+parentType+'.'+name);
1454    }
1455    composeBackboneElement(t, "parameter", name, element, index);
1456    if (element.hasNameElement())
1457      composeString(t, "Parameters", "name", element.getNameElement(), -1);
1458    if (element.hasValue())
1459      composeType(t, "Parameters", "value", element.getValue(), -1);
1460    if (element.hasResource())
1461      composeResource(t, "Parameters", "resource", element.getResource(), -1);
1462    for (int i = 0; i < element.getPart().size(); i++)
1463      composeParametersParametersParameterComponent(t, "Parameters", "part", element.getPart().get(i), i);
1464  }
1465
1466  protected void composeResource(Complex t, String parentType, String name, Resource element, int index) {
1467    if (element.hasIdElement())
1468      composeId(t, "Resource", "id", element.getIdElement(), -1);
1469    if (element.hasMeta())
1470      composeMeta(t, "Resource", "meta", element.getMeta(), -1);
1471    if (element.hasImplicitRulesElement())
1472      composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1);
1473    if (element.hasLanguageElement())
1474      composeCode(t, "Resource", "language", element.getLanguageElement(), -1);
1475  }
1476
1477  protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) {
1478    if (element == null) 
1479      return;
1480    Complex t;
1481    if (Utilities.noString(parentType))
1482      t = parent;
1483    else {
1484      t = parent.predicate("fhir:"+parentType+'.'+name);
1485    }
1486    composeDomainResource(t, "Account", name, element, index);
1487    for (int i = 0; i < element.getIdentifier().size(); i++)
1488      composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i);
1489    if (element.hasStatusElement())
1490      composeEnum(t, "Account", "status", element.getStatusElement(), -1);
1491    if (element.hasType())
1492      composeCodeableConcept(t, "Account", "type", element.getType(), -1);
1493    if (element.hasNameElement())
1494      composeString(t, "Account", "name", element.getNameElement(), -1);
1495    for (int i = 0; i < element.getSubject().size(); i++)
1496      composeReference(t, "Account", "subject", element.getSubject().get(i), i);
1497    if (element.hasServicePeriod())
1498      composePeriod(t, "Account", "servicePeriod", element.getServicePeriod(), -1);
1499    for (int i = 0; i < element.getCoverage().size(); i++)
1500      composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i);
1501    if (element.hasOwner())
1502      composeReference(t, "Account", "owner", element.getOwner(), -1);
1503    if (element.hasDescriptionElement())
1504      composeString(t, "Account", "description", element.getDescriptionElement(), -1);
1505    for (int i = 0; i < element.getGuarantor().size(); i++)
1506      composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i);
1507    if (element.hasPartOf())
1508      composeReference(t, "Account", "partOf", element.getPartOf(), -1);
1509  }
1510
1511  protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) {
1512    if (element == null) 
1513      return;
1514    Complex t;
1515    if (Utilities.noString(parentType))
1516      t = parent;
1517    else {
1518      t = parent.predicate("fhir:"+parentType+'.'+name);
1519    }
1520    composeBackboneElement(t, "coverage", name, element, index);
1521    if (element.hasCoverage())
1522      composeReference(t, "Account", "coverage", element.getCoverage(), -1);
1523    if (element.hasPriorityElement())
1524      composePositiveInt(t, "Account", "priority", element.getPriorityElement(), -1);
1525  }
1526
1527  protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) {
1528    if (element == null) 
1529      return;
1530    Complex t;
1531    if (Utilities.noString(parentType))
1532      t = parent;
1533    else {
1534      t = parent.predicate("fhir:"+parentType+'.'+name);
1535    }
1536    composeBackboneElement(t, "guarantor", name, element, index);
1537    if (element.hasParty())
1538      composeReference(t, "Account", "party", element.getParty(), -1);
1539    if (element.hasOnHoldElement())
1540      composeBoolean(t, "Account", "onHold", element.getOnHoldElement(), -1);
1541    if (element.hasPeriod())
1542      composePeriod(t, "Account", "period", element.getPeriod(), -1);
1543  }
1544
1545  protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) {
1546    if (element == null) 
1547      return;
1548    Complex t;
1549    if (Utilities.noString(parentType))
1550      t = parent;
1551    else {
1552      t = parent.predicate("fhir:"+parentType+'.'+name);
1553    }
1554    composeDomainResource(t, "ActivityDefinition", name, element, index);
1555    if (element.hasUrlElement())
1556      composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1);
1557    for (int i = 0; i < element.getIdentifier().size(); i++)
1558      composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i);
1559    if (element.hasVersionElement())
1560      composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1);
1561    if (element.hasNameElement())
1562      composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1);
1563    if (element.hasTitleElement())
1564      composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1);
1565    if (element.hasSubtitleElement())
1566      composeString(t, "ActivityDefinition", "subtitle", element.getSubtitleElement(), -1);
1567    if (element.hasStatusElement())
1568      composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1);
1569    if (element.hasExperimentalElement())
1570      composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1);
1571    if (element.hasSubject())
1572      composeType(t, "ActivityDefinition", "subject", element.getSubject(), -1);
1573    if (element.hasDateElement())
1574      composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1);
1575    if (element.hasPublisherElement())
1576      composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1);
1577    for (int i = 0; i < element.getContact().size(); i++)
1578      composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i);
1579    if (element.hasDescriptionElement())
1580      composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1);
1581    for (int i = 0; i < element.getUseContext().size(); i++)
1582      composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i);
1583    for (int i = 0; i < element.getJurisdiction().size(); i++)
1584      composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
1585    if (element.hasPurposeElement())
1586      composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1);
1587    if (element.hasUsageElement())
1588      composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1);
1589    if (element.hasCopyrightElement())
1590      composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1);
1591    if (element.hasApprovalDateElement())
1592      composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1);
1593    if (element.hasLastReviewDateElement())
1594      composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
1595    if (element.hasEffectivePeriod())
1596      composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
1597    for (int i = 0; i < element.getTopic().size(); i++)
1598      composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i);
1599    for (int i = 0; i < element.getAuthor().size(); i++)
1600      composeContactDetail(t, "ActivityDefinition", "author", element.getAuthor().get(i), i);
1601    for (int i = 0; i < element.getEditor().size(); i++)
1602      composeContactDetail(t, "ActivityDefinition", "editor", element.getEditor().get(i), i);
1603    for (int i = 0; i < element.getReviewer().size(); i++)
1604      composeContactDetail(t, "ActivityDefinition", "reviewer", element.getReviewer().get(i), i);
1605    for (int i = 0; i < element.getEndorser().size(); i++)
1606      composeContactDetail(t, "ActivityDefinition", "endorser", element.getEndorser().get(i), i);
1607    for (int i = 0; i < element.getRelatedArtifact().size(); i++)
1608      composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
1609    for (int i = 0; i < element.getLibrary().size(); i++)
1610      composeCanonical(t, "ActivityDefinition", "library", element.getLibrary().get(i), i);
1611    if (element.hasKindElement())
1612      composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1);
1613    if (element.hasProfileElement())
1614      composeCanonical(t, "ActivityDefinition", "profile", element.getProfileElement(), -1);
1615    if (element.hasCode())
1616      composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1);
1617    if (element.hasIntentElement())
1618      composeEnum(t, "ActivityDefinition", "intent", element.getIntentElement(), -1);
1619    if (element.hasPriorityElement())
1620      composeEnum(t, "ActivityDefinition", "priority", element.getPriorityElement(), -1);
1621    if (element.hasDoNotPerformElement())
1622      composeBoolean(t, "ActivityDefinition", "doNotPerform", element.getDoNotPerformElement(), -1);
1623    if (element.hasTiming())
1624      composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1);
1625    if (element.hasLocation())
1626      composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1);
1627    for (int i = 0; i < element.getParticipant().size(); i++)
1628      composeActivityDefinitionActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i);
1629    if (element.hasProduct())
1630      composeType(t, "ActivityDefinition", "product", element.getProduct(), -1);
1631    if (element.hasQuantity())
1632      composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1);
1633    for (int i = 0; i < element.getDosage().size(); i++)
1634      composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i);
1635    for (int i = 0; i < element.getBodySite().size(); i++)
1636      composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i);
1637    for (int i = 0; i < element.getSpecimenRequirement().size(); i++)
1638      composeReference(t, "ActivityDefinition", "specimenRequirement", element.getSpecimenRequirement().get(i), i);
1639    for (int i = 0; i < element.getObservationRequirement().size(); i++)
1640      composeReference(t, "ActivityDefinition", "observationRequirement", element.getObservationRequirement().get(i), i);
1641    for (int i = 0; i < element.getObservationResultRequirement().size(); i++)
1642      composeReference(t, "ActivityDefinition", "observationResultRequirement", element.getObservationResultRequirement().get(i), i);
1643    if (element.hasTransformElement())
1644      composeCanonical(t, "ActivityDefinition", "transform", element.getTransformElement(), -1);
1645    for (int i = 0; i < element.getDynamicValue().size(); i++)
1646      composeActivityDefinitionActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i);
1647  }
1648
1649  protected void composeActivityDefinitionActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) {
1650    if (element == null) 
1651      return;
1652    Complex t;
1653    if (Utilities.noString(parentType))
1654      t = parent;
1655    else {
1656      t = parent.predicate("fhir:"+parentType+'.'+name);
1657    }
1658    composeBackboneElement(t, "participant", name, element, index);
1659    if (element.hasTypeElement())
1660      composeEnum(t, "ActivityDefinition", "type", element.getTypeElement(), -1);
1661    if (element.hasRole())
1662      composeCodeableConcept(t, "ActivityDefinition", "role", element.getRole(), -1);
1663  }
1664
1665  protected void composeActivityDefinitionActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) {
1666    if (element == null) 
1667      return;
1668    Complex t;
1669    if (Utilities.noString(parentType))
1670      t = parent;
1671    else {
1672      t = parent.predicate("fhir:"+parentType+'.'+name);
1673    }
1674    composeBackboneElement(t, "dynamicValue", name, element, index);
1675    if (element.hasPathElement())
1676      composeString(t, "ActivityDefinition", "path", element.getPathElement(), -1);
1677    if (element.hasExpression())
1678      composeExpression(t, "ActivityDefinition", "expression", element.getExpression(), -1);
1679  }
1680
1681  protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) {
1682    if (element == null) 
1683      return;
1684    Complex t;
1685    if (Utilities.noString(parentType))
1686      t = parent;
1687    else {
1688      t = parent.predicate("fhir:"+parentType+'.'+name);
1689    }
1690    composeDomainResource(t, "AdverseEvent", name, element, index);
1691    if (element.hasIdentifier())
1692      composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier(), -1);
1693    if (element.hasActualityElement())
1694      composeEnum(t, "AdverseEvent", "actuality", element.getActualityElement(), -1);
1695    for (int i = 0; i < element.getCategory().size(); i++)
1696      composeCodeableConcept(t, "AdverseEvent", "category", element.getCategory().get(i), i);
1697    if (element.hasEvent())
1698      composeCodeableConcept(t, "AdverseEvent", "event", element.getEvent(), -1);
1699    if (element.hasSubject())
1700      composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1);
1701    if (element.hasEncounter())
1702      composeReference(t, "AdverseEvent", "encounter", element.getEncounter(), -1);
1703    if (element.hasDateElement())
1704      composeDateTime(t, "AdverseEvent", "date", element.getDateElement(), -1);
1705    if (element.hasDetectedElement())
1706      composeDateTime(t, "AdverseEvent", "detected", element.getDetectedElement(), -1);
1707    if (element.hasRecordedDateElement())
1708      composeDateTime(t, "AdverseEvent", "recordedDate", element.getRecordedDateElement(), -1);
1709    for (int i = 0; i < element.getResultingCondition().size(); i++)
1710      composeReference(t, "AdverseEvent", "resultingCondition", element.getResultingCondition().get(i), i);
1711    if (element.hasLocation())
1712      composeReference(t, "AdverseEvent", "location", element.getLocation(), -1);
1713    if (element.hasSeriousness())
1714      composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1);
1715    if (element.hasSeverity())
1716      composeCodeableConcept(t, "AdverseEvent", "severity", element.getSeverity(), -1);
1717    if (element.hasOutcome())
1718      composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1);
1719    if (element.hasRecorder())
1720      composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1);
1721    for (int i = 0; i < element.getContributor().size(); i++)
1722      composeReference(t, "AdverseEvent", "contributor", element.getContributor().get(i), i);
1723    for (int i = 0; i < element.getSuspectEntity().size(); i++)
1724      composeAdverseEventAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i);
1725    for (int i = 0; i < element.getSubjectMedicalHistory().size(); i++)
1726      composeReference(t, "AdverseEvent", "subjectMedicalHistory", element.getSubjectMedicalHistory().get(i), i);
1727    for (int i = 0; i < element.getReferenceDocument().size(); i++)
1728      composeReference(t, "AdverseEvent", "referenceDocument", element.getReferenceDocument().get(i), i);
1729    for (int i = 0; i < element.getStudy().size(); i++)
1730      composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i);
1731  }
1732
1733  protected void composeAdverseEventAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent 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, "suspectEntity", name, element, index);
1743    if (element.hasInstance())
1744      composeReference(t, "AdverseEvent", "instance", element.getInstance(), -1);
1745    for (int i = 0; i < element.getCausality().size(); i++)
1746      composeAdverseEventAdverseEventSuspectEntityCausalityComponent(t, "AdverseEvent", "causality", element.getCausality().get(i), i);
1747  }
1748
1749  protected void composeAdverseEventAdverseEventSuspectEntityCausalityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityCausalityComponent element, int index) {
1750    if (element == null) 
1751      return;
1752    Complex t;
1753    if (Utilities.noString(parentType))
1754      t = parent;
1755    else {
1756      t = parent.predicate("fhir:"+parentType+'.'+name);
1757    }
1758    composeBackboneElement(t, "causality", name, element, index);
1759    if (element.hasAssessment())
1760      composeCodeableConcept(t, "AdverseEvent", "assessment", element.getAssessment(), -1);
1761    if (element.hasProductRelatednessElement())
1762      composeString(t, "AdverseEvent", "productRelatedness", element.getProductRelatednessElement(), -1);
1763    if (element.hasAuthor())
1764      composeReference(t, "AdverseEvent", "author", element.getAuthor(), -1);
1765    if (element.hasMethod())
1766      composeCodeableConcept(t, "AdverseEvent", "method", element.getMethod(), -1);
1767  }
1768
1769  protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) {
1770    if (element == null) 
1771      return;
1772    Complex t;
1773    if (Utilities.noString(parentType))
1774      t = parent;
1775    else {
1776      t = parent.predicate("fhir:"+parentType+'.'+name);
1777    }
1778    composeDomainResource(t, "AllergyIntolerance", name, element, index);
1779    for (int i = 0; i < element.getIdentifier().size(); i++)
1780      composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i);
1781    if (element.hasClinicalStatus())
1782      composeCodeableConcept(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatus(), -1);
1783    if (element.hasVerificationStatus())
1784      composeCodeableConcept(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatus(), -1);
1785    if (element.hasTypeElement())
1786      composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1);
1787    for (int i = 0; i < element.getCategory().size(); i++)
1788      composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i);
1789    if (element.hasCriticalityElement())
1790      composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1);
1791    if (element.hasCode())
1792      composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1);
1793    if (element.hasPatient())
1794      composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1);
1795    if (element.hasEncounter())
1796      composeReference(t, "AllergyIntolerance", "encounter", element.getEncounter(), -1);
1797    if (element.hasOnset())
1798      composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1);
1799    if (element.hasRecordedDateElement())
1800      composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1);
1801    if (element.hasRecorder())
1802      composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1);
1803    if (element.hasAsserter())
1804      composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1);
1805    if (element.hasLastOccurrenceElement())
1806      composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1);
1807    for (int i = 0; i < element.getNote().size(); i++)
1808      composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i);
1809    for (int i = 0; i < element.getReaction().size(); i++)
1810      composeAllergyIntoleranceAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i);
1811  }
1812
1813  protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) {
1814    if (element == null) 
1815      return;
1816    Complex t;
1817    if (Utilities.noString(parentType))
1818      t = parent;
1819    else {
1820      t = parent.predicate("fhir:"+parentType+'.'+name);
1821    }
1822    composeBackboneElement(t, "reaction", name, element, index);
1823    if (element.hasSubstance())
1824      composeCodeableConcept(t, "AllergyIntolerance", "substance", element.getSubstance(), -1);
1825    for (int i = 0; i < element.getManifestation().size(); i++)
1826      composeCodeableConcept(t, "AllergyIntolerance", "manifestation", element.getManifestation().get(i), i);
1827    if (element.hasDescriptionElement())
1828      composeString(t, "AllergyIntolerance", "description", element.getDescriptionElement(), -1);
1829    if (element.hasOnsetElement())
1830      composeDateTime(t, "AllergyIntolerance", "onset", element.getOnsetElement(), -1);
1831    if (element.hasSeverityElement())
1832      composeEnum(t, "AllergyIntolerance", "severity", element.getSeverityElement(), -1);
1833    if (element.hasExposureRoute())
1834      composeCodeableConcept(t, "AllergyIntolerance", "exposureRoute", element.getExposureRoute(), -1);
1835    for (int i = 0; i < element.getNote().size(); i++)
1836      composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i);
1837  }
1838
1839  protected void composeAppointment(Complex parent, String parentType, String name, Appointment 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, "Appointment", name, element, index);
1849    for (int i = 0; i < element.getIdentifier().size(); i++)
1850      composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i);
1851    if (element.hasStatusElement())
1852      composeEnum(t, "Appointment", "status", element.getStatusElement(), -1);
1853    if (element.hasCancelationReason())
1854      composeCodeableConcept(t, "Appointment", "cancelationReason", element.getCancelationReason(), -1);
1855    for (int i = 0; i < element.getServiceCategory().size(); i++)
1856      composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory().get(i), i);
1857    for (int i = 0; i < element.getServiceType().size(); i++)
1858      composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i);
1859    for (int i = 0; i < element.getSpecialty().size(); i++)
1860      composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i);
1861    if (element.hasAppointmentType())
1862      composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1);
1863    for (int i = 0; i < element.getReasonCode().size(); i++)
1864      composeCodeableConcept(t, "Appointment", "reasonCode", element.getReasonCode().get(i), i);
1865    for (int i = 0; i < element.getReasonReference().size(); i++)
1866      composeReference(t, "Appointment", "reasonReference", element.getReasonReference().get(i), i);
1867    if (element.hasPriorityElement())
1868      composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1);
1869    if (element.hasDescriptionElement())
1870      composeString(t, "Appointment", "description", element.getDescriptionElement(), -1);
1871    for (int i = 0; i < element.getSupportingInformation().size(); i++)
1872      composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i);
1873    if (element.hasStartElement())
1874      composeInstant(t, "Appointment", "start", element.getStartElement(), -1);
1875    if (element.hasEndElement())
1876      composeInstant(t, "Appointment", "end", element.getEndElement(), -1);
1877    if (element.hasMinutesDurationElement())
1878      composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1);
1879    for (int i = 0; i < element.getSlot().size(); i++)
1880      composeReference(t, "Appointment", "slot", element.getSlot().get(i), i);
1881    if (element.hasCreatedElement())
1882      composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1);
1883    if (element.hasCommentElement())
1884      composeString(t, "Appointment", "comment", element.getCommentElement(), -1);
1885    if (element.hasPatientInstructionElement())
1886      composeString(t, "Appointment", "patientInstruction", element.getPatientInstructionElement(), -1);
1887    for (int i = 0; i < element.getBasedOn().size(); i++)
1888      composeReference(t, "Appointment", "basedOn", element.getBasedOn().get(i), i);
1889    for (int i = 0; i < element.getParticipant().size(); i++)
1890      composeAppointmentAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i);
1891    for (int i = 0; i < element.getRequestedPeriod().size(); i++)
1892      composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i);
1893  }
1894
1895  protected void composeAppointmentAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) {
1896    if (element == null) 
1897      return;
1898    Complex t;
1899    if (Utilities.noString(parentType))
1900      t = parent;
1901    else {
1902      t = parent.predicate("fhir:"+parentType+'.'+name);
1903    }
1904    composeBackboneElement(t, "participant", name, element, index);
1905    for (int i = 0; i < element.getType().size(); i++)
1906      composeCodeableConcept(t, "Appointment", "type", element.getType().get(i), i);
1907    if (element.hasActor())
1908      composeReference(t, "Appointment", "actor", element.getActor(), -1);
1909    if (element.hasRequiredElement())
1910      composeEnum(t, "Appointment", "required", element.getRequiredElement(), -1);
1911    if (element.hasStatusElement())
1912      composeEnum(t, "Appointment", "status", element.getStatusElement(), -1);
1913    if (element.hasPeriod())
1914      composePeriod(t, "Appointment", "period", element.getPeriod(), -1);
1915  }
1916
1917  protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) {
1918    if (element == null) 
1919      return;
1920    Complex t;
1921    if (Utilities.noString(parentType))
1922      t = parent;
1923    else {
1924      t = parent.predicate("fhir:"+parentType+'.'+name);
1925    }
1926    composeDomainResource(t, "AppointmentResponse", name, element, index);
1927    for (int i = 0; i < element.getIdentifier().size(); i++)
1928      composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i);
1929    if (element.hasAppointment())
1930      composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1);
1931    if (element.hasStartElement())
1932      composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1);
1933    if (element.hasEndElement())
1934      composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1);
1935    for (int i = 0; i < element.getParticipantType().size(); i++)
1936      composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i);
1937    if (element.hasActor())
1938      composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1);
1939    if (element.hasParticipantStatusElement())
1940      composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1);
1941    if (element.hasCommentElement())
1942      composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1);
1943  }
1944
1945  protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent 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    composeDomainResource(t, "AuditEvent", name, element, index);
1955    if (element.hasType())
1956      composeCoding(t, "AuditEvent", "type", element.getType(), -1);
1957    for (int i = 0; i < element.getSubtype().size(); i++)
1958      composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i);
1959    if (element.hasActionElement())
1960      composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1);
1961    if (element.hasPeriod())
1962      composePeriod(t, "AuditEvent", "period", element.getPeriod(), -1);
1963    if (element.hasRecordedElement())
1964      composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1);
1965    if (element.hasOutcomeElement())
1966      composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1);
1967    if (element.hasOutcomeDescElement())
1968      composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1);
1969    for (int i = 0; i < element.getPurposeOfEvent().size(); i++)
1970      composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i);
1971    for (int i = 0; i < element.getAgent().size(); i++)
1972      composeAuditEventAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i);
1973    if (element.hasSource())
1974      composeAuditEventAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1);
1975    for (int i = 0; i < element.getEntity().size(); i++)
1976      composeAuditEventAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i);
1977  }
1978
1979  protected void composeAuditEventAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) {
1980    if (element == null) 
1981      return;
1982    Complex t;
1983    if (Utilities.noString(parentType))
1984      t = parent;
1985    else {
1986      t = parent.predicate("fhir:"+parentType+'.'+name);
1987    }
1988    composeBackboneElement(t, "agent", name, element, index);
1989    if (element.hasType())
1990      composeCodeableConcept(t, "AuditEvent", "type", element.getType(), -1);
1991    for (int i = 0; i < element.getRole().size(); i++)
1992      composeCodeableConcept(t, "AuditEvent", "role", element.getRole().get(i), i);
1993    if (element.hasWho())
1994      composeReference(t, "AuditEvent", "who", element.getWho(), -1);
1995    if (element.hasAltIdElement())
1996      composeString(t, "AuditEvent", "altId", element.getAltIdElement(), -1);
1997    if (element.hasNameElement())
1998      composeString(t, "AuditEvent", "name", element.getNameElement(), -1);
1999    if (element.hasRequestorElement())
2000      composeBoolean(t, "AuditEvent", "requestor", element.getRequestorElement(), -1);
2001    if (element.hasLocation())
2002      composeReference(t, "AuditEvent", "location", element.getLocation(), -1);
2003    for (int i = 0; i < element.getPolicy().size(); i++)
2004      composeUri(t, "AuditEvent", "policy", element.getPolicy().get(i), i);
2005    if (element.hasMedia())
2006      composeCoding(t, "AuditEvent", "media", element.getMedia(), -1);
2007    if (element.hasNetwork())
2008      composeAuditEventAuditEventAgentNetworkComponent(t, "AuditEvent", "network", element.getNetwork(), -1);
2009    for (int i = 0; i < element.getPurposeOfUse().size(); i++)
2010      composeCodeableConcept(t, "AuditEvent", "purposeOfUse", element.getPurposeOfUse().get(i), i);
2011  }
2012
2013  protected void composeAuditEventAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) {
2014    if (element == null) 
2015      return;
2016    Complex t;
2017    if (Utilities.noString(parentType))
2018      t = parent;
2019    else {
2020      t = parent.predicate("fhir:"+parentType+'.'+name);
2021    }
2022    composeBackboneElement(t, "network", name, element, index);
2023    if (element.hasAddressElement())
2024      composeString(t, "AuditEvent", "address", element.getAddressElement(), -1);
2025    if (element.hasTypeElement())
2026      composeEnum(t, "AuditEvent", "type", element.getTypeElement(), -1);
2027  }
2028
2029  protected void composeAuditEventAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) {
2030    if (element == null) 
2031      return;
2032    Complex t;
2033    if (Utilities.noString(parentType))
2034      t = parent;
2035    else {
2036      t = parent.predicate("fhir:"+parentType+'.'+name);
2037    }
2038    composeBackboneElement(t, "source", name, element, index);
2039    if (element.hasSiteElement())
2040      composeString(t, "AuditEvent", "site", element.getSiteElement(), -1);
2041    if (element.hasObserver())
2042      composeReference(t, "AuditEvent", "observer", element.getObserver(), -1);
2043    for (int i = 0; i < element.getType().size(); i++)
2044      composeCoding(t, "AuditEvent", "type", element.getType().get(i), i);
2045  }
2046
2047  protected void composeAuditEventAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) {
2048    if (element == null) 
2049      return;
2050    Complex t;
2051    if (Utilities.noString(parentType))
2052      t = parent;
2053    else {
2054      t = parent.predicate("fhir:"+parentType+'.'+name);
2055    }
2056    composeBackboneElement(t, "entity", name, element, index);
2057    if (element.hasWhat())
2058      composeReference(t, "AuditEvent", "what", element.getWhat(), -1);
2059    if (element.hasType())
2060      composeCoding(t, "AuditEvent", "type", element.getType(), -1);
2061    if (element.hasRole())
2062      composeCoding(t, "AuditEvent", "role", element.getRole(), -1);
2063    if (element.hasLifecycle())
2064      composeCoding(t, "AuditEvent", "lifecycle", element.getLifecycle(), -1);
2065    for (int i = 0; i < element.getSecurityLabel().size(); i++)
2066      composeCoding(t, "AuditEvent", "securityLabel", element.getSecurityLabel().get(i), i);
2067    if (element.hasNameElement())
2068      composeString(t, "AuditEvent", "name", element.getNameElement(), -1);
2069    if (element.hasDescriptionElement())
2070      composeString(t, "AuditEvent", "description", element.getDescriptionElement(), -1);
2071    if (element.hasQueryElement())
2072      composeBase64Binary(t, "AuditEvent", "query", element.getQueryElement(), -1);
2073    for (int i = 0; i < element.getDetail().size(); i++)
2074      composeAuditEventAuditEventEntityDetailComponent(t, "AuditEvent", "detail", element.getDetail().get(i), i);
2075  }
2076
2077  protected void composeAuditEventAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) {
2078    if (element == null) 
2079      return;
2080    Complex t;
2081    if (Utilities.noString(parentType))
2082      t = parent;
2083    else {
2084      t = parent.predicate("fhir:"+parentType+'.'+name);
2085    }
2086    composeBackboneElement(t, "detail", name, element, index);
2087    if (element.hasTypeElement())
2088      composeString(t, "AuditEvent", "type", element.getTypeElement(), -1);
2089    if (element.hasValue())
2090      composeType(t, "AuditEvent", "value", element.getValue(), -1);
2091  }
2092
2093  protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) {
2094    if (element == null) 
2095      return;
2096    Complex t;
2097    if (Utilities.noString(parentType))
2098      t = parent;
2099    else {
2100      t = parent.predicate("fhir:"+parentType+'.'+name);
2101    }
2102    composeDomainResource(t, "Basic", name, element, index);
2103    for (int i = 0; i < element.getIdentifier().size(); i++)
2104      composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i);
2105    if (element.hasCode())
2106      composeCodeableConcept(t, "Basic", "code", element.getCode(), -1);
2107    if (element.hasSubject())
2108      composeReference(t, "Basic", "subject", element.getSubject(), -1);
2109    if (element.hasCreatedElement())
2110      composeDate(t, "Basic", "created", element.getCreatedElement(), -1);
2111    if (element.hasAuthor())
2112      composeReference(t, "Basic", "author", element.getAuthor(), -1);
2113  }
2114
2115  protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) {
2116    if (element == null) 
2117      return;
2118    Complex t;
2119    if (Utilities.noString(parentType))
2120      t = parent;
2121    else {
2122      t = parent.predicate("fhir:"+parentType+'.'+name);
2123    }
2124    composeResource(t, "Binary", name, element, index);
2125    if (element.hasContentTypeElement())
2126      composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1);
2127    if (element.hasSecurityContext())
2128      composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1);
2129    if (element.hasDataElement())
2130      composeBase64Binary(t, "Binary", "data", element.getDataElement(), -1);
2131  }
2132
2133  protected void composeBiologicallyDerivedProduct(Complex parent, String parentType, String name, BiologicallyDerivedProduct element, int index) {
2134    if (element == null) 
2135      return;
2136    Complex t;
2137    if (Utilities.noString(parentType))
2138      t = parent;
2139    else {
2140      t = parent.predicate("fhir:"+parentType+'.'+name);
2141    }
2142    composeDomainResource(t, "BiologicallyDerivedProduct", name, element, index);
2143    for (int i = 0; i < element.getIdentifier().size(); i++)
2144      composeIdentifier(t, "BiologicallyDerivedProduct", "identifier", element.getIdentifier().get(i), i);
2145    if (element.hasProductCategoryElement())
2146      composeEnum(t, "BiologicallyDerivedProduct", "productCategory", element.getProductCategoryElement(), -1);
2147    if (element.hasProductCode())
2148      composeCodeableConcept(t, "BiologicallyDerivedProduct", "productCode", element.getProductCode(), -1);
2149    if (element.hasStatusElement())
2150      composeEnum(t, "BiologicallyDerivedProduct", "status", element.getStatusElement(), -1);
2151    for (int i = 0; i < element.getRequest().size(); i++)
2152      composeReference(t, "BiologicallyDerivedProduct", "request", element.getRequest().get(i), i);
2153    if (element.hasQuantityElement())
2154      composeInteger(t, "BiologicallyDerivedProduct", "quantity", element.getQuantityElement(), -1);
2155    for (int i = 0; i < element.getParent().size(); i++)
2156      composeReference(t, "BiologicallyDerivedProduct", "parent", element.getParent().get(i), i);
2157    if (element.hasCollection())
2158      composeBiologicallyDerivedProductBiologicallyDerivedProductCollectionComponent(t, "BiologicallyDerivedProduct", "collection", element.getCollection(), -1);
2159    for (int i = 0; i < element.getProcessing().size(); i++)
2160      composeBiologicallyDerivedProductBiologicallyDerivedProductProcessingComponent(t, "BiologicallyDerivedProduct", "processing", element.getProcessing().get(i), i);
2161    if (element.hasManipulation())
2162      composeBiologicallyDerivedProductBiologicallyDerivedProductManipulationComponent(t, "BiologicallyDerivedProduct", "manipulation", element.getManipulation(), -1);
2163    for (int i = 0; i < element.getStorage().size(); i++)
2164      composeBiologicallyDerivedProductBiologicallyDerivedProductStorageComponent(t, "BiologicallyDerivedProduct", "storage", element.getStorage().get(i), i);
2165  }
2166
2167  protected void composeBiologicallyDerivedProductBiologicallyDerivedProductCollectionComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent element, int index) {
2168    if (element == null) 
2169      return;
2170    Complex t;
2171    if (Utilities.noString(parentType))
2172      t = parent;
2173    else {
2174      t = parent.predicate("fhir:"+parentType+'.'+name);
2175    }
2176    composeBackboneElement(t, "collection", name, element, index);
2177    if (element.hasCollector())
2178      composeReference(t, "BiologicallyDerivedProduct", "collector", element.getCollector(), -1);
2179    if (element.hasSource())
2180      composeReference(t, "BiologicallyDerivedProduct", "source", element.getSource(), -1);
2181    if (element.hasCollected())
2182      composeType(t, "BiologicallyDerivedProduct", "collected", element.getCollected(), -1);
2183  }
2184
2185  protected void composeBiologicallyDerivedProductBiologicallyDerivedProductProcessingComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductProcessingComponent element, int index) {
2186    if (element == null) 
2187      return;
2188    Complex t;
2189    if (Utilities.noString(parentType))
2190      t = parent;
2191    else {
2192      t = parent.predicate("fhir:"+parentType+'.'+name);
2193    }
2194    composeBackboneElement(t, "processing", name, element, index);
2195    if (element.hasDescriptionElement())
2196      composeString(t, "BiologicallyDerivedProduct", "description", element.getDescriptionElement(), -1);
2197    if (element.hasProcedure())
2198      composeCodeableConcept(t, "BiologicallyDerivedProduct", "procedure", element.getProcedure(), -1);
2199    if (element.hasAdditive())
2200      composeReference(t, "BiologicallyDerivedProduct", "additive", element.getAdditive(), -1);
2201    if (element.hasTime())
2202      composeType(t, "BiologicallyDerivedProduct", "time", element.getTime(), -1);
2203  }
2204
2205  protected void composeBiologicallyDerivedProductBiologicallyDerivedProductManipulationComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductManipulationComponent element, int index) {
2206    if (element == null) 
2207      return;
2208    Complex t;
2209    if (Utilities.noString(parentType))
2210      t = parent;
2211    else {
2212      t = parent.predicate("fhir:"+parentType+'.'+name);
2213    }
2214    composeBackboneElement(t, "manipulation", name, element, index);
2215    if (element.hasDescriptionElement())
2216      composeString(t, "BiologicallyDerivedProduct", "description", element.getDescriptionElement(), -1);
2217    if (element.hasTime())
2218      composeType(t, "BiologicallyDerivedProduct", "time", element.getTime(), -1);
2219  }
2220
2221  protected void composeBiologicallyDerivedProductBiologicallyDerivedProductStorageComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductStorageComponent element, int index) {
2222    if (element == null) 
2223      return;
2224    Complex t;
2225    if (Utilities.noString(parentType))
2226      t = parent;
2227    else {
2228      t = parent.predicate("fhir:"+parentType+'.'+name);
2229    }
2230    composeBackboneElement(t, "storage", name, element, index);
2231    if (element.hasDescriptionElement())
2232      composeString(t, "BiologicallyDerivedProduct", "description", element.getDescriptionElement(), -1);
2233    if (element.hasTemperatureElement())
2234      composeDecimal(t, "BiologicallyDerivedProduct", "temperature", element.getTemperatureElement(), -1);
2235    if (element.hasScaleElement())
2236      composeEnum(t, "BiologicallyDerivedProduct", "scale", element.getScaleElement(), -1);
2237    if (element.hasDuration())
2238      composePeriod(t, "BiologicallyDerivedProduct", "duration", element.getDuration(), -1);
2239  }
2240
2241  protected void composeBodyStructure(Complex parent, String parentType, String name, BodyStructure element, int index) {
2242    if (element == null) 
2243      return;
2244    Complex t;
2245    if (Utilities.noString(parentType))
2246      t = parent;
2247    else {
2248      t = parent.predicate("fhir:"+parentType+'.'+name);
2249    }
2250    composeDomainResource(t, "BodyStructure", name, element, index);
2251    for (int i = 0; i < element.getIdentifier().size(); i++)
2252      composeIdentifier(t, "BodyStructure", "identifier", element.getIdentifier().get(i), i);
2253    if (element.hasActiveElement())
2254      composeBoolean(t, "BodyStructure", "active", element.getActiveElement(), -1);
2255    if (element.hasMorphology())
2256      composeCodeableConcept(t, "BodyStructure", "morphology", element.getMorphology(), -1);
2257    if (element.hasLocation())
2258      composeCodeableConcept(t, "BodyStructure", "location", element.getLocation(), -1);
2259    for (int i = 0; i < element.getLocationQualifier().size(); i++)
2260      composeCodeableConcept(t, "BodyStructure", "locationQualifier", element.getLocationQualifier().get(i), i);
2261    if (element.hasDescriptionElement())
2262      composeString(t, "BodyStructure", "description", element.getDescriptionElement(), -1);
2263    for (int i = 0; i < element.getImage().size(); i++)
2264      composeAttachment(t, "BodyStructure", "image", element.getImage().get(i), i);
2265    if (element.hasPatient())
2266      composeReference(t, "BodyStructure", "patient", element.getPatient(), -1);
2267  }
2268
2269  protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) {
2270    if (element == null) 
2271      return;
2272    Complex t;
2273    if (Utilities.noString(parentType))
2274      t = parent;
2275    else {
2276      t = parent.predicate("fhir:"+parentType+'.'+name);
2277    }
2278    composeResource(t, "Bundle", name, element, index);
2279    if (element.hasIdentifier())
2280      composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1);
2281    if (element.hasTypeElement())
2282      composeEnum(t, "Bundle", "type", element.getTypeElement(), -1);
2283    if (element.hasTimestampElement())
2284      composeInstant(t, "Bundle", "timestamp", element.getTimestampElement(), -1);
2285    if (element.hasTotalElement())
2286      composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1);
2287    for (int i = 0; i < element.getLink().size(); i++)
2288      composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i);
2289    for (int i = 0; i < element.getEntry().size(); i++)
2290      composeBundleBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i);
2291    if (element.hasSignature())
2292      composeSignature(t, "Bundle", "signature", element.getSignature(), -1);
2293  }
2294
2295  protected void composeBundleBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) {
2296    if (element == null) 
2297      return;
2298    Complex t;
2299    if (Utilities.noString(parentType))
2300      t = parent;
2301    else {
2302      t = parent.predicate("fhir:"+parentType+'.'+name);
2303    }
2304    composeBackboneElement(t, "link", name, element, index);
2305    if (element.hasRelationElement())
2306      composeString(t, "Bundle", "relation", element.getRelationElement(), -1);
2307    if (element.hasUrlElement())
2308      composeUri(t, "Bundle", "url", element.getUrlElement(), -1);
2309  }
2310
2311  protected void composeBundleBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) {
2312    if (element == null) 
2313      return;
2314    Complex t;
2315    if (Utilities.noString(parentType))
2316      t = parent;
2317    else {
2318      t = parent.predicate("fhir:"+parentType+'.'+name);
2319    }
2320    composeBackboneElement(t, "entry", name, element, index);
2321    for (int i = 0; i < element.getLink().size(); i++)
2322      composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i);
2323    if (element.hasFullUrlElement())
2324      composeUri(t, "Bundle", "fullUrl", element.getFullUrlElement(), -1);
2325    if (element.hasResource())
2326      composeResource(t, "Bundle", "resource", element.getResource(), -1);
2327    if (element.hasSearch())
2328      composeBundleBundleEntrySearchComponent(t, "Bundle", "search", element.getSearch(), -1);
2329    if (element.hasRequest())
2330      composeBundleBundleEntryRequestComponent(t, "Bundle", "request", element.getRequest(), -1);
2331    if (element.hasResponse())
2332      composeBundleBundleEntryResponseComponent(t, "Bundle", "response", element.getResponse(), -1);
2333  }
2334
2335  protected void composeBundleBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) {
2336    if (element == null) 
2337      return;
2338    Complex t;
2339    if (Utilities.noString(parentType))
2340      t = parent;
2341    else {
2342      t = parent.predicate("fhir:"+parentType+'.'+name);
2343    }
2344    composeBackboneElement(t, "search", name, element, index);
2345    if (element.hasModeElement())
2346      composeEnum(t, "Bundle", "mode", element.getModeElement(), -1);
2347    if (element.hasScoreElement())
2348      composeDecimal(t, "Bundle", "score", element.getScoreElement(), -1);
2349  }
2350
2351  protected void composeBundleBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) {
2352    if (element == null) 
2353      return;
2354    Complex t;
2355    if (Utilities.noString(parentType))
2356      t = parent;
2357    else {
2358      t = parent.predicate("fhir:"+parentType+'.'+name);
2359    }
2360    composeBackboneElement(t, "request", name, element, index);
2361    if (element.hasMethodElement())
2362      composeEnum(t, "Bundle", "method", element.getMethodElement(), -1);
2363    if (element.hasUrlElement())
2364      composeUri(t, "Bundle", "url", element.getUrlElement(), -1);
2365    if (element.hasIfNoneMatchElement())
2366      composeString(t, "Bundle", "ifNoneMatch", element.getIfNoneMatchElement(), -1);
2367    if (element.hasIfModifiedSinceElement())
2368      composeInstant(t, "Bundle", "ifModifiedSince", element.getIfModifiedSinceElement(), -1);
2369    if (element.hasIfMatchElement())
2370      composeString(t, "Bundle", "ifMatch", element.getIfMatchElement(), -1);
2371    if (element.hasIfNoneExistElement())
2372      composeString(t, "Bundle", "ifNoneExist", element.getIfNoneExistElement(), -1);
2373  }
2374
2375  protected void composeBundleBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) {
2376    if (element == null) 
2377      return;
2378    Complex t;
2379    if (Utilities.noString(parentType))
2380      t = parent;
2381    else {
2382      t = parent.predicate("fhir:"+parentType+'.'+name);
2383    }
2384    composeBackboneElement(t, "response", name, element, index);
2385    if (element.hasStatusElement())
2386      composeString(t, "Bundle", "status", element.getStatusElement(), -1);
2387    if (element.hasLocationElement())
2388      composeUri(t, "Bundle", "location", element.getLocationElement(), -1);
2389    if (element.hasEtagElement())
2390      composeString(t, "Bundle", "etag", element.getEtagElement(), -1);
2391    if (element.hasLastModifiedElement())
2392      composeInstant(t, "Bundle", "lastModified", element.getLastModifiedElement(), -1);
2393    if (element.hasOutcome())
2394      composeResource(t, "Bundle", "outcome", element.getOutcome(), -1);
2395  }
2396
2397  protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) {
2398    if (element == null) 
2399      return;
2400    Complex t;
2401    if (Utilities.noString(parentType))
2402      t = parent;
2403    else {
2404      t = parent.predicate("fhir:"+parentType+'.'+name);
2405    }
2406    composeDomainResource(t, "CapabilityStatement", name, element, index);
2407    if (element.hasUrlElement())
2408      composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1);
2409    if (element.hasVersionElement())
2410      composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1);
2411    if (element.hasNameElement())
2412      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
2413    if (element.hasTitleElement())
2414      composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1);
2415    if (element.hasStatusElement())
2416      composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1);
2417    if (element.hasExperimentalElement())
2418      composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1);
2419    if (element.hasDateElement())
2420      composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1);
2421    if (element.hasPublisherElement())
2422      composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1);
2423    for (int i = 0; i < element.getContact().size(); i++)
2424      composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i);
2425    if (element.hasDescriptionElement())
2426      composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
2427    for (int i = 0; i < element.getUseContext().size(); i++)
2428      composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i);
2429    for (int i = 0; i < element.getJurisdiction().size(); i++)
2430      composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i);
2431    if (element.hasPurposeElement())
2432      composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1);
2433    if (element.hasCopyrightElement())
2434      composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1);
2435    if (element.hasKindElement())
2436      composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1);
2437    for (int i = 0; i < element.getInstantiates().size(); i++)
2438      composeCanonical(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i);
2439    for (int i = 0; i < element.getImports().size(); i++)
2440      composeCanonical(t, "CapabilityStatement", "imports", element.getImports().get(i), i);
2441    if (element.hasSoftware())
2442      composeCapabilityStatementCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1);
2443    if (element.hasImplementation())
2444      composeCapabilityStatementCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1);
2445    if (element.hasFhirVersionElement())
2446      composeEnum(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1);
2447    for (int i = 0; i < element.getFormat().size(); i++)
2448      composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i);
2449    for (int i = 0; i < element.getPatchFormat().size(); i++)
2450      composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i);
2451    for (int i = 0; i < element.getImplementationGuide().size(); i++)
2452      composeCanonical(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i);
2453    for (int i = 0; i < element.getRest().size(); i++)
2454      composeCapabilityStatementCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i);
2455    for (int i = 0; i < element.getMessaging().size(); i++)
2456      composeCapabilityStatementCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i);
2457    for (int i = 0; i < element.getDocument().size(); i++)
2458      composeCapabilityStatementCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i);
2459  }
2460
2461  protected void composeCapabilityStatementCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) {
2462    if (element == null) 
2463      return;
2464    Complex t;
2465    if (Utilities.noString(parentType))
2466      t = parent;
2467    else {
2468      t = parent.predicate("fhir:"+parentType+'.'+name);
2469    }
2470    composeBackboneElement(t, "software", name, element, index);
2471    if (element.hasNameElement())
2472      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
2473    if (element.hasVersionElement())
2474      composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1);
2475    if (element.hasReleaseDateElement())
2476      composeDateTime(t, "CapabilityStatement", "releaseDate", element.getReleaseDateElement(), -1);
2477  }
2478
2479  protected void composeCapabilityStatementCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) {
2480    if (element == null) 
2481      return;
2482    Complex t;
2483    if (Utilities.noString(parentType))
2484      t = parent;
2485    else {
2486      t = parent.predicate("fhir:"+parentType+'.'+name);
2487    }
2488    composeBackboneElement(t, "implementation", name, element, index);
2489    if (element.hasDescriptionElement())
2490      composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
2491    if (element.hasUrlElement())
2492      composeUrl(t, "CapabilityStatement", "url", element.getUrlElement(), -1);
2493    if (element.hasCustodian())
2494      composeReference(t, "CapabilityStatement", "custodian", element.getCustodian(), -1);
2495  }
2496
2497  protected void composeCapabilityStatementCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) {
2498    if (element == null) 
2499      return;
2500    Complex t;
2501    if (Utilities.noString(parentType))
2502      t = parent;
2503    else {
2504      t = parent.predicate("fhir:"+parentType+'.'+name);
2505    }
2506    composeBackboneElement(t, "rest", name, element, index);
2507    if (element.hasModeElement())
2508      composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1);
2509    if (element.hasDocumentationElement())
2510      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2511    if (element.hasSecurity())
2512      composeCapabilityStatementCapabilityStatementRestSecurityComponent(t, "CapabilityStatement", "security", element.getSecurity(), -1);
2513    for (int i = 0; i < element.getResource().size(); i++)
2514      composeCapabilityStatementCapabilityStatementRestResourceComponent(t, "CapabilityStatement", "resource", element.getResource().get(i), i);
2515    for (int i = 0; i < element.getInteraction().size(); i++)
2516      composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i);
2517    for (int i = 0; i < element.getSearchParam().size(); i++)
2518      composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i);
2519    for (int i = 0; i < element.getOperation().size(); i++)
2520      composeCapabilityStatementCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatement", "operation", element.getOperation().get(i), i);
2521    for (int i = 0; i < element.getCompartment().size(); i++)
2522      composeCanonical(t, "CapabilityStatement", "compartment", element.getCompartment().get(i), i);
2523  }
2524
2525  protected void composeCapabilityStatementCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) {
2526    if (element == null) 
2527      return;
2528    Complex t;
2529    if (Utilities.noString(parentType))
2530      t = parent;
2531    else {
2532      t = parent.predicate("fhir:"+parentType+'.'+name);
2533    }
2534    composeBackboneElement(t, "security", name, element, index);
2535    if (element.hasCorsElement())
2536      composeBoolean(t, "CapabilityStatement", "cors", element.getCorsElement(), -1);
2537    for (int i = 0; i < element.getService().size(); i++)
2538      composeCodeableConcept(t, "CapabilityStatement", "service", element.getService().get(i), i);
2539    if (element.hasDescriptionElement())
2540      composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
2541  }
2542
2543  protected void composeCapabilityStatementCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) {
2544    if (element == null) 
2545      return;
2546    Complex t;
2547    if (Utilities.noString(parentType))
2548      t = parent;
2549    else {
2550      t = parent.predicate("fhir:"+parentType+'.'+name);
2551    }
2552    composeBackboneElement(t, "resource", name, element, index);
2553    if (element.hasTypeElement())
2554      composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1);
2555    if (element.hasProfileElement())
2556      composeCanonical(t, "CapabilityStatement", "profile", element.getProfileElement(), -1);
2557    for (int i = 0; i < element.getSupportedProfile().size(); i++)
2558      composeCanonical(t, "CapabilityStatement", "supportedProfile", element.getSupportedProfile().get(i), i);
2559    if (element.hasDocumentationElement())
2560      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2561    for (int i = 0; i < element.getInteraction().size(); i++)
2562      composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i);
2563    if (element.hasVersioningElement())
2564      composeEnum(t, "CapabilityStatement", "versioning", element.getVersioningElement(), -1);
2565    if (element.hasReadHistoryElement())
2566      composeBoolean(t, "CapabilityStatement", "readHistory", element.getReadHistoryElement(), -1);
2567    if (element.hasUpdateCreateElement())
2568      composeBoolean(t, "CapabilityStatement", "updateCreate", element.getUpdateCreateElement(), -1);
2569    if (element.hasConditionalCreateElement())
2570      composeBoolean(t, "CapabilityStatement", "conditionalCreate", element.getConditionalCreateElement(), -1);
2571    if (element.hasConditionalReadElement())
2572      composeEnum(t, "CapabilityStatement", "conditionalRead", element.getConditionalReadElement(), -1);
2573    if (element.hasConditionalUpdateElement())
2574      composeBoolean(t, "CapabilityStatement", "conditionalUpdate", element.getConditionalUpdateElement(), -1);
2575    if (element.hasConditionalDeleteElement())
2576      composeEnum(t, "CapabilityStatement", "conditionalDelete", element.getConditionalDeleteElement(), -1);
2577    for (int i = 0; i < element.getReferencePolicy().size(); i++)
2578      composeEnum(t, "CapabilityStatement", "referencePolicy", element.getReferencePolicy().get(i), i);
2579    for (int i = 0; i < element.getSearchInclude().size(); i++)
2580      composeString(t, "CapabilityStatement", "searchInclude", element.getSearchInclude().get(i), i);
2581    for (int i = 0; i < element.getSearchRevInclude().size(); i++)
2582      composeString(t, "CapabilityStatement", "searchRevInclude", element.getSearchRevInclude().get(i), i);
2583    for (int i = 0; i < element.getSearchParam().size(); i++)
2584      composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i);
2585    for (int i = 0; i < element.getOperation().size(); i++)
2586      composeCapabilityStatementCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatement", "operation", element.getOperation().get(i), i);
2587  }
2588
2589  protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) {
2590    if (element == null) 
2591      return;
2592    Complex t;
2593    if (Utilities.noString(parentType))
2594      t = parent;
2595    else {
2596      t = parent.predicate("fhir:"+parentType+'.'+name);
2597    }
2598    composeBackboneElement(t, "interaction", name, element, index);
2599    if (element.hasCodeElement())
2600      composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1);
2601    if (element.hasDocumentationElement())
2602      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2603  }
2604
2605  protected void composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) {
2606    if (element == null) 
2607      return;
2608    Complex t;
2609    if (Utilities.noString(parentType))
2610      t = parent;
2611    else {
2612      t = parent.predicate("fhir:"+parentType+'.'+name);
2613    }
2614    composeBackboneElement(t, "searchParam", name, element, index);
2615    if (element.hasNameElement())
2616      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
2617    if (element.hasDefinitionElement())
2618      composeCanonical(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1);
2619    if (element.hasTypeElement())
2620      composeEnum(t, "CapabilityStatement", "type", element.getTypeElement(), -1);
2621    if (element.hasDocumentationElement())
2622      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2623  }
2624
2625  protected void composeCapabilityStatementCapabilityStatementRestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceOperationComponent element, int index) {
2626    if (element == null) 
2627      return;
2628    Complex t;
2629    if (Utilities.noString(parentType))
2630      t = parent;
2631    else {
2632      t = parent.predicate("fhir:"+parentType+'.'+name);
2633    }
2634    composeBackboneElement(t, "operation", name, element, index);
2635    if (element.hasNameElement())
2636      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
2637    if (element.hasDefinitionElement())
2638      composeCanonical(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1);
2639    if (element.hasDocumentationElement())
2640      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2641  }
2642
2643  protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) {
2644    if (element == null) 
2645      return;
2646    Complex t;
2647    if (Utilities.noString(parentType))
2648      t = parent;
2649    else {
2650      t = parent.predicate("fhir:"+parentType+'.'+name);
2651    }
2652    composeBackboneElement(t, "interaction", name, element, index);
2653    if (element.hasCodeElement())
2654      composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1);
2655    if (element.hasDocumentationElement())
2656      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2657  }
2658
2659  protected void composeCapabilityStatementCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) {
2660    if (element == null) 
2661      return;
2662    Complex t;
2663    if (Utilities.noString(parentType))
2664      t = parent;
2665    else {
2666      t = parent.predicate("fhir:"+parentType+'.'+name);
2667    }
2668    composeBackboneElement(t, "messaging", name, element, index);
2669    for (int i = 0; i < element.getEndpoint().size(); i++)
2670      composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatement", "endpoint", element.getEndpoint().get(i), i);
2671    if (element.hasReliableCacheElement())
2672      composeUnsignedInt(t, "CapabilityStatement", "reliableCache", element.getReliableCacheElement(), -1);
2673    if (element.hasDocumentationElement())
2674      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2675    for (int i = 0; i < element.getSupportedMessage().size(); i++)
2676      composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatement", "supportedMessage", element.getSupportedMessage().get(i), i);
2677  }
2678
2679  protected void composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) {
2680    if (element == null) 
2681      return;
2682    Complex t;
2683    if (Utilities.noString(parentType))
2684      t = parent;
2685    else {
2686      t = parent.predicate("fhir:"+parentType+'.'+name);
2687    }
2688    composeBackboneElement(t, "endpoint", name, element, index);
2689    if (element.hasProtocol())
2690      composeCoding(t, "CapabilityStatement", "protocol", element.getProtocol(), -1);
2691    if (element.hasAddressElement())
2692      composeUrl(t, "CapabilityStatement", "address", element.getAddressElement(), -1);
2693  }
2694
2695  protected void composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) {
2696    if (element == null) 
2697      return;
2698    Complex t;
2699    if (Utilities.noString(parentType))
2700      t = parent;
2701    else {
2702      t = parent.predicate("fhir:"+parentType+'.'+name);
2703    }
2704    composeBackboneElement(t, "supportedMessage", name, element, index);
2705    if (element.hasModeElement())
2706      composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1);
2707    if (element.hasDefinitionElement())
2708      composeCanonical(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1);
2709  }
2710
2711  protected void composeCapabilityStatementCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) {
2712    if (element == null) 
2713      return;
2714    Complex t;
2715    if (Utilities.noString(parentType))
2716      t = parent;
2717    else {
2718      t = parent.predicate("fhir:"+parentType+'.'+name);
2719    }
2720    composeBackboneElement(t, "document", name, element, index);
2721    if (element.hasModeElement())
2722      composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1);
2723    if (element.hasDocumentationElement())
2724      composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1);
2725    if (element.hasProfileElement())
2726      composeCanonical(t, "CapabilityStatement", "profile", element.getProfileElement(), -1);
2727  }
2728
2729  protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) {
2730    if (element == null) 
2731      return;
2732    Complex t;
2733    if (Utilities.noString(parentType))
2734      t = parent;
2735    else {
2736      t = parent.predicate("fhir:"+parentType+'.'+name);
2737    }
2738    composeDomainResource(t, "CarePlan", name, element, index);
2739    for (int i = 0; i < element.getIdentifier().size(); i++)
2740      composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i);
2741    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++)
2742      composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
2743    for (int i = 0; i < element.getInstantiatesUri().size(); i++)
2744      composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i);
2745    for (int i = 0; i < element.getBasedOn().size(); i++)
2746      composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i);
2747    for (int i = 0; i < element.getReplaces().size(); i++)
2748      composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i);
2749    for (int i = 0; i < element.getPartOf().size(); i++)
2750      composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i);
2751    if (element.hasStatusElement())
2752      composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1);
2753    if (element.hasIntentElement())
2754      composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1);
2755    for (int i = 0; i < element.getCategory().size(); i++)
2756      composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i);
2757    if (element.hasTitleElement())
2758      composeString(t, "CarePlan", "title", element.getTitleElement(), -1);
2759    if (element.hasDescriptionElement())
2760      composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1);
2761    if (element.hasSubject())
2762      composeReference(t, "CarePlan", "subject", element.getSubject(), -1);
2763    if (element.hasEncounter())
2764      composeReference(t, "CarePlan", "encounter", element.getEncounter(), -1);
2765    if (element.hasPeriod())
2766      composePeriod(t, "CarePlan", "period", element.getPeriod(), -1);
2767    if (element.hasCreatedElement())
2768      composeDateTime(t, "CarePlan", "created", element.getCreatedElement(), -1);
2769    if (element.hasAuthor())
2770      composeReference(t, "CarePlan", "author", element.getAuthor(), -1);
2771    for (int i = 0; i < element.getContributor().size(); i++)
2772      composeReference(t, "CarePlan", "contributor", element.getContributor().get(i), i);
2773    for (int i = 0; i < element.getCareTeam().size(); i++)
2774      composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i);
2775    for (int i = 0; i < element.getAddresses().size(); i++)
2776      composeReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i);
2777    for (int i = 0; i < element.getSupportingInfo().size(); i++)
2778      composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i);
2779    for (int i = 0; i < element.getGoal().size(); i++)
2780      composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i);
2781    for (int i = 0; i < element.getActivity().size(); i++)
2782      composeCarePlanCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i);
2783    for (int i = 0; i < element.getNote().size(); i++)
2784      composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i);
2785  }
2786
2787  protected void composeCarePlanCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) {
2788    if (element == null) 
2789      return;
2790    Complex t;
2791    if (Utilities.noString(parentType))
2792      t = parent;
2793    else {
2794      t = parent.predicate("fhir:"+parentType+'.'+name);
2795    }
2796    composeBackboneElement(t, "activity", name, element, index);
2797    for (int i = 0; i < element.getOutcomeCodeableConcept().size(); i++)
2798      composeCodeableConcept(t, "CarePlan", "outcomeCodeableConcept", element.getOutcomeCodeableConcept().get(i), i);
2799    for (int i = 0; i < element.getOutcomeReference().size(); i++)
2800      composeReference(t, "CarePlan", "outcomeReference", element.getOutcomeReference().get(i), i);
2801    for (int i = 0; i < element.getProgress().size(); i++)
2802      composeAnnotation(t, "CarePlan", "progress", element.getProgress().get(i), i);
2803    if (element.hasReference())
2804      composeReference(t, "CarePlan", "reference", element.getReference(), -1);
2805    if (element.hasDetail())
2806      composeCarePlanCarePlanActivityDetailComponent(t, "CarePlan", "detail", element.getDetail(), -1);
2807  }
2808
2809  protected void composeCarePlanCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) {
2810    if (element == null) 
2811      return;
2812    Complex t;
2813    if (Utilities.noString(parentType))
2814      t = parent;
2815    else {
2816      t = parent.predicate("fhir:"+parentType+'.'+name);
2817    }
2818    composeBackboneElement(t, "detail", name, element, index);
2819    if (element.hasKindElement())
2820      composeEnum(t, "CarePlan", "kind", element.getKindElement(), -1);
2821    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++)
2822      composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
2823    for (int i = 0; i < element.getInstantiatesUri().size(); i++)
2824      composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i);
2825    if (element.hasCode())
2826      composeCodeableConcept(t, "CarePlan", "code", element.getCode(), -1);
2827    for (int i = 0; i < element.getReasonCode().size(); i++)
2828      composeCodeableConcept(t, "CarePlan", "reasonCode", element.getReasonCode().get(i), i);
2829    for (int i = 0; i < element.getReasonReference().size(); i++)
2830      composeReference(t, "CarePlan", "reasonReference", element.getReasonReference().get(i), i);
2831    for (int i = 0; i < element.getGoal().size(); i++)
2832      composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i);
2833    if (element.hasStatusElement())
2834      composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1);
2835    if (element.hasStatusReason())
2836      composeCodeableConcept(t, "CarePlan", "statusReason", element.getStatusReason(), -1);
2837    if (element.hasDoNotPerformElement())
2838      composeBoolean(t, "CarePlan", "doNotPerform", element.getDoNotPerformElement(), -1);
2839    if (element.hasScheduled())
2840      composeType(t, "CarePlan", "scheduled", element.getScheduled(), -1);
2841    if (element.hasLocation())
2842      composeReference(t, "CarePlan", "location", element.getLocation(), -1);
2843    for (int i = 0; i < element.getPerformer().size(); i++)
2844      composeReference(t, "CarePlan", "performer", element.getPerformer().get(i), i);
2845    if (element.hasProduct())
2846      composeType(t, "CarePlan", "product", element.getProduct(), -1);
2847    if (element.hasDailyAmount())
2848      composeQuantity(t, "CarePlan", "dailyAmount", element.getDailyAmount(), -1);
2849    if (element.hasQuantity())
2850      composeQuantity(t, "CarePlan", "quantity", element.getQuantity(), -1);
2851    if (element.hasDescriptionElement())
2852      composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1);
2853  }
2854
2855  protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) {
2856    if (element == null) 
2857      return;
2858    Complex t;
2859    if (Utilities.noString(parentType))
2860      t = parent;
2861    else {
2862      t = parent.predicate("fhir:"+parentType+'.'+name);
2863    }
2864    composeDomainResource(t, "CareTeam", name, element, index);
2865    for (int i = 0; i < element.getIdentifier().size(); i++)
2866      composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i);
2867    if (element.hasStatusElement())
2868      composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1);
2869    for (int i = 0; i < element.getCategory().size(); i++)
2870      composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i);
2871    if (element.hasNameElement())
2872      composeString(t, "CareTeam", "name", element.getNameElement(), -1);
2873    if (element.hasSubject())
2874      composeReference(t, "CareTeam", "subject", element.getSubject(), -1);
2875    if (element.hasEncounter())
2876      composeReference(t, "CareTeam", "encounter", element.getEncounter(), -1);
2877    if (element.hasPeriod())
2878      composePeriod(t, "CareTeam", "period", element.getPeriod(), -1);
2879    for (int i = 0; i < element.getParticipant().size(); i++)
2880      composeCareTeamCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i);
2881    for (int i = 0; i < element.getReasonCode().size(); i++)
2882      composeCodeableConcept(t, "CareTeam", "reasonCode", element.getReasonCode().get(i), i);
2883    for (int i = 0; i < element.getReasonReference().size(); i++)
2884      composeReference(t, "CareTeam", "reasonReference", element.getReasonReference().get(i), i);
2885    for (int i = 0; i < element.getManagingOrganization().size(); i++)
2886      composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i);
2887    for (int i = 0; i < element.getTelecom().size(); i++)
2888      composeContactPoint(t, "CareTeam", "telecom", element.getTelecom().get(i), i);
2889    for (int i = 0; i < element.getNote().size(); i++)
2890      composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i);
2891  }
2892
2893  protected void composeCareTeamCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) {
2894    if (element == null) 
2895      return;
2896    Complex t;
2897    if (Utilities.noString(parentType))
2898      t = parent;
2899    else {
2900      t = parent.predicate("fhir:"+parentType+'.'+name);
2901    }
2902    composeBackboneElement(t, "participant", name, element, index);
2903    for (int i = 0; i < element.getRole().size(); i++)
2904      composeCodeableConcept(t, "CareTeam", "role", element.getRole().get(i), i);
2905    if (element.hasMember())
2906      composeReference(t, "CareTeam", "member", element.getMember(), -1);
2907    if (element.hasOnBehalfOf())
2908      composeReference(t, "CareTeam", "onBehalfOf", element.getOnBehalfOf(), -1);
2909    if (element.hasPeriod())
2910      composePeriod(t, "CareTeam", "period", element.getPeriod(), -1);
2911  }
2912
2913  protected void composeCatalogEntry(Complex parent, String parentType, String name, CatalogEntry element, int index) {
2914    if (element == null) 
2915      return;
2916    Complex t;
2917    if (Utilities.noString(parentType))
2918      t = parent;
2919    else {
2920      t = parent.predicate("fhir:"+parentType+'.'+name);
2921    }
2922    composeDomainResource(t, "CatalogEntry", name, element, index);
2923    for (int i = 0; i < element.getIdentifier().size(); i++)
2924      composeIdentifier(t, "CatalogEntry", "identifier", element.getIdentifier().get(i), i);
2925    if (element.hasType())
2926      composeCodeableConcept(t, "CatalogEntry", "type", element.getType(), -1);
2927    if (element.hasOrderableElement())
2928      composeBoolean(t, "CatalogEntry", "orderable", element.getOrderableElement(), -1);
2929    if (element.hasReferencedItem())
2930      composeReference(t, "CatalogEntry", "referencedItem", element.getReferencedItem(), -1);
2931    for (int i = 0; i < element.getAdditionalIdentifier().size(); i++)
2932      composeIdentifier(t, "CatalogEntry", "additionalIdentifier", element.getAdditionalIdentifier().get(i), i);
2933    for (int i = 0; i < element.getClassification().size(); i++)
2934      composeCodeableConcept(t, "CatalogEntry", "classification", element.getClassification().get(i), i);
2935    if (element.hasStatusElement())
2936      composeEnum(t, "CatalogEntry", "status", element.getStatusElement(), -1);
2937    if (element.hasValidityPeriod())
2938      composePeriod(t, "CatalogEntry", "validityPeriod", element.getValidityPeriod(), -1);
2939    if (element.hasValidToElement())
2940      composeDateTime(t, "CatalogEntry", "validTo", element.getValidToElement(), -1);
2941    if (element.hasLastUpdatedElement())
2942      composeDateTime(t, "CatalogEntry", "lastUpdated", element.getLastUpdatedElement(), -1);
2943    for (int i = 0; i < element.getAdditionalCharacteristic().size(); i++)
2944      composeCodeableConcept(t, "CatalogEntry", "additionalCharacteristic", element.getAdditionalCharacteristic().get(i), i);
2945    for (int i = 0; i < element.getAdditionalClassification().size(); i++)
2946      composeCodeableConcept(t, "CatalogEntry", "additionalClassification", element.getAdditionalClassification().get(i), i);
2947    for (int i = 0; i < element.getRelatedEntry().size(); i++)
2948      composeCatalogEntryCatalogEntryRelatedEntryComponent(t, "CatalogEntry", "relatedEntry", element.getRelatedEntry().get(i), i);
2949  }
2950
2951  protected void composeCatalogEntryCatalogEntryRelatedEntryComponent(Complex parent, String parentType, String name, CatalogEntry.CatalogEntryRelatedEntryComponent element, int index) {
2952    if (element == null) 
2953      return;
2954    Complex t;
2955    if (Utilities.noString(parentType))
2956      t = parent;
2957    else {
2958      t = parent.predicate("fhir:"+parentType+'.'+name);
2959    }
2960    composeBackboneElement(t, "relatedEntry", name, element, index);
2961    if (element.hasRelationtypeElement())
2962      composeEnum(t, "CatalogEntry", "relationtype", element.getRelationtypeElement(), -1);
2963    if (element.hasItem())
2964      composeReference(t, "CatalogEntry", "item", element.getItem(), -1);
2965  }
2966
2967  protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) {
2968    if (element == null) 
2969      return;
2970    Complex t;
2971    if (Utilities.noString(parentType))
2972      t = parent;
2973    else {
2974      t = parent.predicate("fhir:"+parentType+'.'+name);
2975    }
2976    composeDomainResource(t, "ChargeItem", name, element, index);
2977    for (int i = 0; i < element.getIdentifier().size(); i++)
2978      composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier().get(i), i);
2979    for (int i = 0; i < element.getDefinitionUri().size(); i++)
2980      composeUri(t, "ChargeItem", "definitionUri", element.getDefinitionUri().get(i), i);
2981    for (int i = 0; i < element.getDefinitionCanonical().size(); i++)
2982      composeCanonical(t, "ChargeItem", "definitionCanonical", element.getDefinitionCanonical().get(i), i);
2983    if (element.hasStatusElement())
2984      composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1);
2985    for (int i = 0; i < element.getPartOf().size(); i++)
2986      composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i);
2987    if (element.hasCode())
2988      composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1);
2989    if (element.hasSubject())
2990      composeReference(t, "ChargeItem", "subject", element.getSubject(), -1);
2991    if (element.hasContext())
2992      composeReference(t, "ChargeItem", "context", element.getContext(), -1);
2993    if (element.hasOccurrence())
2994      composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1);
2995    for (int i = 0; i < element.getPerformer().size(); i++)
2996      composeChargeItemChargeItemPerformerComponent(t, "ChargeItem", "performer", element.getPerformer().get(i), i);
2997    if (element.hasPerformingOrganization())
2998      composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1);
2999    if (element.hasRequestingOrganization())
3000      composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1);
3001    if (element.hasCostCenter())
3002      composeReference(t, "ChargeItem", "costCenter", element.getCostCenter(), -1);
3003    if (element.hasQuantity())
3004      composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1);
3005    for (int i = 0; i < element.getBodysite().size(); i++)
3006      composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i);
3007    if (element.hasFactorOverrideElement())
3008      composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1);
3009    if (element.hasPriceOverride())
3010      composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1);
3011    if (element.hasOverrideReasonElement())
3012      composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1);
3013    if (element.hasEnterer())
3014      composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1);
3015    if (element.hasEnteredDateElement())
3016      composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1);
3017    for (int i = 0; i < element.getReason().size(); i++)
3018      composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i);
3019    for (int i = 0; i < element.getService().size(); i++)
3020      composeReference(t, "ChargeItem", "service", element.getService().get(i), i);
3021    if (element.hasProduct())
3022      composeType(t, "ChargeItem", "product", element.getProduct(), -1);
3023    for (int i = 0; i < element.getAccount().size(); i++)
3024      composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i);
3025    for (int i = 0; i < element.getNote().size(); i++)
3026      composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i);
3027    for (int i = 0; i < element.getSupportingInformation().size(); i++)
3028      composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i);
3029  }
3030
3031  protected void composeChargeItemChargeItemPerformerComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemPerformerComponent element, int index) {
3032    if (element == null) 
3033      return;
3034    Complex t;
3035    if (Utilities.noString(parentType))
3036      t = parent;
3037    else {
3038      t = parent.predicate("fhir:"+parentType+'.'+name);
3039    }
3040    composeBackboneElement(t, "performer", name, element, index);
3041    if (element.hasFunction())
3042      composeCodeableConcept(t, "ChargeItem", "function", element.getFunction(), -1);
3043    if (element.hasActor())
3044      composeReference(t, "ChargeItem", "actor", element.getActor(), -1);
3045  }
3046
3047  protected void composeChargeItemDefinition(Complex parent, String parentType, String name, ChargeItemDefinition 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    composeDomainResource(t, "ChargeItemDefinition", name, element, index);
3057    if (element.hasUrlElement())
3058      composeUri(t, "ChargeItemDefinition", "url", element.getUrlElement(), -1);
3059    for (int i = 0; i < element.getIdentifier().size(); i++)
3060      composeIdentifier(t, "ChargeItemDefinition", "identifier", element.getIdentifier().get(i), i);
3061    if (element.hasVersionElement())
3062      composeString(t, "ChargeItemDefinition", "version", element.getVersionElement(), -1);
3063    if (element.hasTitleElement())
3064      composeString(t, "ChargeItemDefinition", "title", element.getTitleElement(), -1);
3065    for (int i = 0; i < element.getDerivedFromUri().size(); i++)
3066      composeUri(t, "ChargeItemDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
3067    for (int i = 0; i < element.getPartOf().size(); i++)
3068      composeCanonical(t, "ChargeItemDefinition", "partOf", element.getPartOf().get(i), i);
3069    for (int i = 0; i < element.getReplaces().size(); i++)
3070      composeCanonical(t, "ChargeItemDefinition", "replaces", element.getReplaces().get(i), i);
3071    if (element.hasStatusElement())
3072      composeEnum(t, "ChargeItemDefinition", "status", element.getStatusElement(), -1);
3073    if (element.hasExperimentalElement())
3074      composeBoolean(t, "ChargeItemDefinition", "experimental", element.getExperimentalElement(), -1);
3075    if (element.hasDateElement())
3076      composeDateTime(t, "ChargeItemDefinition", "date", element.getDateElement(), -1);
3077    if (element.hasPublisherElement())
3078      composeString(t, "ChargeItemDefinition", "publisher", element.getPublisherElement(), -1);
3079    for (int i = 0; i < element.getContact().size(); i++)
3080      composeContactDetail(t, "ChargeItemDefinition", "contact", element.getContact().get(i), i);
3081    if (element.hasDescriptionElement())
3082      composeMarkdown(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1);
3083    for (int i = 0; i < element.getUseContext().size(); i++)
3084      composeUsageContext(t, "ChargeItemDefinition", "useContext", element.getUseContext().get(i), i);
3085    for (int i = 0; i < element.getJurisdiction().size(); i++)
3086      composeCodeableConcept(t, "ChargeItemDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
3087    if (element.hasCopyrightElement())
3088      composeMarkdown(t, "ChargeItemDefinition", "copyright", element.getCopyrightElement(), -1);
3089    if (element.hasApprovalDateElement())
3090      composeDate(t, "ChargeItemDefinition", "approvalDate", element.getApprovalDateElement(), -1);
3091    if (element.hasLastReviewDateElement())
3092      composeDate(t, "ChargeItemDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
3093    if (element.hasEffectivePeriod())
3094      composePeriod(t, "ChargeItemDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
3095    if (element.hasCode())
3096      composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1);
3097    for (int i = 0; i < element.getInstance().size(); i++)
3098      composeReference(t, "ChargeItemDefinition", "instance", element.getInstance().get(i), i);
3099    for (int i = 0; i < element.getApplicability().size(); i++)
3100      composeChargeItemDefinitionChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i);
3101    for (int i = 0; i < element.getPropertyGroup().size(); i++)
3102      composeChargeItemDefinitionChargeItemDefinitionPropertyGroupComponent(t, "ChargeItemDefinition", "propertyGroup", element.getPropertyGroup().get(i), i);
3103  }
3104
3105  protected void composeChargeItemDefinitionChargeItemDefinitionApplicabilityComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent 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, "applicability", name, element, index);
3115    if (element.hasDescriptionElement())
3116      composeString(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1);
3117    if (element.hasLanguageElement())
3118      composeString(t, "ChargeItemDefinition", "language", element.getLanguageElement(), -1);
3119    if (element.hasExpressionElement())
3120      composeString(t, "ChargeItemDefinition", "expression", element.getExpressionElement(), -1);
3121  }
3122
3123  protected void composeChargeItemDefinitionChargeItemDefinitionPropertyGroupComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent element, int index) {
3124    if (element == null) 
3125      return;
3126    Complex t;
3127    if (Utilities.noString(parentType))
3128      t = parent;
3129    else {
3130      t = parent.predicate("fhir:"+parentType+'.'+name);
3131    }
3132    composeBackboneElement(t, "propertyGroup", name, element, index);
3133    for (int i = 0; i < element.getApplicability().size(); i++)
3134      composeChargeItemDefinitionChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i);
3135    for (int i = 0; i < element.getPriceComponent().size(); i++)
3136      composeChargeItemDefinitionChargeItemDefinitionPropertyGroupPriceComponentComponent(t, "ChargeItemDefinition", "priceComponent", element.getPriceComponent().get(i), i);
3137  }
3138
3139  protected void composeChargeItemDefinitionChargeItemDefinitionPropertyGroupPriceComponentComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupPriceComponentComponent element, int index) {
3140    if (element == null) 
3141      return;
3142    Complex t;
3143    if (Utilities.noString(parentType))
3144      t = parent;
3145    else {
3146      t = parent.predicate("fhir:"+parentType+'.'+name);
3147    }
3148    composeBackboneElement(t, "priceComponent", name, element, index);
3149    if (element.hasTypeElement())
3150      composeEnum(t, "ChargeItemDefinition", "type", element.getTypeElement(), -1);
3151    if (element.hasCode())
3152      composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1);
3153    if (element.hasFactorElement())
3154      composeDecimal(t, "ChargeItemDefinition", "factor", element.getFactorElement(), -1);
3155    if (element.hasAmount())
3156      composeMoney(t, "ChargeItemDefinition", "amount", element.getAmount(), -1);
3157  }
3158
3159  protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) {
3160    if (element == null) 
3161      return;
3162    Complex t;
3163    if (Utilities.noString(parentType))
3164      t = parent;
3165    else {
3166      t = parent.predicate("fhir:"+parentType+'.'+name);
3167    }
3168    composeDomainResource(t, "Claim", name, element, index);
3169    for (int i = 0; i < element.getIdentifier().size(); i++)
3170      composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i);
3171    if (element.hasStatusElement())
3172      composeEnum(t, "Claim", "status", element.getStatusElement(), -1);
3173    if (element.hasType())
3174      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
3175    if (element.hasSubType())
3176      composeCodeableConcept(t, "Claim", "subType", element.getSubType(), -1);
3177    if (element.hasUseElement())
3178      composeEnum(t, "Claim", "use", element.getUseElement(), -1);
3179    if (element.hasPatient())
3180      composeReference(t, "Claim", "patient", element.getPatient(), -1);
3181    if (element.hasBillablePeriod())
3182      composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1);
3183    if (element.hasCreatedElement())
3184      composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1);
3185    if (element.hasEnterer())
3186      composeReference(t, "Claim", "enterer", element.getEnterer(), -1);
3187    if (element.hasInsurer())
3188      composeReference(t, "Claim", "insurer", element.getInsurer(), -1);
3189    if (element.hasProvider())
3190      composeReference(t, "Claim", "provider", element.getProvider(), -1);
3191    if (element.hasPriority())
3192      composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1);
3193    if (element.hasFundsReserve())
3194      composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1);
3195    for (int i = 0; i < element.getRelated().size(); i++)
3196      composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i);
3197    if (element.hasPrescription())
3198      composeReference(t, "Claim", "prescription", element.getPrescription(), -1);
3199    if (element.hasOriginalPrescription())
3200      composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1);
3201    if (element.hasPayee())
3202      composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1);
3203    if (element.hasReferral())
3204      composeReference(t, "Claim", "referral", element.getReferral(), -1);
3205    if (element.hasFacility())
3206      composeReference(t, "Claim", "facility", element.getFacility(), -1);
3207    for (int i = 0; i < element.getCareTeam().size(); i++)
3208      composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i);
3209    for (int i = 0; i < element.getSupportingInfo().size(); i++)
3210      composeClaimSupportingInformationComponent(t, "Claim", "supportingInfo", element.getSupportingInfo().get(i), i);
3211    for (int i = 0; i < element.getDiagnosis().size(); i++)
3212      composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i);
3213    for (int i = 0; i < element.getProcedure().size(); i++)
3214      composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i);
3215    for (int i = 0; i < element.getInsurance().size(); i++)
3216      composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i);
3217    if (element.hasAccident())
3218      composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1);
3219    for (int i = 0; i < element.getItem().size(); i++)
3220      composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i);
3221    if (element.hasTotal())
3222      composeMoney(t, "Claim", "total", element.getTotal(), -1);
3223  }
3224
3225  protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent 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, "related", name, element, index);
3235    if (element.hasClaim())
3236      composeReference(t, "Claim", "claim", element.getClaim(), -1);
3237    if (element.hasRelationship())
3238      composeCodeableConcept(t, "Claim", "relationship", element.getRelationship(), -1);
3239    if (element.hasReference())
3240      composeIdentifier(t, "Claim", "reference", element.getReference(), -1);
3241  }
3242
3243  protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) {
3244    if (element == null) 
3245      return;
3246    Complex t;
3247    if (Utilities.noString(parentType))
3248      t = parent;
3249    else {
3250      t = parent.predicate("fhir:"+parentType+'.'+name);
3251    }
3252    composeBackboneElement(t, "payee", name, element, index);
3253    if (element.hasType())
3254      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
3255    if (element.hasParty())
3256      composeReference(t, "Claim", "party", element.getParty(), -1);
3257  }
3258
3259  protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) {
3260    if (element == null) 
3261      return;
3262    Complex t;
3263    if (Utilities.noString(parentType))
3264      t = parent;
3265    else {
3266      t = parent.predicate("fhir:"+parentType+'.'+name);
3267    }
3268    composeBackboneElement(t, "careTeam", name, element, index);
3269    if (element.hasSequenceElement())
3270      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
3271    if (element.hasProvider())
3272      composeReference(t, "Claim", "provider", element.getProvider(), -1);
3273    if (element.hasResponsibleElement())
3274      composeBoolean(t, "Claim", "responsible", element.getResponsibleElement(), -1);
3275    if (element.hasRole())
3276      composeCodeableConcept(t, "Claim", "role", element.getRole(), -1);
3277    if (element.hasQualification())
3278      composeCodeableConcept(t, "Claim", "qualification", element.getQualification(), -1);
3279  }
3280
3281  protected void composeClaimSupportingInformationComponent(Complex parent, String parentType, String name, Claim.SupportingInformationComponent element, int index) {
3282    if (element == null) 
3283      return;
3284    Complex t;
3285    if (Utilities.noString(parentType))
3286      t = parent;
3287    else {
3288      t = parent.predicate("fhir:"+parentType+'.'+name);
3289    }
3290    composeBackboneElement(t, "supportingInfo", name, element, index);
3291    if (element.hasSequenceElement())
3292      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
3293    if (element.hasCategory())
3294      composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1);
3295    if (element.hasCode())
3296      composeCodeableConcept(t, "Claim", "code", element.getCode(), -1);
3297    if (element.hasTiming())
3298      composeType(t, "Claim", "timing", element.getTiming(), -1);
3299    if (element.hasValue())
3300      composeType(t, "Claim", "value", element.getValue(), -1);
3301    if (element.hasReason())
3302      composeCodeableConcept(t, "Claim", "reason", element.getReason(), -1);
3303  }
3304
3305  protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) {
3306    if (element == null) 
3307      return;
3308    Complex t;
3309    if (Utilities.noString(parentType))
3310      t = parent;
3311    else {
3312      t = parent.predicate("fhir:"+parentType+'.'+name);
3313    }
3314    composeBackboneElement(t, "diagnosis", name, element, index);
3315    if (element.hasSequenceElement())
3316      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
3317    if (element.hasDiagnosis())
3318      composeType(t, "Claim", "diagnosis", element.getDiagnosis(), -1);
3319    for (int i = 0; i < element.getType().size(); i++)
3320      composeCodeableConcept(t, "Claim", "type", element.getType().get(i), i);
3321    if (element.hasOnAdmission())
3322      composeCodeableConcept(t, "Claim", "onAdmission", element.getOnAdmission(), -1);
3323    if (element.hasPackageCode())
3324      composeCodeableConcept(t, "Claim", "packageCode", element.getPackageCode(), -1);
3325  }
3326
3327  protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) {
3328    if (element == null) 
3329      return;
3330    Complex t;
3331    if (Utilities.noString(parentType))
3332      t = parent;
3333    else {
3334      t = parent.predicate("fhir:"+parentType+'.'+name);
3335    }
3336    composeBackboneElement(t, "procedure", name, element, index);
3337    if (element.hasSequenceElement())
3338      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
3339    for (int i = 0; i < element.getType().size(); i++)
3340      composeCodeableConcept(t, "Claim", "type", element.getType().get(i), i);
3341    if (element.hasDateElement())
3342      composeDateTime(t, "Claim", "date", element.getDateElement(), -1);
3343    if (element.hasProcedure())
3344      composeType(t, "Claim", "procedure", element.getProcedure(), -1);
3345    for (int i = 0; i < element.getUdi().size(); i++)
3346      composeReference(t, "Claim", "udi", element.getUdi().get(i), i);
3347  }
3348
3349  protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) {
3350    if (element == null) 
3351      return;
3352    Complex t;
3353    if (Utilities.noString(parentType))
3354      t = parent;
3355    else {
3356      t = parent.predicate("fhir:"+parentType+'.'+name);
3357    }
3358    composeBackboneElement(t, "insurance", name, element, index);
3359    if (element.hasSequenceElement())
3360      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
3361    if (element.hasFocalElement())
3362      composeBoolean(t, "Claim", "focal", element.getFocalElement(), -1);
3363    if (element.hasIdentifier())
3364      composeIdentifier(t, "Claim", "identifier", element.getIdentifier(), -1);
3365    if (element.hasCoverage())
3366      composeReference(t, "Claim", "coverage", element.getCoverage(), -1);
3367    if (element.hasBusinessArrangementElement())
3368      composeString(t, "Claim", "businessArrangement", element.getBusinessArrangementElement(), -1);
3369    for (int i = 0; i < element.getPreAuthRef().size(); i++)
3370      composeString(t, "Claim", "preAuthRef", element.getPreAuthRef().get(i), i);
3371    if (element.hasClaimResponse())
3372      composeReference(t, "Claim", "claimResponse", element.getClaimResponse(), -1);
3373  }
3374
3375  protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) {
3376    if (element == null) 
3377      return;
3378    Complex t;
3379    if (Utilities.noString(parentType))
3380      t = parent;
3381    else {
3382      t = parent.predicate("fhir:"+parentType+'.'+name);
3383    }
3384    composeBackboneElement(t, "accident", name, element, index);
3385    if (element.hasDateElement())
3386      composeDate(t, "Claim", "date", element.getDateElement(), -1);
3387    if (element.hasType())
3388      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
3389    if (element.hasLocation())
3390      composeType(t, "Claim", "location", element.getLocation(), -1);
3391  }
3392
3393  protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent 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, "item", name, element, index);
3403    if (element.hasSequenceElement())
3404      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
3405    for (int i = 0; i < element.getCareTeamSequence().size(); i++)
3406      composePositiveInt(t, "Claim", "careTeamSequence", element.getCareTeamSequence().get(i), i);
3407    for (int i = 0; i < element.getDiagnosisSequence().size(); i++)
3408      composePositiveInt(t, "Claim", "diagnosisSequence", element.getDiagnosisSequence().get(i), i);
3409    for (int i = 0; i < element.getProcedureSequence().size(); i++)
3410      composePositiveInt(t, "Claim", "procedureSequence", element.getProcedureSequence().get(i), i);
3411    for (int i = 0; i < element.getInformationSequence().size(); i++)
3412      composePositiveInt(t, "Claim", "informationSequence", element.getInformationSequence().get(i), i);
3413    if (element.hasRevenue())
3414      composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1);
3415    if (element.hasCategory())
3416      composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1);
3417    if (element.hasProductOrService())
3418      composeCodeableConcept(t, "Claim", "productOrService", element.getProductOrService(), -1);
3419    for (int i = 0; i < element.getModifier().size(); i++)
3420      composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i);
3421    for (int i = 0; i < element.getProgramCode().size(); i++)
3422      composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i);
3423    if (element.hasServiced())
3424      composeType(t, "Claim", "serviced", element.getServiced(), -1);
3425    if (element.hasLocation())
3426      composeType(t, "Claim", "location", element.getLocation(), -1);
3427    if (element.hasQuantity())
3428      composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1);
3429    if (element.hasUnitPrice())
3430      composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1);
3431    if (element.hasFactorElement())
3432      composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1);
3433    if (element.hasNet())
3434      composeMoney(t, "Claim", "net", element.getNet(), -1);
3435    for (int i = 0; i < element.getUdi().size(); i++)
3436      composeReference(t, "Claim", "udi", element.getUdi().get(i), i);
3437    if (element.hasBodySite())
3438      composeCodeableConcept(t, "Claim", "bodySite", element.getBodySite(), -1);
3439    for (int i = 0; i < element.getSubSite().size(); i++)
3440      composeCodeableConcept(t, "Claim", "subSite", element.getSubSite().get(i), i);
3441    for (int i = 0; i < element.getEncounter().size(); i++)
3442      composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i);
3443    for (int i = 0; i < element.getDetail().size(); i++)
3444      composeClaimDetailComponent(t, "Claim", "detail", element.getDetail().get(i), i);
3445  }
3446
3447  protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) {
3448    if (element == null) 
3449      return;
3450    Complex t;
3451    if (Utilities.noString(parentType))
3452      t = parent;
3453    else {
3454      t = parent.predicate("fhir:"+parentType+'.'+name);
3455    }
3456    composeBackboneElement(t, "detail", name, element, index);
3457    if (element.hasSequenceElement())
3458      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
3459    if (element.hasRevenue())
3460      composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1);
3461    if (element.hasCategory())
3462      composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1);
3463    if (element.hasProductOrService())
3464      composeCodeableConcept(t, "Claim", "productOrService", element.getProductOrService(), -1);
3465    for (int i = 0; i < element.getModifier().size(); i++)
3466      composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i);
3467    for (int i = 0; i < element.getProgramCode().size(); i++)
3468      composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i);
3469    if (element.hasQuantity())
3470      composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1);
3471    if (element.hasUnitPrice())
3472      composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1);
3473    if (element.hasFactorElement())
3474      composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1);
3475    if (element.hasNet())
3476      composeMoney(t, "Claim", "net", element.getNet(), -1);
3477    for (int i = 0; i < element.getUdi().size(); i++)
3478      composeReference(t, "Claim", "udi", element.getUdi().get(i), i);
3479    for (int i = 0; i < element.getSubDetail().size(); i++)
3480      composeClaimSubDetailComponent(t, "Claim", "subDetail", element.getSubDetail().get(i), i);
3481  }
3482
3483  protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) {
3484    if (element == null) 
3485      return;
3486    Complex t;
3487    if (Utilities.noString(parentType))
3488      t = parent;
3489    else {
3490      t = parent.predicate("fhir:"+parentType+'.'+name);
3491    }
3492    composeBackboneElement(t, "subDetail", name, element, index);
3493    if (element.hasSequenceElement())
3494      composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1);
3495    if (element.hasRevenue())
3496      composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1);
3497    if (element.hasCategory())
3498      composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1);
3499    if (element.hasProductOrService())
3500      composeCodeableConcept(t, "Claim", "productOrService", element.getProductOrService(), -1);
3501    for (int i = 0; i < element.getModifier().size(); i++)
3502      composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i);
3503    for (int i = 0; i < element.getProgramCode().size(); i++)
3504      composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i);
3505    if (element.hasQuantity())
3506      composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1);
3507    if (element.hasUnitPrice())
3508      composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1);
3509    if (element.hasFactorElement())
3510      composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1);
3511    if (element.hasNet())
3512      composeMoney(t, "Claim", "net", element.getNet(), -1);
3513    for (int i = 0; i < element.getUdi().size(); i++)
3514      composeReference(t, "Claim", "udi", element.getUdi().get(i), i);
3515  }
3516
3517  protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) {
3518    if (element == null) 
3519      return;
3520    Complex t;
3521    if (Utilities.noString(parentType))
3522      t = parent;
3523    else {
3524      t = parent.predicate("fhir:"+parentType+'.'+name);
3525    }
3526    composeDomainResource(t, "ClaimResponse", name, element, index);
3527    for (int i = 0; i < element.getIdentifier().size(); i++)
3528      composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i);
3529    if (element.hasStatusElement())
3530      composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1);
3531    if (element.hasType())
3532      composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1);
3533    if (element.hasSubType())
3534      composeCodeableConcept(t, "ClaimResponse", "subType", element.getSubType(), -1);
3535    if (element.hasUseElement())
3536      composeEnum(t, "ClaimResponse", "use", element.getUseElement(), -1);
3537    if (element.hasPatient())
3538      composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1);
3539    if (element.hasCreatedElement())
3540      composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1);
3541    if (element.hasInsurer())
3542      composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1);
3543    if (element.hasRequestor())
3544      composeReference(t, "ClaimResponse", "requestor", element.getRequestor(), -1);
3545    if (element.hasRequest())
3546      composeReference(t, "ClaimResponse", "request", element.getRequest(), -1);
3547    if (element.hasOutcomeElement())
3548      composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1);
3549    if (element.hasDispositionElement())
3550      composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1);
3551    if (element.hasPreAuthRefElement())
3552      composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
3553    if (element.hasPreAuthPeriod())
3554      composePeriod(t, "ClaimResponse", "preAuthPeriod", element.getPreAuthPeriod(), -1);
3555    if (element.hasPayeeType())
3556      composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1);
3557    for (int i = 0; i < element.getItem().size(); i++)
3558      composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i);
3559    for (int i = 0; i < element.getAddItem().size(); i++)
3560      composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i);
3561    for (int i = 0; i < element.getAdjudication().size(); i++)
3562      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3563    for (int i = 0; i < element.getTotal().size(); i++)
3564      composeClaimResponseTotalComponent(t, "ClaimResponse", "total", element.getTotal().get(i), i);
3565    if (element.hasPayment())
3566      composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1);
3567    if (element.hasFundsReserve())
3568      composeCodeableConcept(t, "ClaimResponse", "fundsReserve", element.getFundsReserve(), -1);
3569    if (element.hasFormCode())
3570      composeCodeableConcept(t, "ClaimResponse", "formCode", element.getFormCode(), -1);
3571    if (element.hasForm())
3572      composeAttachment(t, "ClaimResponse", "form", element.getForm(), -1);
3573    for (int i = 0; i < element.getProcessNote().size(); i++)
3574      composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i);
3575    for (int i = 0; i < element.getCommunicationRequest().size(); i++)
3576      composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i);
3577    for (int i = 0; i < element.getInsurance().size(); i++)
3578      composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i);
3579    for (int i = 0; i < element.getError().size(); i++)
3580      composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i);
3581  }
3582
3583  protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) {
3584    if (element == null) 
3585      return;
3586    Complex t;
3587    if (Utilities.noString(parentType))
3588      t = parent;
3589    else {
3590      t = parent.predicate("fhir:"+parentType+'.'+name);
3591    }
3592    composeBackboneElement(t, "item", name, element, index);
3593    if (element.hasItemSequenceElement())
3594      composePositiveInt(t, "ClaimResponse", "itemSequence", element.getItemSequenceElement(), -1);
3595    for (int i = 0; i < element.getNoteNumber().size(); i++)
3596      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3597    for (int i = 0; i < element.getAdjudication().size(); i++)
3598      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3599    for (int i = 0; i < element.getDetail().size(); i++)
3600      composeClaimResponseItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i);
3601  }
3602
3603  protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) {
3604    if (element == null) 
3605      return;
3606    Complex t;
3607    if (Utilities.noString(parentType))
3608      t = parent;
3609    else {
3610      t = parent.predicate("fhir:"+parentType+'.'+name);
3611    }
3612    composeBackboneElement(t, "adjudication", name, element, index);
3613    if (element.hasCategory())
3614      composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1);
3615    if (element.hasReason())
3616      composeCodeableConcept(t, "ClaimResponse", "reason", element.getReason(), -1);
3617    if (element.hasAmount())
3618      composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1);
3619    if (element.hasValueElement())
3620      composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1);
3621  }
3622
3623  protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent 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, "detail", name, element, index);
3633    if (element.hasDetailSequenceElement())
3634      composePositiveInt(t, "ClaimResponse", "detailSequence", element.getDetailSequenceElement(), -1);
3635    for (int i = 0; i < element.getNoteNumber().size(); i++)
3636      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3637    for (int i = 0; i < element.getAdjudication().size(); i++)
3638      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3639    for (int i = 0; i < element.getSubDetail().size(); i++)
3640      composeClaimResponseSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i);
3641  }
3642
3643  protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) {
3644    if (element == null) 
3645      return;
3646    Complex t;
3647    if (Utilities.noString(parentType))
3648      t = parent;
3649    else {
3650      t = parent.predicate("fhir:"+parentType+'.'+name);
3651    }
3652    composeBackboneElement(t, "subDetail", name, element, index);
3653    if (element.hasSubDetailSequenceElement())
3654      composePositiveInt(t, "ClaimResponse", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
3655    for (int i = 0; i < element.getNoteNumber().size(); i++)
3656      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3657    for (int i = 0; i < element.getAdjudication().size(); i++)
3658      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3659  }
3660
3661  protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) {
3662    if (element == null) 
3663      return;
3664    Complex t;
3665    if (Utilities.noString(parentType))
3666      t = parent;
3667    else {
3668      t = parent.predicate("fhir:"+parentType+'.'+name);
3669    }
3670    composeBackboneElement(t, "addItem", name, element, index);
3671    for (int i = 0; i < element.getItemSequence().size(); i++)
3672      composePositiveInt(t, "ClaimResponse", "itemSequence", element.getItemSequence().get(i), i);
3673    for (int i = 0; i < element.getDetailSequence().size(); i++)
3674      composePositiveInt(t, "ClaimResponse", "detailSequence", element.getDetailSequence().get(i), i);
3675    for (int i = 0; i < element.getSubdetailSequence().size(); i++)
3676      composePositiveInt(t, "ClaimResponse", "subdetailSequence", element.getSubdetailSequence().get(i), i);
3677    for (int i = 0; i < element.getProvider().size(); i++)
3678      composeReference(t, "ClaimResponse", "provider", element.getProvider().get(i), i);
3679    if (element.hasProductOrService())
3680      composeCodeableConcept(t, "ClaimResponse", "productOrService", element.getProductOrService(), -1);
3681    for (int i = 0; i < element.getModifier().size(); i++)
3682      composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i);
3683    for (int i = 0; i < element.getProgramCode().size(); i++)
3684      composeCodeableConcept(t, "ClaimResponse", "programCode", element.getProgramCode().get(i), i);
3685    if (element.hasServiced())
3686      composeType(t, "ClaimResponse", "serviced", element.getServiced(), -1);
3687    if (element.hasLocation())
3688      composeType(t, "ClaimResponse", "location", element.getLocation(), -1);
3689    if (element.hasQuantity())
3690      composeQuantity(t, "ClaimResponse", "quantity", element.getQuantity(), -1);
3691    if (element.hasUnitPrice())
3692      composeMoney(t, "ClaimResponse", "unitPrice", element.getUnitPrice(), -1);
3693    if (element.hasFactorElement())
3694      composeDecimal(t, "ClaimResponse", "factor", element.getFactorElement(), -1);
3695    if (element.hasNet())
3696      composeMoney(t, "ClaimResponse", "net", element.getNet(), -1);
3697    if (element.hasBodySite())
3698      composeCodeableConcept(t, "ClaimResponse", "bodySite", element.getBodySite(), -1);
3699    for (int i = 0; i < element.getSubSite().size(); i++)
3700      composeCodeableConcept(t, "ClaimResponse", "subSite", element.getSubSite().get(i), i);
3701    for (int i = 0; i < element.getNoteNumber().size(); i++)
3702      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3703    for (int i = 0; i < element.getAdjudication().size(); i++)
3704      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3705    for (int i = 0; i < element.getDetail().size(); i++)
3706      composeClaimResponseAddedItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i);
3707  }
3708
3709  protected void composeClaimResponseAddedItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailComponent element, int index) {
3710    if (element == null) 
3711      return;
3712    Complex t;
3713    if (Utilities.noString(parentType))
3714      t = parent;
3715    else {
3716      t = parent.predicate("fhir:"+parentType+'.'+name);
3717    }
3718    composeBackboneElement(t, "detail", name, element, index);
3719    if (element.hasProductOrService())
3720      composeCodeableConcept(t, "ClaimResponse", "productOrService", element.getProductOrService(), -1);
3721    for (int i = 0; i < element.getModifier().size(); i++)
3722      composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i);
3723    if (element.hasQuantity())
3724      composeQuantity(t, "ClaimResponse", "quantity", element.getQuantity(), -1);
3725    if (element.hasUnitPrice())
3726      composeMoney(t, "ClaimResponse", "unitPrice", element.getUnitPrice(), -1);
3727    if (element.hasFactorElement())
3728      composeDecimal(t, "ClaimResponse", "factor", element.getFactorElement(), -1);
3729    if (element.hasNet())
3730      composeMoney(t, "ClaimResponse", "net", element.getNet(), -1);
3731    for (int i = 0; i < element.getNoteNumber().size(); i++)
3732      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3733    for (int i = 0; i < element.getAdjudication().size(); i++)
3734      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3735    for (int i = 0; i < element.getSubDetail().size(); i++)
3736      composeClaimResponseAddedItemSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i);
3737  }
3738
3739  protected void composeClaimResponseAddedItemSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemSubDetailComponent element, int index) {
3740    if (element == null) 
3741      return;
3742    Complex t;
3743    if (Utilities.noString(parentType))
3744      t = parent;
3745    else {
3746      t = parent.predicate("fhir:"+parentType+'.'+name);
3747    }
3748    composeBackboneElement(t, "subDetail", name, element, index);
3749    if (element.hasProductOrService())
3750      composeCodeableConcept(t, "ClaimResponse", "productOrService", element.getProductOrService(), -1);
3751    for (int i = 0; i < element.getModifier().size(); i++)
3752      composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i);
3753    if (element.hasQuantity())
3754      composeQuantity(t, "ClaimResponse", "quantity", element.getQuantity(), -1);
3755    if (element.hasUnitPrice())
3756      composeMoney(t, "ClaimResponse", "unitPrice", element.getUnitPrice(), -1);
3757    if (element.hasFactorElement())
3758      composeDecimal(t, "ClaimResponse", "factor", element.getFactorElement(), -1);
3759    if (element.hasNet())
3760      composeMoney(t, "ClaimResponse", "net", element.getNet(), -1);
3761    for (int i = 0; i < element.getNoteNumber().size(); i++)
3762      composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i);
3763    for (int i = 0; i < element.getAdjudication().size(); i++)
3764      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
3765  }
3766
3767  protected void composeClaimResponseTotalComponent(Complex parent, String parentType, String name, ClaimResponse.TotalComponent element, int index) {
3768    if (element == null) 
3769      return;
3770    Complex t;
3771    if (Utilities.noString(parentType))
3772      t = parent;
3773    else {
3774      t = parent.predicate("fhir:"+parentType+'.'+name);
3775    }
3776    composeBackboneElement(t, "total", name, element, index);
3777    if (element.hasCategory())
3778      composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1);
3779    if (element.hasAmount())
3780      composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1);
3781  }
3782
3783  protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) {
3784    if (element == null) 
3785      return;
3786    Complex t;
3787    if (Utilities.noString(parentType))
3788      t = parent;
3789    else {
3790      t = parent.predicate("fhir:"+parentType+'.'+name);
3791    }
3792    composeBackboneElement(t, "payment", name, element, index);
3793    if (element.hasType())
3794      composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1);
3795    if (element.hasAdjustment())
3796      composeMoney(t, "ClaimResponse", "adjustment", element.getAdjustment(), -1);
3797    if (element.hasAdjustmentReason())
3798      composeCodeableConcept(t, "ClaimResponse", "adjustmentReason", element.getAdjustmentReason(), -1);
3799    if (element.hasDateElement())
3800      composeDate(t, "ClaimResponse", "date", element.getDateElement(), -1);
3801    if (element.hasAmount())
3802      composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1);
3803    if (element.hasIdentifier())
3804      composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier(), -1);
3805  }
3806
3807  protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) {
3808    if (element == null) 
3809      return;
3810    Complex t;
3811    if (Utilities.noString(parentType))
3812      t = parent;
3813    else {
3814      t = parent.predicate("fhir:"+parentType+'.'+name);
3815    }
3816    composeBackboneElement(t, "processNote", name, element, index);
3817    if (element.hasNumberElement())
3818      composePositiveInt(t, "ClaimResponse", "number", element.getNumberElement(), -1);
3819    if (element.hasTypeElement())
3820      composeEnum(t, "ClaimResponse", "type", element.getTypeElement(), -1);
3821    if (element.hasTextElement())
3822      composeString(t, "ClaimResponse", "text", element.getTextElement(), -1);
3823    if (element.hasLanguage())
3824      composeCodeableConcept(t, "ClaimResponse", "language", element.getLanguage(), -1);
3825  }
3826
3827  protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) {
3828    if (element == null) 
3829      return;
3830    Complex t;
3831    if (Utilities.noString(parentType))
3832      t = parent;
3833    else {
3834      t = parent.predicate("fhir:"+parentType+'.'+name);
3835    }
3836    composeBackboneElement(t, "insurance", name, element, index);
3837    if (element.hasSequenceElement())
3838      composePositiveInt(t, "ClaimResponse", "sequence", element.getSequenceElement(), -1);
3839    if (element.hasFocalElement())
3840      composeBoolean(t, "ClaimResponse", "focal", element.getFocalElement(), -1);
3841    if (element.hasCoverage())
3842      composeReference(t, "ClaimResponse", "coverage", element.getCoverage(), -1);
3843    if (element.hasBusinessArrangementElement())
3844      composeString(t, "ClaimResponse", "businessArrangement", element.getBusinessArrangementElement(), -1);
3845    if (element.hasClaimResponse())
3846      composeReference(t, "ClaimResponse", "claimResponse", element.getClaimResponse(), -1);
3847  }
3848
3849  protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) {
3850    if (element == null) 
3851      return;
3852    Complex t;
3853    if (Utilities.noString(parentType))
3854      t = parent;
3855    else {
3856      t = parent.predicate("fhir:"+parentType+'.'+name);
3857    }
3858    composeBackboneElement(t, "error", name, element, index);
3859    if (element.hasItemSequenceElement())
3860      composePositiveInt(t, "ClaimResponse", "itemSequence", element.getItemSequenceElement(), -1);
3861    if (element.hasDetailSequenceElement())
3862      composePositiveInt(t, "ClaimResponse", "detailSequence", element.getDetailSequenceElement(), -1);
3863    if (element.hasSubDetailSequenceElement())
3864      composePositiveInt(t, "ClaimResponse", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
3865    if (element.hasCode())
3866      composeCodeableConcept(t, "ClaimResponse", "code", element.getCode(), -1);
3867  }
3868
3869  protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression 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    composeDomainResource(t, "ClinicalImpression", name, element, index);
3879    for (int i = 0; i < element.getIdentifier().size(); i++)
3880      composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i);
3881    if (element.hasStatusElement())
3882      composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1);
3883    if (element.hasStatusReason())
3884      composeCodeableConcept(t, "ClinicalImpression", "statusReason", element.getStatusReason(), -1);
3885    if (element.hasCode())
3886      composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1);
3887    if (element.hasDescriptionElement())
3888      composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1);
3889    if (element.hasSubject())
3890      composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1);
3891    if (element.hasEncounter())
3892      composeReference(t, "ClinicalImpression", "encounter", element.getEncounter(), -1);
3893    if (element.hasEffective())
3894      composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1);
3895    if (element.hasDateElement())
3896      composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1);
3897    if (element.hasAssessor())
3898      composeReference(t, "ClinicalImpression", "assessor", element.getAssessor(), -1);
3899    if (element.hasPrevious())
3900      composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1);
3901    for (int i = 0; i < element.getProblem().size(); i++)
3902      composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i);
3903    for (int i = 0; i < element.getInvestigation().size(); i++)
3904      composeClinicalImpressionClinicalImpressionInvestigationComponent(t, "ClinicalImpression", "investigation", element.getInvestigation().get(i), i);
3905    for (int i = 0; i < element.getProtocol().size(); i++)
3906      composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i);
3907    if (element.hasSummaryElement())
3908      composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1);
3909    for (int i = 0; i < element.getFinding().size(); i++)
3910      composeClinicalImpressionClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i);
3911    for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++)
3912      composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i);
3913    for (int i = 0; i < element.getPrognosisReference().size(); i++)
3914      composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i);
3915    for (int i = 0; i < element.getSupportingInfo().size(); i++)
3916      composeReference(t, "ClinicalImpression", "supportingInfo", element.getSupportingInfo().get(i), i);
3917    for (int i = 0; i < element.getNote().size(); i++)
3918      composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i);
3919  }
3920
3921  protected void composeClinicalImpressionClinicalImpressionInvestigationComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionInvestigationComponent element, int index) {
3922    if (element == null) 
3923      return;
3924    Complex t;
3925    if (Utilities.noString(parentType))
3926      t = parent;
3927    else {
3928      t = parent.predicate("fhir:"+parentType+'.'+name);
3929    }
3930    composeBackboneElement(t, "investigation", name, element, index);
3931    if (element.hasCode())
3932      composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1);
3933    for (int i = 0; i < element.getItem().size(); i++)
3934      composeReference(t, "ClinicalImpression", "item", element.getItem().get(i), i);
3935  }
3936
3937  protected void composeClinicalImpressionClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) {
3938    if (element == null) 
3939      return;
3940    Complex t;
3941    if (Utilities.noString(parentType))
3942      t = parent;
3943    else {
3944      t = parent.predicate("fhir:"+parentType+'.'+name);
3945    }
3946    composeBackboneElement(t, "finding", name, element, index);
3947    if (element.hasItemCodeableConcept())
3948      composeCodeableConcept(t, "ClinicalImpression", "itemCodeableConcept", element.getItemCodeableConcept(), -1);
3949    if (element.hasItemReference())
3950      composeReference(t, "ClinicalImpression", "itemReference", element.getItemReference(), -1);
3951    if (element.hasBasisElement())
3952      composeString(t, "ClinicalImpression", "basis", element.getBasisElement(), -1);
3953  }
3954
3955  protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem 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    composeDomainResource(t, "CodeSystem", name, element, index);
3965    if (element.hasUrlElement())
3966      composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1);
3967    for (int i = 0; i < element.getIdentifier().size(); i++)
3968      composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier().get(i), i);
3969    if (element.hasVersionElement())
3970      composeString(t, "CodeSystem", "version", element.getVersionElement(), -1);
3971    if (element.hasNameElement())
3972      composeString(t, "CodeSystem", "name", element.getNameElement(), -1);
3973    if (element.hasTitleElement())
3974      composeString(t, "CodeSystem", "title", element.getTitleElement(), -1);
3975    if (element.hasStatusElement())
3976      composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1);
3977    if (element.hasExperimentalElement())
3978      composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1);
3979    if (element.hasDateElement())
3980      composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1);
3981    if (element.hasPublisherElement())
3982      composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1);
3983    for (int i = 0; i < element.getContact().size(); i++)
3984      composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i);
3985    if (element.hasDescriptionElement())
3986      composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
3987    for (int i = 0; i < element.getUseContext().size(); i++)
3988      composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i);
3989    for (int i = 0; i < element.getJurisdiction().size(); i++)
3990      composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i);
3991    if (element.hasPurposeElement())
3992      composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1);
3993    if (element.hasCopyrightElement())
3994      composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1);
3995    if (element.hasCaseSensitiveElement())
3996      composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1);
3997    if (element.hasValueSetElement())
3998      composeCanonical(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1);
3999    if (element.hasHierarchyMeaningElement())
4000      composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1);
4001    if (element.hasCompositionalElement())
4002      composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1);
4003    if (element.hasVersionNeededElement())
4004      composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1);
4005    if (element.hasContentElement())
4006      composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1);
4007    if (element.hasSupplementsElement())
4008      composeCanonical(t, "CodeSystem", "supplements", element.getSupplementsElement(), -1);
4009    if (element.hasCountElement())
4010      composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1);
4011    for (int i = 0; i < element.getFilter().size(); i++)
4012      composeCodeSystemCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i);
4013    for (int i = 0; i < element.getProperty().size(); i++)
4014      composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i);
4015    for (int i = 0; i < element.getConcept().size(); i++)
4016      composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i);
4017  }
4018
4019  protected void composeCodeSystemCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent 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, "filter", name, element, index);
4029    if (element.hasCodeElement())
4030      composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1);
4031    if (element.hasDescriptionElement())
4032      composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
4033    for (int i = 0; i < element.getOperator().size(); i++)
4034      composeEnum(t, "CodeSystem", "operator", element.getOperator().get(i), i);
4035    if (element.hasValueElement())
4036      composeString(t, "CodeSystem", "value", element.getValueElement(), -1);
4037  }
4038
4039  protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) {
4040    if (element == null) 
4041      return;
4042    Complex t;
4043    if (Utilities.noString(parentType))
4044      t = parent;
4045    else {
4046      t = parent.predicate("fhir:"+parentType+'.'+name);
4047    }
4048    composeBackboneElement(t, "property", name, element, index);
4049    if (element.hasCodeElement())
4050      composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1);
4051    if (element.hasUriElement())
4052      composeUri(t, "CodeSystem", "uri", element.getUriElement(), -1);
4053    if (element.hasDescriptionElement())
4054      composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
4055    if (element.hasTypeElement())
4056      composeEnum(t, "CodeSystem", "type", element.getTypeElement(), -1);
4057  }
4058
4059  protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) {
4060    if (element == null) 
4061      return;
4062    Complex t;
4063    if (Utilities.noString(parentType))
4064      t = parent;
4065    else {
4066      t = parent.predicate("fhir:"+parentType+'.'+name);
4067    }
4068    composeBackboneElement(t, "concept", name, element, index);
4069    if (element.hasCodeElement())
4070      composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1);
4071    if (element.hasDisplayElement())
4072      composeString(t, "CodeSystem", "display", element.getDisplayElement(), -1);
4073    if (element.hasDefinitionElement())
4074      composeString(t, "CodeSystem", "definition", element.getDefinitionElement(), -1);
4075    for (int i = 0; i < element.getDesignation().size(); i++)
4076      composeCodeSystemConceptDefinitionDesignationComponent(t, "CodeSystem", "designation", element.getDesignation().get(i), i);
4077    for (int i = 0; i < element.getProperty().size(); i++)
4078      composeCodeSystemConceptPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i);
4079    for (int i = 0; i < element.getConcept().size(); i++)
4080      composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i);
4081  }
4082
4083  protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) {
4084    if (element == null) 
4085      return;
4086    Complex t;
4087    if (Utilities.noString(parentType))
4088      t = parent;
4089    else {
4090      t = parent.predicate("fhir:"+parentType+'.'+name);
4091    }
4092    composeBackboneElement(t, "designation", name, element, index);
4093    if (element.hasLanguageElement())
4094      composeCode(t, "CodeSystem", "language", element.getLanguageElement(), -1);
4095    if (element.hasUse())
4096      composeCoding(t, "CodeSystem", "use", element.getUse(), -1);
4097    if (element.hasValueElement())
4098      composeString(t, "CodeSystem", "value", element.getValueElement(), -1);
4099  }
4100
4101  protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) {
4102    if (element == null) 
4103      return;
4104    Complex t;
4105    if (Utilities.noString(parentType))
4106      t = parent;
4107    else {
4108      t = parent.predicate("fhir:"+parentType+'.'+name);
4109    }
4110    composeBackboneElement(t, "property", name, element, index);
4111    if (element.hasCodeElement())
4112      composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1);
4113    if (element.hasValue())
4114      composeType(t, "CodeSystem", "value", element.getValue(), -1);
4115  }
4116
4117  protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) {
4118    if (element == null) 
4119      return;
4120    Complex t;
4121    if (Utilities.noString(parentType))
4122      t = parent;
4123    else {
4124      t = parent.predicate("fhir:"+parentType+'.'+name);
4125    }
4126    composeDomainResource(t, "Communication", name, element, index);
4127    for (int i = 0; i < element.getIdentifier().size(); i++)
4128      composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i);
4129    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++)
4130      composeCanonical(t, "Communication", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
4131    for (int i = 0; i < element.getInstantiatesUri().size(); i++)
4132      composeUri(t, "Communication", "instantiatesUri", element.getInstantiatesUri().get(i), i);
4133    for (int i = 0; i < element.getBasedOn().size(); i++)
4134      composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i);
4135    for (int i = 0; i < element.getPartOf().size(); i++)
4136      composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i);
4137    for (int i = 0; i < element.getInResponseTo().size(); i++)
4138      composeReference(t, "Communication", "inResponseTo", element.getInResponseTo().get(i), i);
4139    if (element.hasStatusElement())
4140      composeEnum(t, "Communication", "status", element.getStatusElement(), -1);
4141    if (element.hasStatusReason())
4142      composeCodeableConcept(t, "Communication", "statusReason", element.getStatusReason(), -1);
4143    for (int i = 0; i < element.getCategory().size(); i++)
4144      composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i);
4145    if (element.hasPriorityElement())
4146      composeEnum(t, "Communication", "priority", element.getPriorityElement(), -1);
4147    for (int i = 0; i < element.getMedium().size(); i++)
4148      composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i);
4149    if (element.hasSubject())
4150      composeReference(t, "Communication", "subject", element.getSubject(), -1);
4151    if (element.hasTopic())
4152      composeCodeableConcept(t, "Communication", "topic", element.getTopic(), -1);
4153    for (int i = 0; i < element.getAbout().size(); i++)
4154      composeReference(t, "Communication", "about", element.getAbout().get(i), i);
4155    if (element.hasEncounter())
4156      composeReference(t, "Communication", "encounter", element.getEncounter(), -1);
4157    if (element.hasSentElement())
4158      composeDateTime(t, "Communication", "sent", element.getSentElement(), -1);
4159    if (element.hasReceivedElement())
4160      composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1);
4161    for (int i = 0; i < element.getRecipient().size(); i++)
4162      composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i);
4163    if (element.hasSender())
4164      composeReference(t, "Communication", "sender", element.getSender(), -1);
4165    for (int i = 0; i < element.getReasonCode().size(); i++)
4166      composeCodeableConcept(t, "Communication", "reasonCode", element.getReasonCode().get(i), i);
4167    for (int i = 0; i < element.getReasonReference().size(); i++)
4168      composeReference(t, "Communication", "reasonReference", element.getReasonReference().get(i), i);
4169    for (int i = 0; i < element.getPayload().size(); i++)
4170      composeCommunicationCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i);
4171    for (int i = 0; i < element.getNote().size(); i++)
4172      composeAnnotation(t, "Communication", "note", element.getNote().get(i), i);
4173  }
4174
4175  protected void composeCommunicationCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) {
4176    if (element == null) 
4177      return;
4178    Complex t;
4179    if (Utilities.noString(parentType))
4180      t = parent;
4181    else {
4182      t = parent.predicate("fhir:"+parentType+'.'+name);
4183    }
4184    composeBackboneElement(t, "payload", name, element, index);
4185    if (element.hasContent())
4186      composeType(t, "Communication", "content", element.getContent(), -1);
4187  }
4188
4189  protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) {
4190    if (element == null) 
4191      return;
4192    Complex t;
4193    if (Utilities.noString(parentType))
4194      t = parent;
4195    else {
4196      t = parent.predicate("fhir:"+parentType+'.'+name);
4197    }
4198    composeDomainResource(t, "CommunicationRequest", name, element, index);
4199    for (int i = 0; i < element.getIdentifier().size(); i++)
4200      composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i);
4201    for (int i = 0; i < element.getBasedOn().size(); i++)
4202      composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i);
4203    for (int i = 0; i < element.getReplaces().size(); i++)
4204      composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i);
4205    if (element.hasGroupIdentifier())
4206      composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
4207    if (element.hasStatusElement())
4208      composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1);
4209    if (element.hasStatusReason())
4210      composeCodeableConcept(t, "CommunicationRequest", "statusReason", element.getStatusReason(), -1);
4211    for (int i = 0; i < element.getCategory().size(); i++)
4212      composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i);
4213    if (element.hasPriorityElement())
4214      composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1);
4215    if (element.hasDoNotPerformElement())
4216      composeBoolean(t, "CommunicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
4217    for (int i = 0; i < element.getMedium().size(); i++)
4218      composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i);
4219    if (element.hasSubject())
4220      composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1);
4221    for (int i = 0; i < element.getAbout().size(); i++)
4222      composeReference(t, "CommunicationRequest", "about", element.getAbout().get(i), i);
4223    if (element.hasEncounter())
4224      composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1);
4225    for (int i = 0; i < element.getPayload().size(); i++)
4226      composeCommunicationRequestCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i);
4227    if (element.hasOccurrence())
4228      composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1);
4229    if (element.hasAuthoredOnElement())
4230      composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
4231    if (element.hasRequester())
4232      composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1);
4233    for (int i = 0; i < element.getRecipient().size(); i++)
4234      composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i);
4235    if (element.hasSender())
4236      composeReference(t, "CommunicationRequest", "sender", element.getSender(), -1);
4237    for (int i = 0; i < element.getReasonCode().size(); i++)
4238      composeCodeableConcept(t, "CommunicationRequest", "reasonCode", element.getReasonCode().get(i), i);
4239    for (int i = 0; i < element.getReasonReference().size(); i++)
4240      composeReference(t, "CommunicationRequest", "reasonReference", element.getReasonReference().get(i), i);
4241    for (int i = 0; i < element.getNote().size(); i++)
4242      composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i);
4243  }
4244
4245  protected void composeCommunicationRequestCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) {
4246    if (element == null) 
4247      return;
4248    Complex t;
4249    if (Utilities.noString(parentType))
4250      t = parent;
4251    else {
4252      t = parent.predicate("fhir:"+parentType+'.'+name);
4253    }
4254    composeBackboneElement(t, "payload", name, element, index);
4255    if (element.hasContent())
4256      composeType(t, "CommunicationRequest", "content", element.getContent(), -1);
4257  }
4258
4259  protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) {
4260    if (element == null) 
4261      return;
4262    Complex t;
4263    if (Utilities.noString(parentType))
4264      t = parent;
4265    else {
4266      t = parent.predicate("fhir:"+parentType+'.'+name);
4267    }
4268    composeDomainResource(t, "CompartmentDefinition", name, element, index);
4269    if (element.hasUrlElement())
4270      composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1);
4271    if (element.hasVersionElement())
4272      composeString(t, "CompartmentDefinition", "version", element.getVersionElement(), -1);
4273    if (element.hasNameElement())
4274      composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1);
4275    if (element.hasStatusElement())
4276      composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1);
4277    if (element.hasExperimentalElement())
4278      composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1);
4279    if (element.hasDateElement())
4280      composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1);
4281    if (element.hasPublisherElement())
4282      composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1);
4283    for (int i = 0; i < element.getContact().size(); i++)
4284      composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i);
4285    if (element.hasDescriptionElement())
4286      composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1);
4287    for (int i = 0; i < element.getUseContext().size(); i++)
4288      composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i);
4289    if (element.hasPurposeElement())
4290      composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1);
4291    if (element.hasCodeElement())
4292      composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1);
4293    if (element.hasSearchElement())
4294      composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1);
4295    for (int i = 0; i < element.getResource().size(); i++)
4296      composeCompartmentDefinitionCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i);
4297  }
4298
4299  protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) {
4300    if (element == null) 
4301      return;
4302    Complex t;
4303    if (Utilities.noString(parentType))
4304      t = parent;
4305    else {
4306      t = parent.predicate("fhir:"+parentType+'.'+name);
4307    }
4308    composeBackboneElement(t, "resource", name, element, index);
4309    if (element.hasCodeElement())
4310      composeCode(t, "CompartmentDefinition", "code", element.getCodeElement(), -1);
4311    for (int i = 0; i < element.getParam().size(); i++)
4312      composeString(t, "CompartmentDefinition", "param", element.getParam().get(i), i);
4313    if (element.hasDocumentationElement())
4314      composeString(t, "CompartmentDefinition", "documentation", element.getDocumentationElement(), -1);
4315  }
4316
4317  protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) {
4318    if (element == null) 
4319      return;
4320    Complex t;
4321    if (Utilities.noString(parentType))
4322      t = parent;
4323    else {
4324      t = parent.predicate("fhir:"+parentType+'.'+name);
4325    }
4326    composeDomainResource(t, "Composition", name, element, index);
4327    if (element.hasIdentifier())
4328      composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1);
4329    if (element.hasStatusElement())
4330      composeEnum(t, "Composition", "status", element.getStatusElement(), -1);
4331    if (element.hasType())
4332      composeCodeableConcept(t, "Composition", "type", element.getType(), -1);
4333    for (int i = 0; i < element.getCategory().size(); i++)
4334      composeCodeableConcept(t, "Composition", "category", element.getCategory().get(i), i);
4335    if (element.hasSubject())
4336      composeReference(t, "Composition", "subject", element.getSubject(), -1);
4337    if (element.hasEncounter())
4338      composeReference(t, "Composition", "encounter", element.getEncounter(), -1);
4339    if (element.hasDateElement())
4340      composeDateTime(t, "Composition", "date", element.getDateElement(), -1);
4341    for (int i = 0; i < element.getAuthor().size(); i++)
4342      composeReference(t, "Composition", "author", element.getAuthor().get(i), i);
4343    if (element.hasTitleElement())
4344      composeString(t, "Composition", "title", element.getTitleElement(), -1);
4345    if (element.hasConfidentialityElement())
4346      composeEnum(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1);
4347    for (int i = 0; i < element.getAttester().size(); i++)
4348      composeCompositionCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i);
4349    if (element.hasCustodian())
4350      composeReference(t, "Composition", "custodian", element.getCustodian(), -1);
4351    for (int i = 0; i < element.getRelatesTo().size(); i++)
4352      composeCompositionCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i);
4353    for (int i = 0; i < element.getEvent().size(); i++)
4354      composeCompositionCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i);
4355    for (int i = 0; i < element.getSection().size(); i++)
4356      composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i);
4357  }
4358
4359  protected void composeCompositionCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) {
4360    if (element == null) 
4361      return;
4362    Complex t;
4363    if (Utilities.noString(parentType))
4364      t = parent;
4365    else {
4366      t = parent.predicate("fhir:"+parentType+'.'+name);
4367    }
4368    composeBackboneElement(t, "attester", name, element, index);
4369    if (element.hasModeElement())
4370      composeEnum(t, "Composition", "mode", element.getModeElement(), -1);
4371    if (element.hasTimeElement())
4372      composeDateTime(t, "Composition", "time", element.getTimeElement(), -1);
4373    if (element.hasParty())
4374      composeReference(t, "Composition", "party", element.getParty(), -1);
4375  }
4376
4377  protected void composeCompositionCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) {
4378    if (element == null) 
4379      return;
4380    Complex t;
4381    if (Utilities.noString(parentType))
4382      t = parent;
4383    else {
4384      t = parent.predicate("fhir:"+parentType+'.'+name);
4385    }
4386    composeBackboneElement(t, "relatesTo", name, element, index);
4387    if (element.hasCodeElement())
4388      composeEnum(t, "Composition", "code", element.getCodeElement(), -1);
4389    if (element.hasTarget())
4390      composeType(t, "Composition", "target", element.getTarget(), -1);
4391  }
4392
4393  protected void composeCompositionCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) {
4394    if (element == null) 
4395      return;
4396    Complex t;
4397    if (Utilities.noString(parentType))
4398      t = parent;
4399    else {
4400      t = parent.predicate("fhir:"+parentType+'.'+name);
4401    }
4402    composeBackboneElement(t, "event", name, element, index);
4403    for (int i = 0; i < element.getCode().size(); i++)
4404      composeCodeableConcept(t, "Composition", "code", element.getCode().get(i), i);
4405    if (element.hasPeriod())
4406      composePeriod(t, "Composition", "period", element.getPeriod(), -1);
4407    for (int i = 0; i < element.getDetail().size(); i++)
4408      composeReference(t, "Composition", "detail", element.getDetail().get(i), i);
4409  }
4410
4411  protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) {
4412    if (element == null) 
4413      return;
4414    Complex t;
4415    if (Utilities.noString(parentType))
4416      t = parent;
4417    else {
4418      t = parent.predicate("fhir:"+parentType+'.'+name);
4419    }
4420    composeBackboneElement(t, "section", name, element, index);
4421    if (element.hasTitleElement())
4422      composeString(t, "Composition", "title", element.getTitleElement(), -1);
4423    if (element.hasCode())
4424      composeCodeableConcept(t, "Composition", "code", element.getCode(), -1);
4425    for (int i = 0; i < element.getAuthor().size(); i++)
4426      composeReference(t, "Composition", "author", element.getAuthor().get(i), i);
4427    if (element.hasFocus())
4428      composeReference(t, "Composition", "focus", element.getFocus(), -1);
4429    if (element.hasText())
4430      composeNarrative(t, "Composition", "text", element.getText(), -1);
4431    if (element.hasModeElement())
4432      composeEnum(t, "Composition", "mode", element.getModeElement(), -1);
4433    if (element.hasOrderedBy())
4434      composeCodeableConcept(t, "Composition", "orderedBy", element.getOrderedBy(), -1);
4435    for (int i = 0; i < element.getEntry().size(); i++)
4436      composeReference(t, "Composition", "entry", element.getEntry().get(i), i);
4437    if (element.hasEmptyReason())
4438      composeCodeableConcept(t, "Composition", "emptyReason", element.getEmptyReason(), -1);
4439    for (int i = 0; i < element.getSection().size(); i++)
4440      composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i);
4441  }
4442
4443  protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) {
4444    if (element == null) 
4445      return;
4446    Complex t;
4447    if (Utilities.noString(parentType))
4448      t = parent;
4449    else {
4450      t = parent.predicate("fhir:"+parentType+'.'+name);
4451    }
4452    composeDomainResource(t, "ConceptMap", name, element, index);
4453    if (element.hasUrlElement())
4454      composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1);
4455    if (element.hasIdentifier())
4456      composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier(), -1);
4457    if (element.hasVersionElement())
4458      composeString(t, "ConceptMap", "version", element.getVersionElement(), -1);
4459    if (element.hasNameElement())
4460      composeString(t, "ConceptMap", "name", element.getNameElement(), -1);
4461    if (element.hasTitleElement())
4462      composeString(t, "ConceptMap", "title", element.getTitleElement(), -1);
4463    if (element.hasStatusElement())
4464      composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1);
4465    if (element.hasExperimentalElement())
4466      composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1);
4467    if (element.hasDateElement())
4468      composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1);
4469    if (element.hasPublisherElement())
4470      composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1);
4471    for (int i = 0; i < element.getContact().size(); i++)
4472      composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i);
4473    if (element.hasDescriptionElement())
4474      composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1);
4475    for (int i = 0; i < element.getUseContext().size(); i++)
4476      composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i);
4477    for (int i = 0; i < element.getJurisdiction().size(); i++)
4478      composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i);
4479    if (element.hasPurposeElement())
4480      composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1);
4481    if (element.hasCopyrightElement())
4482      composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1);
4483    if (element.hasSource())
4484      composeType(t, "ConceptMap", "source", element.getSource(), -1);
4485    if (element.hasTarget())
4486      composeType(t, "ConceptMap", "target", element.getTarget(), -1);
4487    for (int i = 0; i < element.getGroup().size(); i++)
4488      composeConceptMapConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i);
4489  }
4490
4491  protected void composeConceptMapConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) {
4492    if (element == null) 
4493      return;
4494    Complex t;
4495    if (Utilities.noString(parentType))
4496      t = parent;
4497    else {
4498      t = parent.predicate("fhir:"+parentType+'.'+name);
4499    }
4500    composeBackboneElement(t, "group", name, element, index);
4501    if (element.hasSourceElement())
4502      composeUri(t, "ConceptMap", "source", element.getSourceElement(), -1);
4503    if (element.hasSourceVersionElement())
4504      composeString(t, "ConceptMap", "sourceVersion", element.getSourceVersionElement(), -1);
4505    if (element.hasTargetElement())
4506      composeUri(t, "ConceptMap", "target", element.getTargetElement(), -1);
4507    if (element.hasTargetVersionElement())
4508      composeString(t, "ConceptMap", "targetVersion", element.getTargetVersionElement(), -1);
4509    for (int i = 0; i < element.getElement().size(); i++)
4510      composeConceptMapSourceElementComponent(t, "ConceptMap", "element", element.getElement().get(i), i);
4511    if (element.hasUnmapped())
4512      composeConceptMapConceptMapGroupUnmappedComponent(t, "ConceptMap", "unmapped", element.getUnmapped(), -1);
4513  }
4514
4515  protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) {
4516    if (element == null) 
4517      return;
4518    Complex t;
4519    if (Utilities.noString(parentType))
4520      t = parent;
4521    else {
4522      t = parent.predicate("fhir:"+parentType+'.'+name);
4523    }
4524    composeBackboneElement(t, "element", name, element, index);
4525    if (element.hasCodeElement())
4526      composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1);
4527    if (element.hasDisplayElement())
4528      composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1);
4529    for (int i = 0; i < element.getTarget().size(); i++)
4530      composeConceptMapTargetElementComponent(t, "ConceptMap", "target", element.getTarget().get(i), i);
4531  }
4532
4533  protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) {
4534    if (element == null) 
4535      return;
4536    Complex t;
4537    if (Utilities.noString(parentType))
4538      t = parent;
4539    else {
4540      t = parent.predicate("fhir:"+parentType+'.'+name);
4541    }
4542    composeBackboneElement(t, "target", name, element, index);
4543    if (element.hasCodeElement())
4544      composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1);
4545    if (element.hasDisplayElement())
4546      composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1);
4547    if (element.hasEquivalenceElement())
4548      composeEnum(t, "ConceptMap", "equivalence", element.getEquivalenceElement(), -1);
4549    if (element.hasCommentElement())
4550      composeString(t, "ConceptMap", "comment", element.getCommentElement(), -1);
4551    for (int i = 0; i < element.getDependsOn().size(); i++)
4552      composeConceptMapOtherElementComponent(t, "ConceptMap", "dependsOn", element.getDependsOn().get(i), i);
4553    for (int i = 0; i < element.getProduct().size(); i++)
4554      composeConceptMapOtherElementComponent(t, "ConceptMap", "product", element.getProduct().get(i), i);
4555  }
4556
4557  protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) {
4558    if (element == null) 
4559      return;
4560    Complex t;
4561    if (Utilities.noString(parentType))
4562      t = parent;
4563    else {
4564      t = parent.predicate("fhir:"+parentType+'.'+name);
4565    }
4566    composeBackboneElement(t, "dependsOn", name, element, index);
4567    if (element.hasPropertyElement())
4568      composeUri(t, "ConceptMap", "property", element.getPropertyElement(), -1);
4569    if (element.hasSystemElement())
4570      composeCanonical(t, "ConceptMap", "system", element.getSystemElement(), -1);
4571    if (element.hasValueElement())
4572      composeString(t, "ConceptMap", "value", element.getValueElement(), -1);
4573    if (element.hasDisplayElement())
4574      composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1);
4575  }
4576
4577  protected void composeConceptMapConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) {
4578    if (element == null) 
4579      return;
4580    Complex t;
4581    if (Utilities.noString(parentType))
4582      t = parent;
4583    else {
4584      t = parent.predicate("fhir:"+parentType+'.'+name);
4585    }
4586    composeBackboneElement(t, "unmapped", name, element, index);
4587    if (element.hasModeElement())
4588      composeEnum(t, "ConceptMap", "mode", element.getModeElement(), -1);
4589    if (element.hasCodeElement())
4590      composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1);
4591    if (element.hasDisplayElement())
4592      composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1);
4593    if (element.hasUrlElement())
4594      composeCanonical(t, "ConceptMap", "url", element.getUrlElement(), -1);
4595  }
4596
4597  protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) {
4598    if (element == null) 
4599      return;
4600    Complex t;
4601    if (Utilities.noString(parentType))
4602      t = parent;
4603    else {
4604      t = parent.predicate("fhir:"+parentType+'.'+name);
4605    }
4606    composeDomainResource(t, "Condition", name, element, index);
4607    for (int i = 0; i < element.getIdentifier().size(); i++)
4608      composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i);
4609    if (element.hasClinicalStatus())
4610      composeCodeableConcept(t, "Condition", "clinicalStatus", element.getClinicalStatus(), -1);
4611    if (element.hasVerificationStatus())
4612      composeCodeableConcept(t, "Condition", "verificationStatus", element.getVerificationStatus(), -1);
4613    for (int i = 0; i < element.getCategory().size(); i++)
4614      composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i);
4615    if (element.hasSeverity())
4616      composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1);
4617    if (element.hasCode())
4618      composeCodeableConcept(t, "Condition", "code", element.getCode(), -1);
4619    for (int i = 0; i < element.getBodySite().size(); i++)
4620      composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i);
4621    if (element.hasSubject())
4622      composeReference(t, "Condition", "subject", element.getSubject(), -1);
4623    if (element.hasEncounter())
4624      composeReference(t, "Condition", "encounter", element.getEncounter(), -1);
4625    if (element.hasOnset())
4626      composeType(t, "Condition", "onset", element.getOnset(), -1);
4627    if (element.hasAbatement())
4628      composeType(t, "Condition", "abatement", element.getAbatement(), -1);
4629    if (element.hasRecordedDateElement())
4630      composeDateTime(t, "Condition", "recordedDate", element.getRecordedDateElement(), -1);
4631    if (element.hasRecorder())
4632      composeReference(t, "Condition", "recorder", element.getRecorder(), -1);
4633    if (element.hasAsserter())
4634      composeReference(t, "Condition", "asserter", element.getAsserter(), -1);
4635    for (int i = 0; i < element.getStage().size(); i++)
4636      composeConditionConditionStageComponent(t, "Condition", "stage", element.getStage().get(i), i);
4637    for (int i = 0; i < element.getEvidence().size(); i++)
4638      composeConditionConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i);
4639    for (int i = 0; i < element.getNote().size(); i++)
4640      composeAnnotation(t, "Condition", "note", element.getNote().get(i), i);
4641  }
4642
4643  protected void composeConditionConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) {
4644    if (element == null) 
4645      return;
4646    Complex t;
4647    if (Utilities.noString(parentType))
4648      t = parent;
4649    else {
4650      t = parent.predicate("fhir:"+parentType+'.'+name);
4651    }
4652    composeBackboneElement(t, "stage", name, element, index);
4653    if (element.hasSummary())
4654      composeCodeableConcept(t, "Condition", "summary", element.getSummary(), -1);
4655    for (int i = 0; i < element.getAssessment().size(); i++)
4656      composeReference(t, "Condition", "assessment", element.getAssessment().get(i), i);
4657    if (element.hasType())
4658      composeCodeableConcept(t, "Condition", "type", element.getType(), -1);
4659  }
4660
4661  protected void composeConditionConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) {
4662    if (element == null) 
4663      return;
4664    Complex t;
4665    if (Utilities.noString(parentType))
4666      t = parent;
4667    else {
4668      t = parent.predicate("fhir:"+parentType+'.'+name);
4669    }
4670    composeBackboneElement(t, "evidence", name, element, index);
4671    for (int i = 0; i < element.getCode().size(); i++)
4672      composeCodeableConcept(t, "Condition", "code", element.getCode().get(i), i);
4673    for (int i = 0; i < element.getDetail().size(); i++)
4674      composeReference(t, "Condition", "detail", element.getDetail().get(i), i);
4675  }
4676
4677  protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) {
4678    if (element == null) 
4679      return;
4680    Complex t;
4681    if (Utilities.noString(parentType))
4682      t = parent;
4683    else {
4684      t = parent.predicate("fhir:"+parentType+'.'+name);
4685    }
4686    composeDomainResource(t, "Consent", name, element, index);
4687    for (int i = 0; i < element.getIdentifier().size(); i++)
4688      composeIdentifier(t, "Consent", "identifier", element.getIdentifier().get(i), i);
4689    if (element.hasStatusElement())
4690      composeEnum(t, "Consent", "status", element.getStatusElement(), -1);
4691    if (element.hasScope())
4692      composeCodeableConcept(t, "Consent", "scope", element.getScope(), -1);
4693    for (int i = 0; i < element.getCategory().size(); i++)
4694      composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i);
4695    if (element.hasPatient())
4696      composeReference(t, "Consent", "patient", element.getPatient(), -1);
4697    if (element.hasDateTimeElement())
4698      composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1);
4699    for (int i = 0; i < element.getPerformer().size(); i++)
4700      composeReference(t, "Consent", "performer", element.getPerformer().get(i), i);
4701    for (int i = 0; i < element.getOrganization().size(); i++)
4702      composeReference(t, "Consent", "organization", element.getOrganization().get(i), i);
4703    if (element.hasSource())
4704      composeType(t, "Consent", "source", element.getSource(), -1);
4705    for (int i = 0; i < element.getPolicy().size(); i++)
4706      composeConsentConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i);
4707    if (element.hasPolicyRule())
4708      composeCodeableConcept(t, "Consent", "policyRule", element.getPolicyRule(), -1);
4709    for (int i = 0; i < element.getVerification().size(); i++)
4710      composeConsentConsentVerificationComponent(t, "Consent", "verification", element.getVerification().get(i), i);
4711    if (element.hasProvision())
4712      composeConsentprovisionComponent(t, "Consent", "provision", element.getProvision(), -1);
4713  }
4714
4715  protected void composeConsentConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) {
4716    if (element == null) 
4717      return;
4718    Complex t;
4719    if (Utilities.noString(parentType))
4720      t = parent;
4721    else {
4722      t = parent.predicate("fhir:"+parentType+'.'+name);
4723    }
4724    composeBackboneElement(t, "policy", name, element, index);
4725    if (element.hasAuthorityElement())
4726      composeUri(t, "Consent", "authority", element.getAuthorityElement(), -1);
4727    if (element.hasUriElement())
4728      composeUri(t, "Consent", "uri", element.getUriElement(), -1);
4729  }
4730
4731  protected void composeConsentConsentVerificationComponent(Complex parent, String parentType, String name, Consent.ConsentVerificationComponent element, int index) {
4732    if (element == null) 
4733      return;
4734    Complex t;
4735    if (Utilities.noString(parentType))
4736      t = parent;
4737    else {
4738      t = parent.predicate("fhir:"+parentType+'.'+name);
4739    }
4740    composeBackboneElement(t, "verification", name, element, index);
4741    if (element.hasVerifiedElement())
4742      composeBoolean(t, "Consent", "verified", element.getVerifiedElement(), -1);
4743    if (element.hasVerifiedWith())
4744      composeReference(t, "Consent", "verifiedWith", element.getVerifiedWith(), -1);
4745    if (element.hasVerificationDateElement())
4746      composeDateTime(t, "Consent", "verificationDate", element.getVerificationDateElement(), -1);
4747  }
4748
4749  protected void composeConsentprovisionComponent(Complex parent, String parentType, String name, Consent.provisionComponent element, int index) {
4750    if (element == null) 
4751      return;
4752    Complex t;
4753    if (Utilities.noString(parentType))
4754      t = parent;
4755    else {
4756      t = parent.predicate("fhir:"+parentType+'.'+name);
4757    }
4758    composeBackboneElement(t, "provision", name, element, index);
4759    if (element.hasTypeElement())
4760      composeEnum(t, "Consent", "type", element.getTypeElement(), -1);
4761    if (element.hasPeriod())
4762      composePeriod(t, "Consent", "period", element.getPeriod(), -1);
4763    for (int i = 0; i < element.getActor().size(); i++)
4764      composeConsentprovisionActorComponent(t, "Consent", "actor", element.getActor().get(i), i);
4765    for (int i = 0; i < element.getAction().size(); i++)
4766      composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i);
4767    for (int i = 0; i < element.getSecurityLabel().size(); i++)
4768      composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i);
4769    for (int i = 0; i < element.getPurpose().size(); i++)
4770      composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i);
4771    for (int i = 0; i < element.getClass_().size(); i++)
4772      composeCoding(t, "Consent", "class", element.getClass_().get(i), i);
4773    for (int i = 0; i < element.getCode().size(); i++)
4774      composeCodeableConcept(t, "Consent", "code", element.getCode().get(i), i);
4775    if (element.hasDataPeriod())
4776      composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1);
4777    for (int i = 0; i < element.getData().size(); i++)
4778      composeConsentprovisionDataComponent(t, "Consent", "data", element.getData().get(i), i);
4779    for (int i = 0; i < element.getProvision().size(); i++)
4780      composeConsentprovisionComponent(t, "Consent", "provision", element.getProvision().get(i), i);
4781  }
4782
4783  protected void composeConsentprovisionActorComponent(Complex parent, String parentType, String name, Consent.provisionActorComponent element, int index) {
4784    if (element == null) 
4785      return;
4786    Complex t;
4787    if (Utilities.noString(parentType))
4788      t = parent;
4789    else {
4790      t = parent.predicate("fhir:"+parentType+'.'+name);
4791    }
4792    composeBackboneElement(t, "actor", name, element, index);
4793    if (element.hasRole())
4794      composeCodeableConcept(t, "Consent", "role", element.getRole(), -1);
4795    if (element.hasReference())
4796      composeReference(t, "Consent", "reference", element.getReference(), -1);
4797  }
4798
4799  protected void composeConsentprovisionDataComponent(Complex parent, String parentType, String name, Consent.provisionDataComponent element, int index) {
4800    if (element == null) 
4801      return;
4802    Complex t;
4803    if (Utilities.noString(parentType))
4804      t = parent;
4805    else {
4806      t = parent.predicate("fhir:"+parentType+'.'+name);
4807    }
4808    composeBackboneElement(t, "data", name, element, index);
4809    if (element.hasMeaningElement())
4810      composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1);
4811    if (element.hasReference())
4812      composeReference(t, "Consent", "reference", element.getReference(), -1);
4813  }
4814
4815  protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) {
4816    if (element == null) 
4817      return;
4818    Complex t;
4819    if (Utilities.noString(parentType))
4820      t = parent;
4821    else {
4822      t = parent.predicate("fhir:"+parentType+'.'+name);
4823    }
4824    composeDomainResource(t, "Contract", name, element, index);
4825    for (int i = 0; i < element.getIdentifier().size(); i++)
4826      composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i);
4827    if (element.hasUrlElement())
4828      composeUri(t, "Contract", "url", element.getUrlElement(), -1);
4829    if (element.hasVersionElement())
4830      composeString(t, "Contract", "version", element.getVersionElement(), -1);
4831    if (element.hasStatusElement())
4832      composeEnum(t, "Contract", "status", element.getStatusElement(), -1);
4833    if (element.hasLegalState())
4834      composeCodeableConcept(t, "Contract", "legalState", element.getLegalState(), -1);
4835    if (element.hasInstantiatesCanonical())
4836      composeReference(t, "Contract", "instantiatesCanonical", element.getInstantiatesCanonical(), -1);
4837    if (element.hasInstantiatesUriElement())
4838      composeUri(t, "Contract", "instantiatesUri", element.getInstantiatesUriElement(), -1);
4839    if (element.hasContentDerivative())
4840      composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1);
4841    if (element.hasIssuedElement())
4842      composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1);
4843    if (element.hasApplies())
4844      composePeriod(t, "Contract", "applies", element.getApplies(), -1);
4845    if (element.hasExpirationType())
4846      composeCodeableConcept(t, "Contract", "expirationType", element.getExpirationType(), -1);
4847    for (int i = 0; i < element.getSubject().size(); i++)
4848      composeReference(t, "Contract", "subject", element.getSubject().get(i), i);
4849    for (int i = 0; i < element.getAuthority().size(); i++)
4850      composeReference(t, "Contract", "authority", element.getAuthority().get(i), i);
4851    for (int i = 0; i < element.getDomain().size(); i++)
4852      composeReference(t, "Contract", "domain", element.getDomain().get(i), i);
4853    for (int i = 0; i < element.getSite().size(); i++)
4854      composeReference(t, "Contract", "site", element.getSite().get(i), i);
4855    if (element.hasNameElement())
4856      composeString(t, "Contract", "name", element.getNameElement(), -1);
4857    if (element.hasTitleElement())
4858      composeString(t, "Contract", "title", element.getTitleElement(), -1);
4859    if (element.hasSubtitleElement())
4860      composeString(t, "Contract", "subtitle", element.getSubtitleElement(), -1);
4861    for (int i = 0; i < element.getAlias().size(); i++)
4862      composeString(t, "Contract", "alias", element.getAlias().get(i), i);
4863    if (element.hasAuthor())
4864      composeReference(t, "Contract", "author", element.getAuthor(), -1);
4865    if (element.hasScope())
4866      composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1);
4867    if (element.hasTopic())
4868      composeType(t, "Contract", "topic", element.getTopic(), -1);
4869    if (element.hasType())
4870      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
4871    for (int i = 0; i < element.getSubType().size(); i++)
4872      composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i);
4873    if (element.hasContentDefinition())
4874      composeContractContentDefinitionComponent(t, "Contract", "contentDefinition", element.getContentDefinition(), -1);
4875    for (int i = 0; i < element.getTerm().size(); i++)
4876      composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i);
4877    for (int i = 0; i < element.getSupportingInfo().size(); i++)
4878      composeReference(t, "Contract", "supportingInfo", element.getSupportingInfo().get(i), i);
4879    for (int i = 0; i < element.getRelevantHistory().size(); i++)
4880      composeReference(t, "Contract", "relevantHistory", element.getRelevantHistory().get(i), i);
4881    for (int i = 0; i < element.getSigner().size(); i++)
4882      composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i);
4883    for (int i = 0; i < element.getFriendly().size(); i++)
4884      composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i);
4885    for (int i = 0; i < element.getLegal().size(); i++)
4886      composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i);
4887    for (int i = 0; i < element.getRule().size(); i++)
4888      composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i);
4889    if (element.hasLegallyBinding())
4890      composeType(t, "Contract", "legallyBinding", element.getLegallyBinding(), -1);
4891  }
4892
4893  protected void composeContractContentDefinitionComponent(Complex parent, String parentType, String name, Contract.ContentDefinitionComponent 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    composeBackboneElement(t, "contentDefinition", name, element, index);
4903    if (element.hasType())
4904      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
4905    if (element.hasSubType())
4906      composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1);
4907    if (element.hasPublisher())
4908      composeReference(t, "Contract", "publisher", element.getPublisher(), -1);
4909    if (element.hasPublicationDateElement())
4910      composeDateTime(t, "Contract", "publicationDate", element.getPublicationDateElement(), -1);
4911    if (element.hasPublicationStatusElement())
4912      composeEnum(t, "Contract", "publicationStatus", element.getPublicationStatusElement(), -1);
4913    if (element.hasCopyrightElement())
4914      composeMarkdown(t, "Contract", "copyright", element.getCopyrightElement(), -1);
4915  }
4916
4917  protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) {
4918    if (element == null) 
4919      return;
4920    Complex t;
4921    if (Utilities.noString(parentType))
4922      t = parent;
4923    else {
4924      t = parent.predicate("fhir:"+parentType+'.'+name);
4925    }
4926    composeBackboneElement(t, "term", name, element, index);
4927    if (element.hasIdentifier())
4928      composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1);
4929    if (element.hasIssuedElement())
4930      composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1);
4931    if (element.hasApplies())
4932      composePeriod(t, "Contract", "applies", element.getApplies(), -1);
4933    if (element.hasTopic())
4934      composeType(t, "Contract", "topic", element.getTopic(), -1);
4935    if (element.hasType())
4936      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
4937    if (element.hasSubType())
4938      composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1);
4939    if (element.hasTextElement())
4940      composeString(t, "Contract", "text", element.getTextElement(), -1);
4941    for (int i = 0; i < element.getSecurityLabel().size(); i++)
4942      composeContractSecurityLabelComponent(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i);
4943    if (element.hasOffer())
4944      composeContractContractOfferComponent(t, "Contract", "offer", element.getOffer(), -1);
4945    for (int i = 0; i < element.getAsset().size(); i++)
4946      composeContractContractAssetComponent(t, "Contract", "asset", element.getAsset().get(i), i);
4947    for (int i = 0; i < element.getAction().size(); i++)
4948      composeContractActionComponent(t, "Contract", "action", element.getAction().get(i), i);
4949    for (int i = 0; i < element.getGroup().size(); i++)
4950      composeContractTermComponent(t, "Contract", "group", element.getGroup().get(i), i);
4951  }
4952
4953  protected void composeContractSecurityLabelComponent(Complex parent, String parentType, String name, Contract.SecurityLabelComponent element, int index) {
4954    if (element == null) 
4955      return;
4956    Complex t;
4957    if (Utilities.noString(parentType))
4958      t = parent;
4959    else {
4960      t = parent.predicate("fhir:"+parentType+'.'+name);
4961    }
4962    composeBackboneElement(t, "securityLabel", name, element, index);
4963    for (int i = 0; i < element.getNumber().size(); i++)
4964      composeUnsignedInt(t, "Contract", "number", element.getNumber().get(i), i);
4965    if (element.hasClassification())
4966      composeCoding(t, "Contract", "classification", element.getClassification(), -1);
4967    for (int i = 0; i < element.getCategory().size(); i++)
4968      composeCoding(t, "Contract", "category", element.getCategory().get(i), i);
4969    for (int i = 0; i < element.getControl().size(); i++)
4970      composeCoding(t, "Contract", "control", element.getControl().get(i), i);
4971  }
4972
4973  protected void composeContractContractOfferComponent(Complex parent, String parentType, String name, Contract.ContractOfferComponent 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, "offer", name, element, index);
4983    for (int i = 0; i < element.getIdentifier().size(); i++)
4984      composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i);
4985    for (int i = 0; i < element.getParty().size(); i++)
4986      composeContractContractPartyComponent(t, "Contract", "party", element.getParty().get(i), i);
4987    if (element.hasTopic())
4988      composeReference(t, "Contract", "topic", element.getTopic(), -1);
4989    if (element.hasType())
4990      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
4991    if (element.hasDecision())
4992      composeCodeableConcept(t, "Contract", "decision", element.getDecision(), -1);
4993    for (int i = 0; i < element.getDecisionMode().size(); i++)
4994      composeCodeableConcept(t, "Contract", "decisionMode", element.getDecisionMode().get(i), i);
4995    for (int i = 0; i < element.getAnswer().size(); i++)
4996      composeContractAnswerComponent(t, "Contract", "answer", element.getAnswer().get(i), i);
4997    if (element.hasTextElement())
4998      composeString(t, "Contract", "text", element.getTextElement(), -1);
4999    for (int i = 0; i < element.getLinkId().size(); i++)
5000      composeString(t, "Contract", "linkId", element.getLinkId().get(i), i);
5001    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++)
5002      composeUnsignedInt(t, "Contract", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
5003  }
5004
5005  protected void composeContractContractPartyComponent(Complex parent, String parentType, String name, Contract.ContractPartyComponent 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    composeBackboneElement(t, "party", name, element, index);
5015    for (int i = 0; i < element.getReference().size(); i++)
5016      composeReference(t, "Contract", "reference", element.getReference().get(i), i);
5017    if (element.hasRole())
5018      composeCodeableConcept(t, "Contract", "role", element.getRole(), -1);
5019  }
5020
5021  protected void composeContractAnswerComponent(Complex parent, String parentType, String name, Contract.AnswerComponent element, int index) {
5022    if (element == null) 
5023      return;
5024    Complex t;
5025    if (Utilities.noString(parentType))
5026      t = parent;
5027    else {
5028      t = parent.predicate("fhir:"+parentType+'.'+name);
5029    }
5030    composeBackboneElement(t, "answer", name, element, index);
5031    if (element.hasValue())
5032      composeType(t, "Contract", "value", element.getValue(), -1);
5033  }
5034
5035  protected void composeContractContractAssetComponent(Complex parent, String parentType, String name, Contract.ContractAssetComponent element, int index) {
5036    if (element == null) 
5037      return;
5038    Complex t;
5039    if (Utilities.noString(parentType))
5040      t = parent;
5041    else {
5042      t = parent.predicate("fhir:"+parentType+'.'+name);
5043    }
5044    composeBackboneElement(t, "asset", name, element, index);
5045    if (element.hasScope())
5046      composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1);
5047    for (int i = 0; i < element.getType().size(); i++)
5048      composeCodeableConcept(t, "Contract", "type", element.getType().get(i), i);
5049    for (int i = 0; i < element.getTypeReference().size(); i++)
5050      composeReference(t, "Contract", "typeReference", element.getTypeReference().get(i), i);
5051    for (int i = 0; i < element.getSubtype().size(); i++)
5052      composeCodeableConcept(t, "Contract", "subtype", element.getSubtype().get(i), i);
5053    if (element.hasRelationship())
5054      composeCoding(t, "Contract", "relationship", element.getRelationship(), -1);
5055    for (int i = 0; i < element.getContext().size(); i++)
5056      composeContractAssetContextComponent(t, "Contract", "context", element.getContext().get(i), i);
5057    if (element.hasConditionElement())
5058      composeString(t, "Contract", "condition", element.getConditionElement(), -1);
5059    for (int i = 0; i < element.getPeriodType().size(); i++)
5060      composeCodeableConcept(t, "Contract", "periodType", element.getPeriodType().get(i), i);
5061    for (int i = 0; i < element.getPeriod().size(); i++)
5062      composePeriod(t, "Contract", "period", element.getPeriod().get(i), i);
5063    for (int i = 0; i < element.getUsePeriod().size(); i++)
5064      composePeriod(t, "Contract", "usePeriod", element.getUsePeriod().get(i), i);
5065    if (element.hasTextElement())
5066      composeString(t, "Contract", "text", element.getTextElement(), -1);
5067    for (int i = 0; i < element.getLinkId().size(); i++)
5068      composeString(t, "Contract", "linkId", element.getLinkId().get(i), i);
5069    for (int i = 0; i < element.getAnswer().size(); i++)
5070      composeContractAnswerComponent(t, "Contract", "answer", element.getAnswer().get(i), i);
5071    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++)
5072      composeUnsignedInt(t, "Contract", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
5073    for (int i = 0; i < element.getValuedItem().size(); i++)
5074      composeContractValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i);
5075  }
5076
5077  protected void composeContractAssetContextComponent(Complex parent, String parentType, String name, Contract.AssetContextComponent element, int index) {
5078    if (element == null) 
5079      return;
5080    Complex t;
5081    if (Utilities.noString(parentType))
5082      t = parent;
5083    else {
5084      t = parent.predicate("fhir:"+parentType+'.'+name);
5085    }
5086    composeBackboneElement(t, "context", name, element, index);
5087    if (element.hasReference())
5088      composeReference(t, "Contract", "reference", element.getReference(), -1);
5089    for (int i = 0; i < element.getCode().size(); i++)
5090      composeCodeableConcept(t, "Contract", "code", element.getCode().get(i), i);
5091    if (element.hasTextElement())
5092      composeString(t, "Contract", "text", element.getTextElement(), -1);
5093  }
5094
5095  protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) {
5096    if (element == null) 
5097      return;
5098    Complex t;
5099    if (Utilities.noString(parentType))
5100      t = parent;
5101    else {
5102      t = parent.predicate("fhir:"+parentType+'.'+name);
5103    }
5104    composeBackboneElement(t, "valuedItem", name, element, index);
5105    if (element.hasEntity())
5106      composeType(t, "Contract", "entity", element.getEntity(), -1);
5107    if (element.hasIdentifier())
5108      composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1);
5109    if (element.hasEffectiveTimeElement())
5110      composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1);
5111    if (element.hasQuantity())
5112      composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1);
5113    if (element.hasUnitPrice())
5114      composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1);
5115    if (element.hasFactorElement())
5116      composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1);
5117    if (element.hasPointsElement())
5118      composeDecimal(t, "Contract", "points", element.getPointsElement(), -1);
5119    if (element.hasNet())
5120      composeMoney(t, "Contract", "net", element.getNet(), -1);
5121    if (element.hasPaymentElement())
5122      composeString(t, "Contract", "payment", element.getPaymentElement(), -1);
5123    if (element.hasPaymentDateElement())
5124      composeDateTime(t, "Contract", "paymentDate", element.getPaymentDateElement(), -1);
5125    if (element.hasResponsible())
5126      composeReference(t, "Contract", "responsible", element.getResponsible(), -1);
5127    if (element.hasRecipient())
5128      composeReference(t, "Contract", "recipient", element.getRecipient(), -1);
5129    for (int i = 0; i < element.getLinkId().size(); i++)
5130      composeString(t, "Contract", "linkId", element.getLinkId().get(i), i);
5131    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++)
5132      composeUnsignedInt(t, "Contract", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
5133  }
5134
5135  protected void composeContractActionComponent(Complex parent, String parentType, String name, Contract.ActionComponent element, int index) {
5136    if (element == null) 
5137      return;
5138    Complex t;
5139    if (Utilities.noString(parentType))
5140      t = parent;
5141    else {
5142      t = parent.predicate("fhir:"+parentType+'.'+name);
5143    }
5144    composeBackboneElement(t, "action", name, element, index);
5145    if (element.hasDoNotPerformElement())
5146      composeBoolean(t, "Contract", "doNotPerform", element.getDoNotPerformElement(), -1);
5147    if (element.hasType())
5148      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
5149    for (int i = 0; i < element.getSubject().size(); i++)
5150      composeContractActionSubjectComponent(t, "Contract", "subject", element.getSubject().get(i), i);
5151    if (element.hasIntent())
5152      composeCodeableConcept(t, "Contract", "intent", element.getIntent(), -1);
5153    for (int i = 0; i < element.getLinkId().size(); i++)
5154      composeString(t, "Contract", "linkId", element.getLinkId().get(i), i);
5155    if (element.hasStatus())
5156      composeCodeableConcept(t, "Contract", "status", element.getStatus(), -1);
5157    if (element.hasContext())
5158      composeReference(t, "Contract", "context", element.getContext(), -1);
5159    for (int i = 0; i < element.getContextLinkId().size(); i++)
5160      composeString(t, "Contract", "contextLinkId", element.getContextLinkId().get(i), i);
5161    if (element.hasOccurrence())
5162      composeType(t, "Contract", "occurrence", element.getOccurrence(), -1);
5163    for (int i = 0; i < element.getRequester().size(); i++)
5164      composeReference(t, "Contract", "requester", element.getRequester().get(i), i);
5165    for (int i = 0; i < element.getRequesterLinkId().size(); i++)
5166      composeString(t, "Contract", "requesterLinkId", element.getRequesterLinkId().get(i), i);
5167    for (int i = 0; i < element.getPerformerType().size(); i++)
5168      composeCodeableConcept(t, "Contract", "performerType", element.getPerformerType().get(i), i);
5169    if (element.hasPerformerRole())
5170      composeCodeableConcept(t, "Contract", "performerRole", element.getPerformerRole(), -1);
5171    if (element.hasPerformer())
5172      composeReference(t, "Contract", "performer", element.getPerformer(), -1);
5173    for (int i = 0; i < element.getPerformerLinkId().size(); i++)
5174      composeString(t, "Contract", "performerLinkId", element.getPerformerLinkId().get(i), i);
5175    for (int i = 0; i < element.getReasonCode().size(); i++)
5176      composeCodeableConcept(t, "Contract", "reasonCode", element.getReasonCode().get(i), i);
5177    for (int i = 0; i < element.getReasonReference().size(); i++)
5178      composeReference(t, "Contract", "reasonReference", element.getReasonReference().get(i), i);
5179    for (int i = 0; i < element.getReason().size(); i++)
5180      composeString(t, "Contract", "reason", element.getReason().get(i), i);
5181    for (int i = 0; i < element.getReasonLinkId().size(); i++)
5182      composeString(t, "Contract", "reasonLinkId", element.getReasonLinkId().get(i), i);
5183    for (int i = 0; i < element.getNote().size(); i++)
5184      composeAnnotation(t, "Contract", "note", element.getNote().get(i), i);
5185    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++)
5186      composeUnsignedInt(t, "Contract", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
5187  }
5188
5189  protected void composeContractActionSubjectComponent(Complex parent, String parentType, String name, Contract.ActionSubjectComponent element, int index) {
5190    if (element == null) 
5191      return;
5192    Complex t;
5193    if (Utilities.noString(parentType))
5194      t = parent;
5195    else {
5196      t = parent.predicate("fhir:"+parentType+'.'+name);
5197    }
5198    composeBackboneElement(t, "subject", name, element, index);
5199    for (int i = 0; i < element.getReference().size(); i++)
5200      composeReference(t, "Contract", "reference", element.getReference().get(i), i);
5201    if (element.hasRole())
5202      composeCodeableConcept(t, "Contract", "role", element.getRole(), -1);
5203  }
5204
5205  protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) {
5206    if (element == null) 
5207      return;
5208    Complex t;
5209    if (Utilities.noString(parentType))
5210      t = parent;
5211    else {
5212      t = parent.predicate("fhir:"+parentType+'.'+name);
5213    }
5214    composeBackboneElement(t, "signer", name, element, index);
5215    if (element.hasType())
5216      composeCoding(t, "Contract", "type", element.getType(), -1);
5217    if (element.hasParty())
5218      composeReference(t, "Contract", "party", element.getParty(), -1);
5219    for (int i = 0; i < element.getSignature().size(); i++)
5220      composeSignature(t, "Contract", "signature", element.getSignature().get(i), i);
5221  }
5222
5223  protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) {
5224    if (element == null) 
5225      return;
5226    Complex t;
5227    if (Utilities.noString(parentType))
5228      t = parent;
5229    else {
5230      t = parent.predicate("fhir:"+parentType+'.'+name);
5231    }
5232    composeBackboneElement(t, "friendly", name, element, index);
5233    if (element.hasContent())
5234      composeType(t, "Contract", "content", element.getContent(), -1);
5235  }
5236
5237  protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) {
5238    if (element == null) 
5239      return;
5240    Complex t;
5241    if (Utilities.noString(parentType))
5242      t = parent;
5243    else {
5244      t = parent.predicate("fhir:"+parentType+'.'+name);
5245    }
5246    composeBackboneElement(t, "legal", name, element, index);
5247    if (element.hasContent())
5248      composeType(t, "Contract", "content", element.getContent(), -1);
5249  }
5250
5251  protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) {
5252    if (element == null) 
5253      return;
5254    Complex t;
5255    if (Utilities.noString(parentType))
5256      t = parent;
5257    else {
5258      t = parent.predicate("fhir:"+parentType+'.'+name);
5259    }
5260    composeBackboneElement(t, "rule", name, element, index);
5261    if (element.hasContent())
5262      composeType(t, "Contract", "content", element.getContent(), -1);
5263  }
5264
5265  protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) {
5266    if (element == null) 
5267      return;
5268    Complex t;
5269    if (Utilities.noString(parentType))
5270      t = parent;
5271    else {
5272      t = parent.predicate("fhir:"+parentType+'.'+name);
5273    }
5274    composeDomainResource(t, "Coverage", name, element, index);
5275    for (int i = 0; i < element.getIdentifier().size(); i++)
5276      composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i);
5277    if (element.hasStatusElement())
5278      composeEnum(t, "Coverage", "status", element.getStatusElement(), -1);
5279    if (element.hasType())
5280      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
5281    if (element.hasPolicyHolder())
5282      composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1);
5283    if (element.hasSubscriber())
5284      composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1);
5285    if (element.hasSubscriberIdElement())
5286      composeString(t, "Coverage", "subscriberId", element.getSubscriberIdElement(), -1);
5287    if (element.hasBeneficiary())
5288      composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1);
5289    if (element.hasDependentElement())
5290      composeString(t, "Coverage", "dependent", element.getDependentElement(), -1);
5291    if (element.hasRelationship())
5292      composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1);
5293    if (element.hasPeriod())
5294      composePeriod(t, "Coverage", "period", element.getPeriod(), -1);
5295    for (int i = 0; i < element.getPayor().size(); i++)
5296      composeReference(t, "Coverage", "payor", element.getPayor().get(i), i);
5297    for (int i = 0; i < element.getClass_().size(); i++)
5298      composeCoverageClassComponent(t, "Coverage", "class", element.getClass_().get(i), i);
5299    if (element.hasOrderElement())
5300      composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1);
5301    if (element.hasNetworkElement())
5302      composeString(t, "Coverage", "network", element.getNetworkElement(), -1);
5303    for (int i = 0; i < element.getCostToBeneficiary().size(); i++)
5304      composeCoverageCostToBeneficiaryComponent(t, "Coverage", "costToBeneficiary", element.getCostToBeneficiary().get(i), i);
5305    if (element.hasSubrogationElement())
5306      composeBoolean(t, "Coverage", "subrogation", element.getSubrogationElement(), -1);
5307    for (int i = 0; i < element.getContract().size(); i++)
5308      composeReference(t, "Coverage", "contract", element.getContract().get(i), i);
5309  }
5310
5311  protected void composeCoverageClassComponent(Complex parent, String parentType, String name, Coverage.ClassComponent element, int index) {
5312    if (element == null) 
5313      return;
5314    Complex t;
5315    if (Utilities.noString(parentType))
5316      t = parent;
5317    else {
5318      t = parent.predicate("fhir:"+parentType+'.'+name);
5319    }
5320    composeBackboneElement(t, "class", name, element, index);
5321    if (element.hasType())
5322      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
5323    if (element.hasValueElement())
5324      composeString(t, "Coverage", "value", element.getValueElement(), -1);
5325    if (element.hasNameElement())
5326      composeString(t, "Coverage", "name", element.getNameElement(), -1);
5327  }
5328
5329  protected void composeCoverageCostToBeneficiaryComponent(Complex parent, String parentType, String name, Coverage.CostToBeneficiaryComponent element, int index) {
5330    if (element == null) 
5331      return;
5332    Complex t;
5333    if (Utilities.noString(parentType))
5334      t = parent;
5335    else {
5336      t = parent.predicate("fhir:"+parentType+'.'+name);
5337    }
5338    composeBackboneElement(t, "costToBeneficiary", name, element, index);
5339    if (element.hasType())
5340      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
5341    if (element.hasValue())
5342      composeType(t, "Coverage", "value", element.getValue(), -1);
5343    for (int i = 0; i < element.getException().size(); i++)
5344      composeCoverageExemptionComponent(t, "Coverage", "exception", element.getException().get(i), i);
5345  }
5346
5347  protected void composeCoverageExemptionComponent(Complex parent, String parentType, String name, Coverage.ExemptionComponent element, int index) {
5348    if (element == null) 
5349      return;
5350    Complex t;
5351    if (Utilities.noString(parentType))
5352      t = parent;
5353    else {
5354      t = parent.predicate("fhir:"+parentType+'.'+name);
5355    }
5356    composeBackboneElement(t, "exception", name, element, index);
5357    if (element.hasType())
5358      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
5359    if (element.hasPeriod())
5360      composePeriod(t, "Coverage", "period", element.getPeriod(), -1);
5361  }
5362
5363  protected void composeCoverageEligibilityRequest(Complex parent, String parentType, String name, CoverageEligibilityRequest element, int index) {
5364    if (element == null) 
5365      return;
5366    Complex t;
5367    if (Utilities.noString(parentType))
5368      t = parent;
5369    else {
5370      t = parent.predicate("fhir:"+parentType+'.'+name);
5371    }
5372    composeDomainResource(t, "CoverageEligibilityRequest", name, element, index);
5373    for (int i = 0; i < element.getIdentifier().size(); i++)
5374      composeIdentifier(t, "CoverageEligibilityRequest", "identifier", element.getIdentifier().get(i), i);
5375    if (element.hasStatusElement())
5376      composeEnum(t, "CoverageEligibilityRequest", "status", element.getStatusElement(), -1);
5377    if (element.hasPriority())
5378      composeCodeableConcept(t, "CoverageEligibilityRequest", "priority", element.getPriority(), -1);
5379    for (int i = 0; i < element.getPurpose().size(); i++)
5380      composeEnum(t, "CoverageEligibilityRequest", "purpose", element.getPurpose().get(i), i);
5381    if (element.hasPatient())
5382      composeReference(t, "CoverageEligibilityRequest", "patient", element.getPatient(), -1);
5383    if (element.hasServiced())
5384      composeType(t, "CoverageEligibilityRequest", "serviced", element.getServiced(), -1);
5385    if (element.hasCreatedElement())
5386      composeDateTime(t, "CoverageEligibilityRequest", "created", element.getCreatedElement(), -1);
5387    if (element.hasEnterer())
5388      composeReference(t, "CoverageEligibilityRequest", "enterer", element.getEnterer(), -1);
5389    if (element.hasProvider())
5390      composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1);
5391    if (element.hasInsurer())
5392      composeReference(t, "CoverageEligibilityRequest", "insurer", element.getInsurer(), -1);
5393    if (element.hasFacility())
5394      composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1);
5395    for (int i = 0; i < element.getSupportingInfo().size(); i++)
5396      composeCoverageEligibilityRequestSupportingInformationComponent(t, "CoverageEligibilityRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
5397    for (int i = 0; i < element.getInsurance().size(); i++)
5398      composeCoverageEligibilityRequestInsuranceComponent(t, "CoverageEligibilityRequest", "insurance", element.getInsurance().get(i), i);
5399    for (int i = 0; i < element.getItem().size(); i++)
5400      composeCoverageEligibilityRequestDetailsComponent(t, "CoverageEligibilityRequest", "item", element.getItem().get(i), i);
5401  }
5402
5403  protected void composeCoverageEligibilityRequestSupportingInformationComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.SupportingInformationComponent element, int index) {
5404    if (element == null) 
5405      return;
5406    Complex t;
5407    if (Utilities.noString(parentType))
5408      t = parent;
5409    else {
5410      t = parent.predicate("fhir:"+parentType+'.'+name);
5411    }
5412    composeBackboneElement(t, "supportingInfo", name, element, index);
5413    if (element.hasSequenceElement())
5414      composePositiveInt(t, "CoverageEligibilityRequest", "sequence", element.getSequenceElement(), -1);
5415    if (element.hasInformation())
5416      composeReference(t, "CoverageEligibilityRequest", "information", element.getInformation(), -1);
5417    if (element.hasAppliesToAllElement())
5418      composeBoolean(t, "CoverageEligibilityRequest", "appliesToAll", element.getAppliesToAllElement(), -1);
5419  }
5420
5421  protected void composeCoverageEligibilityRequestInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.InsuranceComponent 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, "insurance", name, element, index);
5431    if (element.hasFocalElement())
5432      composeBoolean(t, "CoverageEligibilityRequest", "focal", element.getFocalElement(), -1);
5433    if (element.hasCoverage())
5434      composeReference(t, "CoverageEligibilityRequest", "coverage", element.getCoverage(), -1);
5435    if (element.hasBusinessArrangementElement())
5436      composeString(t, "CoverageEligibilityRequest", "businessArrangement", element.getBusinessArrangementElement(), -1);
5437  }
5438
5439  protected void composeCoverageEligibilityRequestDetailsComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DetailsComponent element, int index) {
5440    if (element == null) 
5441      return;
5442    Complex t;
5443    if (Utilities.noString(parentType))
5444      t = parent;
5445    else {
5446      t = parent.predicate("fhir:"+parentType+'.'+name);
5447    }
5448    composeBackboneElement(t, "item", name, element, index);
5449    for (int i = 0; i < element.getSupportingInfoSequence().size(); i++)
5450      composePositiveInt(t, "CoverageEligibilityRequest", "supportingInfoSequence", element.getSupportingInfoSequence().get(i), i);
5451    if (element.hasCategory())
5452      composeCodeableConcept(t, "CoverageEligibilityRequest", "category", element.getCategory(), -1);
5453    if (element.hasProductOrService())
5454      composeCodeableConcept(t, "CoverageEligibilityRequest", "productOrService", element.getProductOrService(), -1);
5455    for (int i = 0; i < element.getModifier().size(); i++)
5456      composeCodeableConcept(t, "CoverageEligibilityRequest", "modifier", element.getModifier().get(i), i);
5457    if (element.hasProvider())
5458      composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1);
5459    if (element.hasQuantity())
5460      composeQuantity(t, "CoverageEligibilityRequest", "quantity", element.getQuantity(), -1);
5461    if (element.hasUnitPrice())
5462      composeMoney(t, "CoverageEligibilityRequest", "unitPrice", element.getUnitPrice(), -1);
5463    if (element.hasFacility())
5464      composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1);
5465    for (int i = 0; i < element.getDiagnosis().size(); i++)
5466      composeCoverageEligibilityRequestDiagnosisComponent(t, "CoverageEligibilityRequest", "diagnosis", element.getDiagnosis().get(i), i);
5467    for (int i = 0; i < element.getDetail().size(); i++)
5468      composeReference(t, "CoverageEligibilityRequest", "detail", element.getDetail().get(i), i);
5469  }
5470
5471  protected void composeCoverageEligibilityRequestDiagnosisComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DiagnosisComponent element, int index) {
5472    if (element == null) 
5473      return;
5474    Complex t;
5475    if (Utilities.noString(parentType))
5476      t = parent;
5477    else {
5478      t = parent.predicate("fhir:"+parentType+'.'+name);
5479    }
5480    composeBackboneElement(t, "diagnosis", name, element, index);
5481    if (element.hasDiagnosis())
5482      composeType(t, "CoverageEligibilityRequest", "diagnosis", element.getDiagnosis(), -1);
5483  }
5484
5485  protected void composeCoverageEligibilityResponse(Complex parent, String parentType, String name, CoverageEligibilityResponse element, int index) {
5486    if (element == null) 
5487      return;
5488    Complex t;
5489    if (Utilities.noString(parentType))
5490      t = parent;
5491    else {
5492      t = parent.predicate("fhir:"+parentType+'.'+name);
5493    }
5494    composeDomainResource(t, "CoverageEligibilityResponse", name, element, index);
5495    for (int i = 0; i < element.getIdentifier().size(); i++)
5496      composeIdentifier(t, "CoverageEligibilityResponse", "identifier", element.getIdentifier().get(i), i);
5497    if (element.hasStatusElement())
5498      composeEnum(t, "CoverageEligibilityResponse", "status", element.getStatusElement(), -1);
5499    for (int i = 0; i < element.getPurpose().size(); i++)
5500      composeEnum(t, "CoverageEligibilityResponse", "purpose", element.getPurpose().get(i), i);
5501    if (element.hasPatient())
5502      composeReference(t, "CoverageEligibilityResponse", "patient", element.getPatient(), -1);
5503    if (element.hasServiced())
5504      composeType(t, "CoverageEligibilityResponse", "serviced", element.getServiced(), -1);
5505    if (element.hasCreatedElement())
5506      composeDateTime(t, "CoverageEligibilityResponse", "created", element.getCreatedElement(), -1);
5507    if (element.hasRequestor())
5508      composeReference(t, "CoverageEligibilityResponse", "requestor", element.getRequestor(), -1);
5509    if (element.hasRequest())
5510      composeReference(t, "CoverageEligibilityResponse", "request", element.getRequest(), -1);
5511    if (element.hasOutcomeElement())
5512      composeEnum(t, "CoverageEligibilityResponse", "outcome", element.getOutcomeElement(), -1);
5513    if (element.hasDispositionElement())
5514      composeString(t, "CoverageEligibilityResponse", "disposition", element.getDispositionElement(), -1);
5515    if (element.hasInsurer())
5516      composeReference(t, "CoverageEligibilityResponse", "insurer", element.getInsurer(), -1);
5517    for (int i = 0; i < element.getInsurance().size(); i++)
5518      composeCoverageEligibilityResponseInsuranceComponent(t, "CoverageEligibilityResponse", "insurance", element.getInsurance().get(i), i);
5519    if (element.hasPreAuthRefElement())
5520      composeString(t, "CoverageEligibilityResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
5521    if (element.hasForm())
5522      composeCodeableConcept(t, "CoverageEligibilityResponse", "form", element.getForm(), -1);
5523    for (int i = 0; i < element.getError().size(); i++)
5524      composeCoverageEligibilityResponseErrorsComponent(t, "CoverageEligibilityResponse", "error", element.getError().get(i), i);
5525  }
5526
5527  protected void composeCoverageEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.InsuranceComponent element, int index) {
5528    if (element == null) 
5529      return;
5530    Complex t;
5531    if (Utilities.noString(parentType))
5532      t = parent;
5533    else {
5534      t = parent.predicate("fhir:"+parentType+'.'+name);
5535    }
5536    composeBackboneElement(t, "insurance", name, element, index);
5537    if (element.hasCoverage())
5538      composeReference(t, "CoverageEligibilityResponse", "coverage", element.getCoverage(), -1);
5539    if (element.hasInforceElement())
5540      composeBoolean(t, "CoverageEligibilityResponse", "inforce", element.getInforceElement(), -1);
5541    if (element.hasBenefitPeriod())
5542      composePeriod(t, "CoverageEligibilityResponse", "benefitPeriod", element.getBenefitPeriod(), -1);
5543    for (int i = 0; i < element.getItem().size(); i++)
5544      composeCoverageEligibilityResponseItemsComponent(t, "CoverageEligibilityResponse", "item", element.getItem().get(i), i);
5545  }
5546
5547  protected void composeCoverageEligibilityResponseItemsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ItemsComponent element, int index) {
5548    if (element == null) 
5549      return;
5550    Complex t;
5551    if (Utilities.noString(parentType))
5552      t = parent;
5553    else {
5554      t = parent.predicate("fhir:"+parentType+'.'+name);
5555    }
5556    composeBackboneElement(t, "item", name, element, index);
5557    if (element.hasCategory())
5558      composeCodeableConcept(t, "CoverageEligibilityResponse", "category", element.getCategory(), -1);
5559    if (element.hasProductOrService())
5560      composeCodeableConcept(t, "CoverageEligibilityResponse", "productOrService", element.getProductOrService(), -1);
5561    for (int i = 0; i < element.getModifier().size(); i++)
5562      composeCodeableConcept(t, "CoverageEligibilityResponse", "modifier", element.getModifier().get(i), i);
5563    if (element.hasProvider())
5564      composeReference(t, "CoverageEligibilityResponse", "provider", element.getProvider(), -1);
5565    if (element.hasExcludedElement())
5566      composeBoolean(t, "CoverageEligibilityResponse", "excluded", element.getExcludedElement(), -1);
5567    if (element.hasNameElement())
5568      composeString(t, "CoverageEligibilityResponse", "name", element.getNameElement(), -1);
5569    if (element.hasDescriptionElement())
5570      composeString(t, "CoverageEligibilityResponse", "description", element.getDescriptionElement(), -1);
5571    if (element.hasNetwork())
5572      composeCodeableConcept(t, "CoverageEligibilityResponse", "network", element.getNetwork(), -1);
5573    if (element.hasUnit())
5574      composeCodeableConcept(t, "CoverageEligibilityResponse", "unit", element.getUnit(), -1);
5575    if (element.hasTerm())
5576      composeCodeableConcept(t, "CoverageEligibilityResponse", "term", element.getTerm(), -1);
5577    for (int i = 0; i < element.getBenefit().size(); i++)
5578      composeCoverageEligibilityResponseBenefitComponent(t, "CoverageEligibilityResponse", "benefit", element.getBenefit().get(i), i);
5579    if (element.hasAuthorizationRequiredElement())
5580      composeBoolean(t, "CoverageEligibilityResponse", "authorizationRequired", element.getAuthorizationRequiredElement(), -1);
5581    for (int i = 0; i < element.getAuthorizationSupporting().size(); i++)
5582      composeCodeableConcept(t, "CoverageEligibilityResponse", "authorizationSupporting", element.getAuthorizationSupporting().get(i), i);
5583    if (element.hasAuthorizationUrlElement())
5584      composeUri(t, "CoverageEligibilityResponse", "authorizationUrl", element.getAuthorizationUrlElement(), -1);
5585  }
5586
5587  protected void composeCoverageEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.BenefitComponent element, int index) {
5588    if (element == null) 
5589      return;
5590    Complex t;
5591    if (Utilities.noString(parentType))
5592      t = parent;
5593    else {
5594      t = parent.predicate("fhir:"+parentType+'.'+name);
5595    }
5596    composeBackboneElement(t, "benefit", name, element, index);
5597    if (element.hasType())
5598      composeCodeableConcept(t, "CoverageEligibilityResponse", "type", element.getType(), -1);
5599    if (element.hasAllowed())
5600      composeType(t, "CoverageEligibilityResponse", "allowed", element.getAllowed(), -1);
5601    if (element.hasUsed())
5602      composeType(t, "CoverageEligibilityResponse", "used", element.getUsed(), -1);
5603  }
5604
5605  protected void composeCoverageEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ErrorsComponent element, int index) {
5606    if (element == null) 
5607      return;
5608    Complex t;
5609    if (Utilities.noString(parentType))
5610      t = parent;
5611    else {
5612      t = parent.predicate("fhir:"+parentType+'.'+name);
5613    }
5614    composeBackboneElement(t, "error", name, element, index);
5615    if (element.hasCode())
5616      composeCodeableConcept(t, "CoverageEligibilityResponse", "code", element.getCode(), -1);
5617  }
5618
5619  protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) {
5620    if (element == null) 
5621      return;
5622    Complex t;
5623    if (Utilities.noString(parentType))
5624      t = parent;
5625    else {
5626      t = parent.predicate("fhir:"+parentType+'.'+name);
5627    }
5628    composeDomainResource(t, "DetectedIssue", name, element, index);
5629    for (int i = 0; i < element.getIdentifier().size(); i++)
5630      composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier().get(i), i);
5631    if (element.hasStatusElement())
5632      composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1);
5633    if (element.hasCode())
5634      composeCodeableConcept(t, "DetectedIssue", "code", element.getCode(), -1);
5635    if (element.hasSeverityElement())
5636      composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1);
5637    if (element.hasPatient())
5638      composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1);
5639    if (element.hasIdentified())
5640      composeType(t, "DetectedIssue", "identified", element.getIdentified(), -1);
5641    if (element.hasAuthor())
5642      composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1);
5643    for (int i = 0; i < element.getImplicated().size(); i++)
5644      composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i);
5645    for (int i = 0; i < element.getEvidence().size(); i++)
5646      composeDetectedIssueDetectedIssueEvidenceComponent(t, "DetectedIssue", "evidence", element.getEvidence().get(i), i);
5647    if (element.hasDetailElement())
5648      composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1);
5649    if (element.hasReferenceElement())
5650      composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1);
5651    for (int i = 0; i < element.getMitigation().size(); i++)
5652      composeDetectedIssueDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i);
5653  }
5654
5655  protected void composeDetectedIssueDetectedIssueEvidenceComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueEvidenceComponent element, int index) {
5656    if (element == null) 
5657      return;
5658    Complex t;
5659    if (Utilities.noString(parentType))
5660      t = parent;
5661    else {
5662      t = parent.predicate("fhir:"+parentType+'.'+name);
5663    }
5664    composeBackboneElement(t, "evidence", name, element, index);
5665    for (int i = 0; i < element.getCode().size(); i++)
5666      composeCodeableConcept(t, "DetectedIssue", "code", element.getCode().get(i), i);
5667    for (int i = 0; i < element.getDetail().size(); i++)
5668      composeReference(t, "DetectedIssue", "detail", element.getDetail().get(i), i);
5669  }
5670
5671  protected void composeDetectedIssueDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) {
5672    if (element == null) 
5673      return;
5674    Complex t;
5675    if (Utilities.noString(parentType))
5676      t = parent;
5677    else {
5678      t = parent.predicate("fhir:"+parentType+'.'+name);
5679    }
5680    composeBackboneElement(t, "mitigation", name, element, index);
5681    if (element.hasAction())
5682      composeCodeableConcept(t, "DetectedIssue", "action", element.getAction(), -1);
5683    if (element.hasDateElement())
5684      composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1);
5685    if (element.hasAuthor())
5686      composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1);
5687  }
5688
5689  protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) {
5690    if (element == null) 
5691      return;
5692    Complex t;
5693    if (Utilities.noString(parentType))
5694      t = parent;
5695    else {
5696      t = parent.predicate("fhir:"+parentType+'.'+name);
5697    }
5698    composeDomainResource(t, "Device", name, element, index);
5699    for (int i = 0; i < element.getIdentifier().size(); i++)
5700      composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i);
5701    if (element.hasDefinition())
5702      composeReference(t, "Device", "definition", element.getDefinition(), -1);
5703    for (int i = 0; i < element.getUdiCarrier().size(); i++)
5704      composeDeviceDeviceUdiCarrierComponent(t, "Device", "udiCarrier", element.getUdiCarrier().get(i), i);
5705    if (element.hasStatusElement())
5706      composeEnum(t, "Device", "status", element.getStatusElement(), -1);
5707    for (int i = 0; i < element.getStatusReason().size(); i++)
5708      composeCodeableConcept(t, "Device", "statusReason", element.getStatusReason().get(i), i);
5709    if (element.hasDistinctIdentifierElement())
5710      composeString(t, "Device", "distinctIdentifier", element.getDistinctIdentifierElement(), -1);
5711    if (element.hasManufacturerElement())
5712      composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1);
5713    if (element.hasManufactureDateElement())
5714      composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1);
5715    if (element.hasExpirationDateElement())
5716      composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1);
5717    if (element.hasLotNumberElement())
5718      composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1);
5719    if (element.hasSerialNumberElement())
5720      composeString(t, "Device", "serialNumber", element.getSerialNumberElement(), -1);
5721    for (int i = 0; i < element.getDeviceName().size(); i++)
5722      composeDeviceDeviceDeviceNameComponent(t, "Device", "deviceName", element.getDeviceName().get(i), i);
5723    if (element.hasModelNumberElement())
5724      composeString(t, "Device", "modelNumber", element.getModelNumberElement(), -1);
5725    if (element.hasPartNumberElement())
5726      composeString(t, "Device", "partNumber", element.getPartNumberElement(), -1);
5727    if (element.hasType())
5728      composeCodeableConcept(t, "Device", "type", element.getType(), -1);
5729    for (int i = 0; i < element.getSpecialization().size(); i++)
5730      composeDeviceDeviceSpecializationComponent(t, "Device", "specialization", element.getSpecialization().get(i), i);
5731    for (int i = 0; i < element.getVersion().size(); i++)
5732      composeDeviceDeviceVersionComponent(t, "Device", "version", element.getVersion().get(i), i);
5733    for (int i = 0; i < element.getProperty().size(); i++)
5734      composeDeviceDevicePropertyComponent(t, "Device", "property", element.getProperty().get(i), i);
5735    if (element.hasPatient())
5736      composeReference(t, "Device", "patient", element.getPatient(), -1);
5737    if (element.hasOwner())
5738      composeReference(t, "Device", "owner", element.getOwner(), -1);
5739    for (int i = 0; i < element.getContact().size(); i++)
5740      composeContactPoint(t, "Device", "contact", element.getContact().get(i), i);
5741    if (element.hasLocation())
5742      composeReference(t, "Device", "location", element.getLocation(), -1);
5743    if (element.hasUrlElement())
5744      composeUri(t, "Device", "url", element.getUrlElement(), -1);
5745    for (int i = 0; i < element.getNote().size(); i++)
5746      composeAnnotation(t, "Device", "note", element.getNote().get(i), i);
5747    for (int i = 0; i < element.getSafety().size(); i++)
5748      composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i);
5749    if (element.hasParent())
5750      composeReference(t, "Device", "parent", element.getParent(), -1);
5751  }
5752
5753  protected void composeDeviceDeviceUdiCarrierComponent(Complex parent, String parentType, String name, Device.DeviceUdiCarrierComponent element, int index) {
5754    if (element == null) 
5755      return;
5756    Complex t;
5757    if (Utilities.noString(parentType))
5758      t = parent;
5759    else {
5760      t = parent.predicate("fhir:"+parentType+'.'+name);
5761    }
5762    composeBackboneElement(t, "udiCarrier", name, element, index);
5763    if (element.hasDeviceIdentifierElement())
5764      composeString(t, "Device", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
5765    if (element.hasIssuerElement())
5766      composeUri(t, "Device", "issuer", element.getIssuerElement(), -1);
5767    if (element.hasJurisdictionElement())
5768      composeUri(t, "Device", "jurisdiction", element.getJurisdictionElement(), -1);
5769    if (element.hasCarrierAIDCElement())
5770      composeBase64Binary(t, "Device", "carrierAIDC", element.getCarrierAIDCElement(), -1);
5771    if (element.hasCarrierHRFElement())
5772      composeString(t, "Device", "carrierHRF", element.getCarrierHRFElement(), -1);
5773    if (element.hasEntryTypeElement())
5774      composeEnum(t, "Device", "entryType", element.getEntryTypeElement(), -1);
5775  }
5776
5777  protected void composeDeviceDeviceDeviceNameComponent(Complex parent, String parentType, String name, Device.DeviceDeviceNameComponent element, int index) {
5778    if (element == null) 
5779      return;
5780    Complex t;
5781    if (Utilities.noString(parentType))
5782      t = parent;
5783    else {
5784      t = parent.predicate("fhir:"+parentType+'.'+name);
5785    }
5786    composeBackboneElement(t, "deviceName", name, element, index);
5787    if (element.hasNameElement())
5788      composeString(t, "Device", "name", element.getNameElement(), -1);
5789    if (element.hasTypeElement())
5790      composeEnum(t, "Device", "type", element.getTypeElement(), -1);
5791  }
5792
5793  protected void composeDeviceDeviceSpecializationComponent(Complex parent, String parentType, String name, Device.DeviceSpecializationComponent element, int index) {
5794    if (element == null) 
5795      return;
5796    Complex t;
5797    if (Utilities.noString(parentType))
5798      t = parent;
5799    else {
5800      t = parent.predicate("fhir:"+parentType+'.'+name);
5801    }
5802    composeBackboneElement(t, "specialization", name, element, index);
5803    if (element.hasSystemType())
5804      composeCodeableConcept(t, "Device", "systemType", element.getSystemType(), -1);
5805    if (element.hasVersionElement())
5806      composeString(t, "Device", "version", element.getVersionElement(), -1);
5807  }
5808
5809  protected void composeDeviceDeviceVersionComponent(Complex parent, String parentType, String name, Device.DeviceVersionComponent element, int index) {
5810    if (element == null) 
5811      return;
5812    Complex t;
5813    if (Utilities.noString(parentType))
5814      t = parent;
5815    else {
5816      t = parent.predicate("fhir:"+parentType+'.'+name);
5817    }
5818    composeBackboneElement(t, "version", name, element, index);
5819    if (element.hasType())
5820      composeCodeableConcept(t, "Device", "type", element.getType(), -1);
5821    if (element.hasComponent())
5822      composeIdentifier(t, "Device", "component", element.getComponent(), -1);
5823    if (element.hasValueElement())
5824      composeString(t, "Device", "value", element.getValueElement(), -1);
5825  }
5826
5827  protected void composeDeviceDevicePropertyComponent(Complex parent, String parentType, String name, Device.DevicePropertyComponent element, int index) {
5828    if (element == null) 
5829      return;
5830    Complex t;
5831    if (Utilities.noString(parentType))
5832      t = parent;
5833    else {
5834      t = parent.predicate("fhir:"+parentType+'.'+name);
5835    }
5836    composeBackboneElement(t, "property", name, element, index);
5837    if (element.hasType())
5838      composeCodeableConcept(t, "Device", "type", element.getType(), -1);
5839    for (int i = 0; i < element.getValueQuantity().size(); i++)
5840      composeQuantity(t, "Device", "valueQuantity", element.getValueQuantity().get(i), i);
5841    for (int i = 0; i < element.getValueCode().size(); i++)
5842      composeCodeableConcept(t, "Device", "valueCode", element.getValueCode().get(i), i);
5843  }
5844
5845  protected void composeDeviceDefinition(Complex parent, String parentType, String name, DeviceDefinition element, int index) {
5846    if (element == null) 
5847      return;
5848    Complex t;
5849    if (Utilities.noString(parentType))
5850      t = parent;
5851    else {
5852      t = parent.predicate("fhir:"+parentType+'.'+name);
5853    }
5854    composeDomainResource(t, "DeviceDefinition", name, element, index);
5855    for (int i = 0; i < element.getIdentifier().size(); i++)
5856      composeIdentifier(t, "DeviceDefinition", "identifier", element.getIdentifier().get(i), i);
5857    for (int i = 0; i < element.getUdiDeviceIdentifier().size(); i++)
5858      composeDeviceDefinitionDeviceDefinitionUdiDeviceIdentifierComponent(t, "DeviceDefinition", "udiDeviceIdentifier", element.getUdiDeviceIdentifier().get(i), i);
5859    if (element.hasManufacturer())
5860      composeType(t, "DeviceDefinition", "manufacturer", element.getManufacturer(), -1);
5861    for (int i = 0; i < element.getDeviceName().size(); i++)
5862      composeDeviceDefinitionDeviceDefinitionDeviceNameComponent(t, "DeviceDefinition", "deviceName", element.getDeviceName().get(i), i);
5863    if (element.hasModelNumberElement())
5864      composeString(t, "DeviceDefinition", "modelNumber", element.getModelNumberElement(), -1);
5865    if (element.hasType())
5866      composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1);
5867    for (int i = 0; i < element.getSpecialization().size(); i++)
5868      composeDeviceDefinitionDeviceDefinitionSpecializationComponent(t, "DeviceDefinition", "specialization", element.getSpecialization().get(i), i);
5869    for (int i = 0; i < element.getVersion().size(); i++)
5870      composeString(t, "DeviceDefinition", "version", element.getVersion().get(i), i);
5871    for (int i = 0; i < element.getSafety().size(); i++)
5872      composeCodeableConcept(t, "DeviceDefinition", "safety", element.getSafety().get(i), i);
5873    for (int i = 0; i < element.getShelfLifeStorage().size(); i++)
5874      composeProductShelfLife(t, "DeviceDefinition", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i);
5875    if (element.hasPhysicalCharacteristics())
5876      composeProdCharacteristic(t, "DeviceDefinition", "physicalCharacteristics", element.getPhysicalCharacteristics(), -1);
5877    for (int i = 0; i < element.getLanguageCode().size(); i++)
5878      composeCodeableConcept(t, "DeviceDefinition", "languageCode", element.getLanguageCode().get(i), i);
5879    for (int i = 0; i < element.getCapability().size(); i++)
5880      composeDeviceDefinitionDeviceDefinitionCapabilityComponent(t, "DeviceDefinition", "capability", element.getCapability().get(i), i);
5881    for (int i = 0; i < element.getProperty().size(); i++)
5882      composeDeviceDefinitionDeviceDefinitionPropertyComponent(t, "DeviceDefinition", "property", element.getProperty().get(i), i);
5883    if (element.hasOwner())
5884      composeReference(t, "DeviceDefinition", "owner", element.getOwner(), -1);
5885    for (int i = 0; i < element.getContact().size(); i++)
5886      composeContactPoint(t, "DeviceDefinition", "contact", element.getContact().get(i), i);
5887    if (element.hasUrlElement())
5888      composeUri(t, "DeviceDefinition", "url", element.getUrlElement(), -1);
5889    if (element.hasOnlineInformationElement())
5890      composeUri(t, "DeviceDefinition", "onlineInformation", element.getOnlineInformationElement(), -1);
5891    for (int i = 0; i < element.getNote().size(); i++)
5892      composeAnnotation(t, "DeviceDefinition", "note", element.getNote().get(i), i);
5893    if (element.hasQuantity())
5894      composeQuantity(t, "DeviceDefinition", "quantity", element.getQuantity(), -1);
5895    if (element.hasParentDevice())
5896      composeReference(t, "DeviceDefinition", "parentDevice", element.getParentDevice(), -1);
5897    for (int i = 0; i < element.getMaterial().size(); i++)
5898      composeDeviceDefinitionDeviceDefinitionMaterialComponent(t, "DeviceDefinition", "material", element.getMaterial().get(i), i);
5899  }
5900
5901  protected void composeDeviceDefinitionDeviceDefinitionUdiDeviceIdentifierComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionUdiDeviceIdentifierComponent element, int index) {
5902    if (element == null) 
5903      return;
5904    Complex t;
5905    if (Utilities.noString(parentType))
5906      t = parent;
5907    else {
5908      t = parent.predicate("fhir:"+parentType+'.'+name);
5909    }
5910    composeBackboneElement(t, "udiDeviceIdentifier", name, element, index);
5911    if (element.hasDeviceIdentifierElement())
5912      composeString(t, "DeviceDefinition", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
5913    if (element.hasIssuerElement())
5914      composeUri(t, "DeviceDefinition", "issuer", element.getIssuerElement(), -1);
5915    if (element.hasJurisdictionElement())
5916      composeUri(t, "DeviceDefinition", "jurisdiction", element.getJurisdictionElement(), -1);
5917  }
5918
5919  protected void composeDeviceDefinitionDeviceDefinitionDeviceNameComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionDeviceNameComponent element, int index) {
5920    if (element == null) 
5921      return;
5922    Complex t;
5923    if (Utilities.noString(parentType))
5924      t = parent;
5925    else {
5926      t = parent.predicate("fhir:"+parentType+'.'+name);
5927    }
5928    composeBackboneElement(t, "deviceName", name, element, index);
5929    if (element.hasNameElement())
5930      composeString(t, "DeviceDefinition", "name", element.getNameElement(), -1);
5931    if (element.hasTypeElement())
5932      composeEnum(t, "DeviceDefinition", "type", element.getTypeElement(), -1);
5933  }
5934
5935  protected void composeDeviceDefinitionDeviceDefinitionSpecializationComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionSpecializationComponent element, int index) {
5936    if (element == null) 
5937      return;
5938    Complex t;
5939    if (Utilities.noString(parentType))
5940      t = parent;
5941    else {
5942      t = parent.predicate("fhir:"+parentType+'.'+name);
5943    }
5944    composeBackboneElement(t, "specialization", name, element, index);
5945    if (element.hasSystemTypeElement())
5946      composeString(t, "DeviceDefinition", "systemType", element.getSystemTypeElement(), -1);
5947    if (element.hasVersionElement())
5948      composeString(t, "DeviceDefinition", "version", element.getVersionElement(), -1);
5949  }
5950
5951  protected void composeDeviceDefinitionDeviceDefinitionCapabilityComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionCapabilityComponent element, int index) {
5952    if (element == null) 
5953      return;
5954    Complex t;
5955    if (Utilities.noString(parentType))
5956      t = parent;
5957    else {
5958      t = parent.predicate("fhir:"+parentType+'.'+name);
5959    }
5960    composeBackboneElement(t, "capability", name, element, index);
5961    if (element.hasType())
5962      composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1);
5963    for (int i = 0; i < element.getDescription().size(); i++)
5964      composeCodeableConcept(t, "DeviceDefinition", "description", element.getDescription().get(i), i);
5965  }
5966
5967  protected void composeDeviceDefinitionDeviceDefinitionPropertyComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionPropertyComponent element, int index) {
5968    if (element == null) 
5969      return;
5970    Complex t;
5971    if (Utilities.noString(parentType))
5972      t = parent;
5973    else {
5974      t = parent.predicate("fhir:"+parentType+'.'+name);
5975    }
5976    composeBackboneElement(t, "property", name, element, index);
5977    if (element.hasType())
5978      composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1);
5979    for (int i = 0; i < element.getValueQuantity().size(); i++)
5980      composeQuantity(t, "DeviceDefinition", "valueQuantity", element.getValueQuantity().get(i), i);
5981    for (int i = 0; i < element.getValueCode().size(); i++)
5982      composeCodeableConcept(t, "DeviceDefinition", "valueCode", element.getValueCode().get(i), i);
5983  }
5984
5985  protected void composeDeviceDefinitionDeviceDefinitionMaterialComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionMaterialComponent element, int index) {
5986    if (element == null) 
5987      return;
5988    Complex t;
5989    if (Utilities.noString(parentType))
5990      t = parent;
5991    else {
5992      t = parent.predicate("fhir:"+parentType+'.'+name);
5993    }
5994    composeBackboneElement(t, "material", name, element, index);
5995    if (element.hasSubstance())
5996      composeCodeableConcept(t, "DeviceDefinition", "substance", element.getSubstance(), -1);
5997    if (element.hasAlternateElement())
5998      composeBoolean(t, "DeviceDefinition", "alternate", element.getAlternateElement(), -1);
5999    if (element.hasAllergenicIndicatorElement())
6000      composeBoolean(t, "DeviceDefinition", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1);
6001  }
6002
6003  protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) {
6004    if (element == null) 
6005      return;
6006    Complex t;
6007    if (Utilities.noString(parentType))
6008      t = parent;
6009    else {
6010      t = parent.predicate("fhir:"+parentType+'.'+name);
6011    }
6012    composeDomainResource(t, "DeviceMetric", name, element, index);
6013    for (int i = 0; i < element.getIdentifier().size(); i++)
6014      composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier().get(i), i);
6015    if (element.hasType())
6016      composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1);
6017    if (element.hasUnit())
6018      composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1);
6019    if (element.hasSource())
6020      composeReference(t, "DeviceMetric", "source", element.getSource(), -1);
6021    if (element.hasParent())
6022      composeReference(t, "DeviceMetric", "parent", element.getParent(), -1);
6023    if (element.hasOperationalStatusElement())
6024      composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1);
6025    if (element.hasColorElement())
6026      composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1);
6027    if (element.hasCategoryElement())
6028      composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1);
6029    if (element.hasMeasurementPeriod())
6030      composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1);
6031    for (int i = 0; i < element.getCalibration().size(); i++)
6032      composeDeviceMetricDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i);
6033  }
6034
6035  protected void composeDeviceMetricDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) {
6036    if (element == null) 
6037      return;
6038    Complex t;
6039    if (Utilities.noString(parentType))
6040      t = parent;
6041    else {
6042      t = parent.predicate("fhir:"+parentType+'.'+name);
6043    }
6044    composeBackboneElement(t, "calibration", name, element, index);
6045    if (element.hasTypeElement())
6046      composeEnum(t, "DeviceMetric", "type", element.getTypeElement(), -1);
6047    if (element.hasStateElement())
6048      composeEnum(t, "DeviceMetric", "state", element.getStateElement(), -1);
6049    if (element.hasTimeElement())
6050      composeInstant(t, "DeviceMetric", "time", element.getTimeElement(), -1);
6051  }
6052
6053  protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest element, int index) {
6054    if (element == null) 
6055      return;
6056    Complex t;
6057    if (Utilities.noString(parentType))
6058      t = parent;
6059    else {
6060      t = parent.predicate("fhir:"+parentType+'.'+name);
6061    }
6062    composeDomainResource(t, "DeviceRequest", name, element, index);
6063    for (int i = 0; i < element.getIdentifier().size(); i++)
6064      composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i);
6065    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++)
6066      composeCanonical(t, "DeviceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
6067    for (int i = 0; i < element.getInstantiatesUri().size(); i++)
6068      composeUri(t, "DeviceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
6069    for (int i = 0; i < element.getBasedOn().size(); i++)
6070      composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i);
6071    for (int i = 0; i < element.getPriorRequest().size(); i++)
6072      composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i);
6073    if (element.hasGroupIdentifier())
6074      composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
6075    if (element.hasStatusElement())
6076      composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1);
6077    if (element.hasIntentElement())
6078      composeEnum(t, "DeviceRequest", "intent", element.getIntentElement(), -1);
6079    if (element.hasPriorityElement())
6080      composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1);
6081    if (element.hasCode())
6082      composeType(t, "DeviceRequest", "code", element.getCode(), -1);
6083    for (int i = 0; i < element.getParameter().size(); i++)
6084      composeDeviceRequestDeviceRequestParameterComponent(t, "DeviceRequest", "parameter", element.getParameter().get(i), i);
6085    if (element.hasSubject())
6086      composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1);
6087    if (element.hasEncounter())
6088      composeReference(t, "DeviceRequest", "encounter", element.getEncounter(), -1);
6089    if (element.hasOccurrence())
6090      composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1);
6091    if (element.hasAuthoredOnElement())
6092      composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1);
6093    if (element.hasRequester())
6094      composeReference(t, "DeviceRequest", "requester", element.getRequester(), -1);
6095    if (element.hasPerformerType())
6096      composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1);
6097    if (element.hasPerformer())
6098      composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1);
6099    for (int i = 0; i < element.getReasonCode().size(); i++)
6100      composeCodeableConcept(t, "DeviceRequest", "reasonCode", element.getReasonCode().get(i), i);
6101    for (int i = 0; i < element.getReasonReference().size(); i++)
6102      composeReference(t, "DeviceRequest", "reasonReference", element.getReasonReference().get(i), i);
6103    for (int i = 0; i < element.getInsurance().size(); i++)
6104      composeReference(t, "DeviceRequest", "insurance", element.getInsurance().get(i), i);
6105    for (int i = 0; i < element.getSupportingInfo().size(); i++)
6106      composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
6107    for (int i = 0; i < element.getNote().size(); i++)
6108      composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i);
6109    for (int i = 0; i < element.getRelevantHistory().size(); i++)
6110      composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i);
6111  }
6112
6113  protected void composeDeviceRequestDeviceRequestParameterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestParameterComponent element, int index) {
6114    if (element == null) 
6115      return;
6116    Complex t;
6117    if (Utilities.noString(parentType))
6118      t = parent;
6119    else {
6120      t = parent.predicate("fhir:"+parentType+'.'+name);
6121    }
6122    composeBackboneElement(t, "parameter", name, element, index);
6123    if (element.hasCode())
6124      composeCodeableConcept(t, "DeviceRequest", "code", element.getCode(), -1);
6125    if (element.hasValue())
6126      composeType(t, "DeviceRequest", "value", element.getValue(), -1);
6127  }
6128
6129  protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) {
6130    if (element == null) 
6131      return;
6132    Complex t;
6133    if (Utilities.noString(parentType))
6134      t = parent;
6135    else {
6136      t = parent.predicate("fhir:"+parentType+'.'+name);
6137    }
6138    composeDomainResource(t, "DeviceUseStatement", name, element, index);
6139    for (int i = 0; i < element.getIdentifier().size(); i++)
6140      composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i);
6141    for (int i = 0; i < element.getBasedOn().size(); i++)
6142      composeReference(t, "DeviceUseStatement", "basedOn", element.getBasedOn().get(i), i);
6143    if (element.hasStatusElement())
6144      composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1);
6145    if (element.hasSubject())
6146      composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1);
6147    for (int i = 0; i < element.getDerivedFrom().size(); i++)
6148      composeReference(t, "DeviceUseStatement", "derivedFrom", element.getDerivedFrom().get(i), i);
6149    if (element.hasTiming())
6150      composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1);
6151    if (element.hasRecordedOnElement())
6152      composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1);
6153    if (element.hasSource())
6154      composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1);
6155    if (element.hasDevice())
6156      composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1);
6157    for (int i = 0; i < element.getReasonCode().size(); i++)
6158      composeCodeableConcept(t, "DeviceUseStatement", "reasonCode", element.getReasonCode().get(i), i);
6159    for (int i = 0; i < element.getReasonReference().size(); i++)
6160      composeReference(t, "DeviceUseStatement", "reasonReference", element.getReasonReference().get(i), i);
6161    if (element.hasBodySite())
6162      composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1);
6163    for (int i = 0; i < element.getNote().size(); i++)
6164      composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i);
6165  }
6166
6167  protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) {
6168    if (element == null) 
6169      return;
6170    Complex t;
6171    if (Utilities.noString(parentType))
6172      t = parent;
6173    else {
6174      t = parent.predicate("fhir:"+parentType+'.'+name);
6175    }
6176    composeDomainResource(t, "DiagnosticReport", name, element, index);
6177    for (int i = 0; i < element.getIdentifier().size(); i++)
6178      composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i);
6179    for (int i = 0; i < element.getBasedOn().size(); i++)
6180      composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i);
6181    if (element.hasStatusElement())
6182      composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1);
6183    for (int i = 0; i < element.getCategory().size(); i++)
6184      composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory().get(i), i);
6185    if (element.hasCode())
6186      composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1);
6187    if (element.hasSubject())
6188      composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1);
6189    if (element.hasEncounter())
6190      composeReference(t, "DiagnosticReport", "encounter", element.getEncounter(), -1);
6191    if (element.hasEffective())
6192      composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1);
6193    if (element.hasIssuedElement())
6194      composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1);
6195    for (int i = 0; i < element.getPerformer().size(); i++)
6196      composeReference(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i);
6197    for (int i = 0; i < element.getResultsInterpreter().size(); i++)
6198      composeReference(t, "DiagnosticReport", "resultsInterpreter", element.getResultsInterpreter().get(i), i);
6199    for (int i = 0; i < element.getSpecimen().size(); i++)
6200      composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i);
6201    for (int i = 0; i < element.getResult().size(); i++)
6202      composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i);
6203    for (int i = 0; i < element.getImagingStudy().size(); i++)
6204      composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i);
6205    for (int i = 0; i < element.getMedia().size(); i++)
6206      composeDiagnosticReportDiagnosticReportMediaComponent(t, "DiagnosticReport", "media", element.getMedia().get(i), i);
6207    if (element.hasConclusionElement())
6208      composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1);
6209    for (int i = 0; i < element.getConclusionCode().size(); i++)
6210      composeCodeableConcept(t, "DiagnosticReport", "conclusionCode", element.getConclusionCode().get(i), i);
6211    for (int i = 0; i < element.getPresentedForm().size(); i++)
6212      composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i);
6213  }
6214
6215  protected void composeDiagnosticReportDiagnosticReportMediaComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportMediaComponent 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, "media", name, element, index);
6225    if (element.hasCommentElement())
6226      composeString(t, "DiagnosticReport", "comment", element.getCommentElement(), -1);
6227    if (element.hasLink())
6228      composeReference(t, "DiagnosticReport", "link", element.getLink(), -1);
6229  }
6230
6231  protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) {
6232    if (element == null) 
6233      return;
6234    Complex t;
6235    if (Utilities.noString(parentType))
6236      t = parent;
6237    else {
6238      t = parent.predicate("fhir:"+parentType+'.'+name);
6239    }
6240    composeDomainResource(t, "DocumentManifest", name, element, index);
6241    if (element.hasMasterIdentifier())
6242      composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1);
6243    for (int i = 0; i < element.getIdentifier().size(); i++)
6244      composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i);
6245    if (element.hasStatusElement())
6246      composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1);
6247    if (element.hasType())
6248      composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1);
6249    if (element.hasSubject())
6250      composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1);
6251    if (element.hasCreatedElement())
6252      composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1);
6253    for (int i = 0; i < element.getAuthor().size(); i++)
6254      composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i);
6255    for (int i = 0; i < element.getRecipient().size(); i++)
6256      composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i);
6257    if (element.hasSourceElement())
6258      composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1);
6259    if (element.hasDescriptionElement())
6260      composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1);
6261    for (int i = 0; i < element.getContent().size(); i++)
6262      composeReference(t, "DocumentManifest", "content", element.getContent().get(i), i);
6263    for (int i = 0; i < element.getRelated().size(); i++)
6264      composeDocumentManifestDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i);
6265  }
6266
6267  protected void composeDocumentManifestDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) {
6268    if (element == null) 
6269      return;
6270    Complex t;
6271    if (Utilities.noString(parentType))
6272      t = parent;
6273    else {
6274      t = parent.predicate("fhir:"+parentType+'.'+name);
6275    }
6276    composeBackboneElement(t, "related", name, element, index);
6277    if (element.hasIdentifier())
6278      composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier(), -1);
6279    if (element.hasRef())
6280      composeReference(t, "DocumentManifest", "ref", element.getRef(), -1);
6281  }
6282
6283  protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) {
6284    if (element == null) 
6285      return;
6286    Complex t;
6287    if (Utilities.noString(parentType))
6288      t = parent;
6289    else {
6290      t = parent.predicate("fhir:"+parentType+'.'+name);
6291    }
6292    composeDomainResource(t, "DocumentReference", name, element, index);
6293    if (element.hasMasterIdentifier())
6294      composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1);
6295    for (int i = 0; i < element.getIdentifier().size(); i++)
6296      composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i);
6297    if (element.hasStatusElement())
6298      composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1);
6299    if (element.hasDocStatusElement())
6300      composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1);
6301    if (element.hasType())
6302      composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1);
6303    for (int i = 0; i < element.getCategory().size(); i++)
6304      composeCodeableConcept(t, "DocumentReference", "category", element.getCategory().get(i), i);
6305    if (element.hasSubject())
6306      composeReference(t, "DocumentReference", "subject", element.getSubject(), -1);
6307    if (element.hasDateElement())
6308      composeInstant(t, "DocumentReference", "date", element.getDateElement(), -1);
6309    for (int i = 0; i < element.getAuthor().size(); i++)
6310      composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i);
6311    if (element.hasAuthenticator())
6312      composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1);
6313    if (element.hasCustodian())
6314      composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1);
6315    for (int i = 0; i < element.getRelatesTo().size(); i++)
6316      composeDocumentReferenceDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i);
6317    if (element.hasDescriptionElement())
6318      composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1);
6319    for (int i = 0; i < element.getSecurityLabel().size(); i++)
6320      composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i);
6321    for (int i = 0; i < element.getContent().size(); i++)
6322      composeDocumentReferenceDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i);
6323    if (element.hasContext())
6324      composeDocumentReferenceDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1);
6325  }
6326
6327  protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) {
6328    if (element == null) 
6329      return;
6330    Complex t;
6331    if (Utilities.noString(parentType))
6332      t = parent;
6333    else {
6334      t = parent.predicate("fhir:"+parentType+'.'+name);
6335    }
6336    composeBackboneElement(t, "relatesTo", name, element, index);
6337    if (element.hasCodeElement())
6338      composeEnum(t, "DocumentReference", "code", element.getCodeElement(), -1);
6339    if (element.hasTarget())
6340      composeReference(t, "DocumentReference", "target", element.getTarget(), -1);
6341  }
6342
6343  protected void composeDocumentReferenceDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) {
6344    if (element == null) 
6345      return;
6346    Complex t;
6347    if (Utilities.noString(parentType))
6348      t = parent;
6349    else {
6350      t = parent.predicate("fhir:"+parentType+'.'+name);
6351    }
6352    composeBackboneElement(t, "content", name, element, index);
6353    if (element.hasAttachment())
6354      composeAttachment(t, "DocumentReference", "attachment", element.getAttachment(), -1);
6355    if (element.hasFormat())
6356      composeCoding(t, "DocumentReference", "format", element.getFormat(), -1);
6357  }
6358
6359  protected void composeDocumentReferenceDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) {
6360    if (element == null) 
6361      return;
6362    Complex t;
6363    if (Utilities.noString(parentType))
6364      t = parent;
6365    else {
6366      t = parent.predicate("fhir:"+parentType+'.'+name);
6367    }
6368    composeBackboneElement(t, "context", name, element, index);
6369    for (int i = 0; i < element.getEncounter().size(); i++)
6370      composeReference(t, "DocumentReference", "encounter", element.getEncounter().get(i), i);
6371    for (int i = 0; i < element.getEvent().size(); i++)
6372      composeCodeableConcept(t, "DocumentReference", "event", element.getEvent().get(i), i);
6373    if (element.hasPeriod())
6374      composePeriod(t, "DocumentReference", "period", element.getPeriod(), -1);
6375    if (element.hasFacilityType())
6376      composeCodeableConcept(t, "DocumentReference", "facilityType", element.getFacilityType(), -1);
6377    if (element.hasPracticeSetting())
6378      composeCodeableConcept(t, "DocumentReference", "practiceSetting", element.getPracticeSetting(), -1);
6379    if (element.hasSourcePatientInfo())
6380      composeReference(t, "DocumentReference", "sourcePatientInfo", element.getSourcePatientInfo(), -1);
6381    for (int i = 0; i < element.getRelated().size(); i++)
6382      composeReference(t, "DocumentReference", "related", element.getRelated().get(i), i);
6383  }
6384
6385  protected void composeEffectEvidenceSynthesis(Complex parent, String parentType, String name, EffectEvidenceSynthesis 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    composeDomainResource(t, "EffectEvidenceSynthesis", name, element, index);
6395    if (element.hasUrlElement())
6396      composeUri(t, "EffectEvidenceSynthesis", "url", element.getUrlElement(), -1);
6397    for (int i = 0; i < element.getIdentifier().size(); i++)
6398      composeIdentifier(t, "EffectEvidenceSynthesis", "identifier", element.getIdentifier().get(i), i);
6399    if (element.hasVersionElement())
6400      composeString(t, "EffectEvidenceSynthesis", "version", element.getVersionElement(), -1);
6401    if (element.hasNameElement())
6402      composeString(t, "EffectEvidenceSynthesis", "name", element.getNameElement(), -1);
6403    if (element.hasTitleElement())
6404      composeString(t, "EffectEvidenceSynthesis", "title", element.getTitleElement(), -1);
6405    if (element.hasStatusElement())
6406      composeEnum(t, "EffectEvidenceSynthesis", "status", element.getStatusElement(), -1);
6407    if (element.hasDateElement())
6408      composeDateTime(t, "EffectEvidenceSynthesis", "date", element.getDateElement(), -1);
6409    if (element.hasPublisherElement())
6410      composeString(t, "EffectEvidenceSynthesis", "publisher", element.getPublisherElement(), -1);
6411    for (int i = 0; i < element.getContact().size(); i++)
6412      composeContactDetail(t, "EffectEvidenceSynthesis", "contact", element.getContact().get(i), i);
6413    if (element.hasDescriptionElement())
6414      composeMarkdown(t, "EffectEvidenceSynthesis", "description", element.getDescriptionElement(), -1);
6415    for (int i = 0; i < element.getNote().size(); i++)
6416      composeAnnotation(t, "EffectEvidenceSynthesis", "note", element.getNote().get(i), i);
6417    for (int i = 0; i < element.getUseContext().size(); i++)
6418      composeUsageContext(t, "EffectEvidenceSynthesis", "useContext", element.getUseContext().get(i), i);
6419    for (int i = 0; i < element.getJurisdiction().size(); i++)
6420      composeCodeableConcept(t, "EffectEvidenceSynthesis", "jurisdiction", element.getJurisdiction().get(i), i);
6421    if (element.hasCopyrightElement())
6422      composeMarkdown(t, "EffectEvidenceSynthesis", "copyright", element.getCopyrightElement(), -1);
6423    if (element.hasApprovalDateElement())
6424      composeDate(t, "EffectEvidenceSynthesis", "approvalDate", element.getApprovalDateElement(), -1);
6425    if (element.hasLastReviewDateElement())
6426      composeDate(t, "EffectEvidenceSynthesis", "lastReviewDate", element.getLastReviewDateElement(), -1);
6427    if (element.hasEffectivePeriod())
6428      composePeriod(t, "EffectEvidenceSynthesis", "effectivePeriod", element.getEffectivePeriod(), -1);
6429    for (int i = 0; i < element.getTopic().size(); i++)
6430      composeCodeableConcept(t, "EffectEvidenceSynthesis", "topic", element.getTopic().get(i), i);
6431    for (int i = 0; i < element.getAuthor().size(); i++)
6432      composeContactDetail(t, "EffectEvidenceSynthesis", "author", element.getAuthor().get(i), i);
6433    for (int i = 0; i < element.getEditor().size(); i++)
6434      composeContactDetail(t, "EffectEvidenceSynthesis", "editor", element.getEditor().get(i), i);
6435    for (int i = 0; i < element.getReviewer().size(); i++)
6436      composeContactDetail(t, "EffectEvidenceSynthesis", "reviewer", element.getReviewer().get(i), i);
6437    for (int i = 0; i < element.getEndorser().size(); i++)
6438      composeContactDetail(t, "EffectEvidenceSynthesis", "endorser", element.getEndorser().get(i), i);
6439    for (int i = 0; i < element.getRelatedArtifact().size(); i++)
6440      composeRelatedArtifact(t, "EffectEvidenceSynthesis", "relatedArtifact", element.getRelatedArtifact().get(i), i);
6441    if (element.hasSynthesisType())
6442      composeCodeableConcept(t, "EffectEvidenceSynthesis", "synthesisType", element.getSynthesisType(), -1);
6443    if (element.hasStudyType())
6444      composeCodeableConcept(t, "EffectEvidenceSynthesis", "studyType", element.getStudyType(), -1);
6445    if (element.hasPopulation())
6446      composeReference(t, "EffectEvidenceSynthesis", "population", element.getPopulation(), -1);
6447    if (element.hasExposure())
6448      composeReference(t, "EffectEvidenceSynthesis", "exposure", element.getExposure(), -1);
6449    if (element.hasExposureAlternative())
6450      composeReference(t, "EffectEvidenceSynthesis", "exposureAlternative", element.getExposureAlternative(), -1);
6451    if (element.hasOutcome())
6452      composeReference(t, "EffectEvidenceSynthesis", "outcome", element.getOutcome(), -1);
6453    if (element.hasSampleSize())
6454      composeEffectEvidenceSynthesisEffectEvidenceSynthesisSampleSizeComponent(t, "EffectEvidenceSynthesis", "sampleSize", element.getSampleSize(), -1);
6455    for (int i = 0; i < element.getResultsByExposure().size(); i++)
6456      composeEffectEvidenceSynthesisEffectEvidenceSynthesisResultsByExposureComponent(t, "EffectEvidenceSynthesis", "resultsByExposure", element.getResultsByExposure().get(i), i);
6457    for (int i = 0; i < element.getEffectEstimate().size(); i++)
6458      composeEffectEvidenceSynthesisEffectEvidenceSynthesisEffectEstimateComponent(t, "EffectEvidenceSynthesis", "effectEstimate", element.getEffectEstimate().get(i), i);
6459    for (int i = 0; i < element.getCertainty().size(); i++)
6460      composeEffectEvidenceSynthesisEffectEvidenceSynthesisCertaintyComponent(t, "EffectEvidenceSynthesis", "certainty", element.getCertainty().get(i), i);
6461  }
6462
6463  protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisSampleSizeComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisSampleSizeComponent element, int index) {
6464    if (element == null) 
6465      return;
6466    Complex t;
6467    if (Utilities.noString(parentType))
6468      t = parent;
6469    else {
6470      t = parent.predicate("fhir:"+parentType+'.'+name);
6471    }
6472    composeBackboneElement(t, "sampleSize", name, element, index);
6473    if (element.hasDescriptionElement())
6474      composeString(t, "EffectEvidenceSynthesis", "description", element.getDescriptionElement(), -1);
6475    if (element.hasNumberOfStudiesElement())
6476      composeInteger(t, "EffectEvidenceSynthesis", "numberOfStudies", element.getNumberOfStudiesElement(), -1);
6477    if (element.hasNumberOfParticipantsElement())
6478      composeInteger(t, "EffectEvidenceSynthesis", "numberOfParticipants", element.getNumberOfParticipantsElement(), -1);
6479  }
6480
6481  protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisResultsByExposureComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisResultsByExposureComponent element, int index) {
6482    if (element == null) 
6483      return;
6484    Complex t;
6485    if (Utilities.noString(parentType))
6486      t = parent;
6487    else {
6488      t = parent.predicate("fhir:"+parentType+'.'+name);
6489    }
6490    composeBackboneElement(t, "resultsByExposure", name, element, index);
6491    if (element.hasDescriptionElement())
6492      composeString(t, "EffectEvidenceSynthesis", "description", element.getDescriptionElement(), -1);
6493    if (element.hasExposureStateElement())
6494      composeEnum(t, "EffectEvidenceSynthesis", "exposureState", element.getExposureStateElement(), -1);
6495    if (element.hasVariantState())
6496      composeCodeableConcept(t, "EffectEvidenceSynthesis", "variantState", element.getVariantState(), -1);
6497    if (element.hasRiskEvidenceSynthesis())
6498      composeReference(t, "EffectEvidenceSynthesis", "riskEvidenceSynthesis", element.getRiskEvidenceSynthesis(), -1);
6499  }
6500
6501  protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisEffectEstimateComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisEffectEstimateComponent element, int index) {
6502    if (element == null) 
6503      return;
6504    Complex t;
6505    if (Utilities.noString(parentType))
6506      t = parent;
6507    else {
6508      t = parent.predicate("fhir:"+parentType+'.'+name);
6509    }
6510    composeBackboneElement(t, "effectEstimate", name, element, index);
6511    if (element.hasDescriptionElement())
6512      composeString(t, "EffectEvidenceSynthesis", "description", element.getDescriptionElement(), -1);
6513    if (element.hasType())
6514      composeCodeableConcept(t, "EffectEvidenceSynthesis", "type", element.getType(), -1);
6515    if (element.hasVariantState())
6516      composeCodeableConcept(t, "EffectEvidenceSynthesis", "variantState", element.getVariantState(), -1);
6517    if (element.hasValueElement())
6518      composeDecimal(t, "EffectEvidenceSynthesis", "value", element.getValueElement(), -1);
6519    if (element.hasUnitOfMeasure())
6520      composeCodeableConcept(t, "EffectEvidenceSynthesis", "unitOfMeasure", element.getUnitOfMeasure(), -1);
6521    for (int i = 0; i < element.getPrecisionEstimate().size(); i++)
6522      composeEffectEvidenceSynthesisEffectEvidenceSynthesisEffectEstimatePrecisionEstimateComponent(t, "EffectEvidenceSynthesis", "precisionEstimate", element.getPrecisionEstimate().get(i), i);
6523  }
6524
6525  protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisEffectEstimatePrecisionEstimateComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisEffectEstimatePrecisionEstimateComponent element, int index) {
6526    if (element == null) 
6527      return;
6528    Complex t;
6529    if (Utilities.noString(parentType))
6530      t = parent;
6531    else {
6532      t = parent.predicate("fhir:"+parentType+'.'+name);
6533    }
6534    composeBackboneElement(t, "precisionEstimate", name, element, index);
6535    if (element.hasType())
6536      composeCodeableConcept(t, "EffectEvidenceSynthesis", "type", element.getType(), -1);
6537    if (element.hasLevelElement())
6538      composeDecimal(t, "EffectEvidenceSynthesis", "level", element.getLevelElement(), -1);
6539    if (element.hasFromElement())
6540      composeDecimal(t, "EffectEvidenceSynthesis", "from", element.getFromElement(), -1);
6541    if (element.hasToElement())
6542      composeDecimal(t, "EffectEvidenceSynthesis", "to", element.getToElement(), -1);
6543  }
6544
6545  protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisCertaintyComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisCertaintyComponent element, int index) {
6546    if (element == null) 
6547      return;
6548    Complex t;
6549    if (Utilities.noString(parentType))
6550      t = parent;
6551    else {
6552      t = parent.predicate("fhir:"+parentType+'.'+name);
6553    }
6554    composeBackboneElement(t, "certainty", name, element, index);
6555    for (int i = 0; i < element.getRating().size(); i++)
6556      composeCodeableConcept(t, "EffectEvidenceSynthesis", "rating", element.getRating().get(i), i);
6557    for (int i = 0; i < element.getNote().size(); i++)
6558      composeAnnotation(t, "EffectEvidenceSynthesis", "note", element.getNote().get(i), i);
6559    for (int i = 0; i < element.getCertaintySubcomponent().size(); i++)
6560      composeEffectEvidenceSynthesisEffectEvidenceSynthesisCertaintyCertaintySubcomponentComponent(t, "EffectEvidenceSynthesis", "certaintySubcomponent", element.getCertaintySubcomponent().get(i), i);
6561  }
6562
6563  protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisCertaintyCertaintySubcomponentComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisCertaintyCertaintySubcomponentComponent element, int index) {
6564    if (element == null) 
6565      return;
6566    Complex t;
6567    if (Utilities.noString(parentType))
6568      t = parent;
6569    else {
6570      t = parent.predicate("fhir:"+parentType+'.'+name);
6571    }
6572    composeBackboneElement(t, "certaintySubcomponent", name, element, index);
6573    if (element.hasType())
6574      composeCodeableConcept(t, "EffectEvidenceSynthesis", "type", element.getType(), -1);
6575    for (int i = 0; i < element.getRating().size(); i++)
6576      composeCodeableConcept(t, "EffectEvidenceSynthesis", "rating", element.getRating().get(i), i);
6577    for (int i = 0; i < element.getNote().size(); i++)
6578      composeAnnotation(t, "EffectEvidenceSynthesis", "note", element.getNote().get(i), i);
6579  }
6580
6581  protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) {
6582    if (element == null) 
6583      return;
6584    Complex t;
6585    if (Utilities.noString(parentType))
6586      t = parent;
6587    else {
6588      t = parent.predicate("fhir:"+parentType+'.'+name);
6589    }
6590    composeDomainResource(t, "Encounter", name, element, index);
6591    for (int i = 0; i < element.getIdentifier().size(); i++)
6592      composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i);
6593    if (element.hasStatusElement())
6594      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
6595    for (int i = 0; i < element.getStatusHistory().size(); i++)
6596      composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i);
6597    if (element.hasClass_())
6598      composeCoding(t, "Encounter", "class", element.getClass_(), -1);
6599    for (int i = 0; i < element.getClassHistory().size(); i++)
6600      composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i);
6601    for (int i = 0; i < element.getType().size(); i++)
6602      composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i);
6603    if (element.hasServiceType())
6604      composeCodeableConcept(t, "Encounter", "serviceType", element.getServiceType(), -1);
6605    if (element.hasPriority())
6606      composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1);
6607    if (element.hasSubject())
6608      composeReference(t, "Encounter", "subject", element.getSubject(), -1);
6609    for (int i = 0; i < element.getEpisodeOfCare().size(); i++)
6610      composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i);
6611    for (int i = 0; i < element.getBasedOn().size(); i++)
6612      composeReference(t, "Encounter", "basedOn", element.getBasedOn().get(i), i);
6613    for (int i = 0; i < element.getParticipant().size(); i++)
6614      composeEncounterEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i);
6615    for (int i = 0; i < element.getAppointment().size(); i++)
6616      composeReference(t, "Encounter", "appointment", element.getAppointment().get(i), i);
6617    if (element.hasPeriod())
6618      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
6619    if (element.hasLength())
6620      composeDuration(t, "Encounter", "length", element.getLength(), -1);
6621    for (int i = 0; i < element.getReasonCode().size(); i++)
6622      composeCodeableConcept(t, "Encounter", "reasonCode", element.getReasonCode().get(i), i);
6623    for (int i = 0; i < element.getReasonReference().size(); i++)
6624      composeReference(t, "Encounter", "reasonReference", element.getReasonReference().get(i), i);
6625    for (int i = 0; i < element.getDiagnosis().size(); i++)
6626      composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i);
6627    for (int i = 0; i < element.getAccount().size(); i++)
6628      composeReference(t, "Encounter", "account", element.getAccount().get(i), i);
6629    if (element.hasHospitalization())
6630      composeEncounterEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1);
6631    for (int i = 0; i < element.getLocation().size(); i++)
6632      composeEncounterEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i);
6633    if (element.hasServiceProvider())
6634      composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1);
6635    if (element.hasPartOf())
6636      composeReference(t, "Encounter", "partOf", element.getPartOf(), -1);
6637  }
6638
6639  protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent element, int index) {
6640    if (element == null) 
6641      return;
6642    Complex t;
6643    if (Utilities.noString(parentType))
6644      t = parent;
6645    else {
6646      t = parent.predicate("fhir:"+parentType+'.'+name);
6647    }
6648    composeBackboneElement(t, "statusHistory", name, element, index);
6649    if (element.hasStatusElement())
6650      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
6651    if (element.hasPeriod())
6652      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
6653  }
6654
6655  protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent element, int index) {
6656    if (element == null) 
6657      return;
6658    Complex t;
6659    if (Utilities.noString(parentType))
6660      t = parent;
6661    else {
6662      t = parent.predicate("fhir:"+parentType+'.'+name);
6663    }
6664    composeBackboneElement(t, "classHistory", name, element, index);
6665    if (element.hasClass_())
6666      composeCoding(t, "Encounter", "class", element.getClass_(), -1);
6667    if (element.hasPeriod())
6668      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
6669  }
6670
6671  protected void composeEncounterEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) {
6672    if (element == null) 
6673      return;
6674    Complex t;
6675    if (Utilities.noString(parentType))
6676      t = parent;
6677    else {
6678      t = parent.predicate("fhir:"+parentType+'.'+name);
6679    }
6680    composeBackboneElement(t, "participant", name, element, index);
6681    for (int i = 0; i < element.getType().size(); i++)
6682      composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i);
6683    if (element.hasPeriod())
6684      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
6685    if (element.hasIndividual())
6686      composeReference(t, "Encounter", "individual", element.getIndividual(), -1);
6687  }
6688
6689  protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) {
6690    if (element == null) 
6691      return;
6692    Complex t;
6693    if (Utilities.noString(parentType))
6694      t = parent;
6695    else {
6696      t = parent.predicate("fhir:"+parentType+'.'+name);
6697    }
6698    composeBackboneElement(t, "diagnosis", name, element, index);
6699    if (element.hasCondition())
6700      composeReference(t, "Encounter", "condition", element.getCondition(), -1);
6701    if (element.hasUse())
6702      composeCodeableConcept(t, "Encounter", "use", element.getUse(), -1);
6703    if (element.hasRankElement())
6704      composePositiveInt(t, "Encounter", "rank", element.getRankElement(), -1);
6705  }
6706
6707  protected void composeEncounterEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) {
6708    if (element == null) 
6709      return;
6710    Complex t;
6711    if (Utilities.noString(parentType))
6712      t = parent;
6713    else {
6714      t = parent.predicate("fhir:"+parentType+'.'+name);
6715    }
6716    composeBackboneElement(t, "hospitalization", name, element, index);
6717    if (element.hasPreAdmissionIdentifier())
6718      composeIdentifier(t, "Encounter", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1);
6719    if (element.hasOrigin())
6720      composeReference(t, "Encounter", "origin", element.getOrigin(), -1);
6721    if (element.hasAdmitSource())
6722      composeCodeableConcept(t, "Encounter", "admitSource", element.getAdmitSource(), -1);
6723    if (element.hasReAdmission())
6724      composeCodeableConcept(t, "Encounter", "reAdmission", element.getReAdmission(), -1);
6725    for (int i = 0; i < element.getDietPreference().size(); i++)
6726      composeCodeableConcept(t, "Encounter", "dietPreference", element.getDietPreference().get(i), i);
6727    for (int i = 0; i < element.getSpecialCourtesy().size(); i++)
6728      composeCodeableConcept(t, "Encounter", "specialCourtesy", element.getSpecialCourtesy().get(i), i);
6729    for (int i = 0; i < element.getSpecialArrangement().size(); i++)
6730      composeCodeableConcept(t, "Encounter", "specialArrangement", element.getSpecialArrangement().get(i), i);
6731    if (element.hasDestination())
6732      composeReference(t, "Encounter", "destination", element.getDestination(), -1);
6733    if (element.hasDischargeDisposition())
6734      composeCodeableConcept(t, "Encounter", "dischargeDisposition", element.getDischargeDisposition(), -1);
6735  }
6736
6737  protected void composeEncounterEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) {
6738    if (element == null) 
6739      return;
6740    Complex t;
6741    if (Utilities.noString(parentType))
6742      t = parent;
6743    else {
6744      t = parent.predicate("fhir:"+parentType+'.'+name);
6745    }
6746    composeBackboneElement(t, "location", name, element, index);
6747    if (element.hasLocation())
6748      composeReference(t, "Encounter", "location", element.getLocation(), -1);
6749    if (element.hasStatusElement())
6750      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
6751    if (element.hasPhysicalType())
6752      composeCodeableConcept(t, "Encounter", "physicalType", element.getPhysicalType(), -1);
6753    if (element.hasPeriod())
6754      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
6755  }
6756
6757  protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) {
6758    if (element == null) 
6759      return;
6760    Complex t;
6761    if (Utilities.noString(parentType))
6762      t = parent;
6763    else {
6764      t = parent.predicate("fhir:"+parentType+'.'+name);
6765    }
6766    composeDomainResource(t, "Endpoint", name, element, index);
6767    for (int i = 0; i < element.getIdentifier().size(); i++)
6768      composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i);
6769    if (element.hasStatusElement())
6770      composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1);
6771    if (element.hasConnectionType())
6772      composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1);
6773    if (element.hasNameElement())
6774      composeString(t, "Endpoint", "name", element.getNameElement(), -1);
6775    if (element.hasManagingOrganization())
6776      composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1);
6777    for (int i = 0; i < element.getContact().size(); i++)
6778      composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i);
6779    if (element.hasPeriod())
6780      composePeriod(t, "Endpoint", "period", element.getPeriod(), -1);
6781    for (int i = 0; i < element.getPayloadType().size(); i++)
6782      composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i);
6783    for (int i = 0; i < element.getPayloadMimeType().size(); i++)
6784      composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i);
6785    if (element.hasAddressElement())
6786      composeUrl(t, "Endpoint", "address", element.getAddressElement(), -1);
6787    for (int i = 0; i < element.getHeader().size(); i++)
6788      composeString(t, "Endpoint", "header", element.getHeader().get(i), i);
6789  }
6790
6791  protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) {
6792    if (element == null) 
6793      return;
6794    Complex t;
6795    if (Utilities.noString(parentType))
6796      t = parent;
6797    else {
6798      t = parent.predicate("fhir:"+parentType+'.'+name);
6799    }
6800    composeDomainResource(t, "EnrollmentRequest", name, element, index);
6801    for (int i = 0; i < element.getIdentifier().size(); i++)
6802      composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i);
6803    if (element.hasStatusElement())
6804      composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1);
6805    if (element.hasCreatedElement())
6806      composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1);
6807    if (element.hasInsurer())
6808      composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1);
6809    if (element.hasProvider())
6810      composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1);
6811    if (element.hasCandidate())
6812      composeReference(t, "EnrollmentRequest", "candidate", element.getCandidate(), -1);
6813    if (element.hasCoverage())
6814      composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1);
6815  }
6816
6817  protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) {
6818    if (element == null) 
6819      return;
6820    Complex t;
6821    if (Utilities.noString(parentType))
6822      t = parent;
6823    else {
6824      t = parent.predicate("fhir:"+parentType+'.'+name);
6825    }
6826    composeDomainResource(t, "EnrollmentResponse", name, element, index);
6827    for (int i = 0; i < element.getIdentifier().size(); i++)
6828      composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i);
6829    if (element.hasStatusElement())
6830      composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1);
6831    if (element.hasRequest())
6832      composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1);
6833    if (element.hasOutcomeElement())
6834      composeEnum(t, "EnrollmentResponse", "outcome", element.getOutcomeElement(), -1);
6835    if (element.hasDispositionElement())
6836      composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1);
6837    if (element.hasCreatedElement())
6838      composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1);
6839    if (element.hasOrganization())
6840      composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1);
6841    if (element.hasRequestProvider())
6842      composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1);
6843  }
6844
6845  protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) {
6846    if (element == null) 
6847      return;
6848    Complex t;
6849    if (Utilities.noString(parentType))
6850      t = parent;
6851    else {
6852      t = parent.predicate("fhir:"+parentType+'.'+name);
6853    }
6854    composeDomainResource(t, "EpisodeOfCare", name, element, index);
6855    for (int i = 0; i < element.getIdentifier().size(); i++)
6856      composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i);
6857    if (element.hasStatusElement())
6858      composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1);
6859    for (int i = 0; i < element.getStatusHistory().size(); i++)
6860      composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i);
6861    for (int i = 0; i < element.getType().size(); i++)
6862      composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i);
6863    for (int i = 0; i < element.getDiagnosis().size(); i++)
6864      composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i);
6865    if (element.hasPatient())
6866      composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1);
6867    if (element.hasManagingOrganization())
6868      composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1);
6869    if (element.hasPeriod())
6870      composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1);
6871    for (int i = 0; i < element.getReferralRequest().size(); i++)
6872      composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i);
6873    if (element.hasCareManager())
6874      composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1);
6875    for (int i = 0; i < element.getTeam().size(); i++)
6876      composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i);
6877    for (int i = 0; i < element.getAccount().size(); i++)
6878      composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i);
6879  }
6880
6881  protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) {
6882    if (element == null) 
6883      return;
6884    Complex t;
6885    if (Utilities.noString(parentType))
6886      t = parent;
6887    else {
6888      t = parent.predicate("fhir:"+parentType+'.'+name);
6889    }
6890    composeBackboneElement(t, "statusHistory", name, element, index);
6891    if (element.hasStatusElement())
6892      composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1);
6893    if (element.hasPeriod())
6894      composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1);
6895  }
6896
6897  protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) {
6898    if (element == null) 
6899      return;
6900    Complex t;
6901    if (Utilities.noString(parentType))
6902      t = parent;
6903    else {
6904      t = parent.predicate("fhir:"+parentType+'.'+name);
6905    }
6906    composeBackboneElement(t, "diagnosis", name, element, index);
6907    if (element.hasCondition())
6908      composeReference(t, "EpisodeOfCare", "condition", element.getCondition(), -1);
6909    if (element.hasRole())
6910      composeCodeableConcept(t, "EpisodeOfCare", "role", element.getRole(), -1);
6911    if (element.hasRankElement())
6912      composePositiveInt(t, "EpisodeOfCare", "rank", element.getRankElement(), -1);
6913  }
6914
6915  protected void composeEventDefinition(Complex parent, String parentType, String name, EventDefinition element, int index) {
6916    if (element == null) 
6917      return;
6918    Complex t;
6919    if (Utilities.noString(parentType))
6920      t = parent;
6921    else {
6922      t = parent.predicate("fhir:"+parentType+'.'+name);
6923    }
6924    composeDomainResource(t, "EventDefinition", name, element, index);
6925    if (element.hasUrlElement())
6926      composeUri(t, "EventDefinition", "url", element.getUrlElement(), -1);
6927    for (int i = 0; i < element.getIdentifier().size(); i++)
6928      composeIdentifier(t, "EventDefinition", "identifier", element.getIdentifier().get(i), i);
6929    if (element.hasVersionElement())
6930      composeString(t, "EventDefinition", "version", element.getVersionElement(), -1);
6931    if (element.hasNameElement())
6932      composeString(t, "EventDefinition", "name", element.getNameElement(), -1);
6933    if (element.hasTitleElement())
6934      composeString(t, "EventDefinition", "title", element.getTitleElement(), -1);
6935    if (element.hasSubtitleElement())
6936      composeString(t, "EventDefinition", "subtitle", element.getSubtitleElement(), -1);
6937    if (element.hasStatusElement())
6938      composeEnum(t, "EventDefinition", "status", element.getStatusElement(), -1);
6939    if (element.hasExperimentalElement())
6940      composeBoolean(t, "EventDefinition", "experimental", element.getExperimentalElement(), -1);
6941    if (element.hasSubject())
6942      composeType(t, "EventDefinition", "subject", element.getSubject(), -1);
6943    if (element.hasDateElement())
6944      composeDateTime(t, "EventDefinition", "date", element.getDateElement(), -1);
6945    if (element.hasPublisherElement())
6946      composeString(t, "EventDefinition", "publisher", element.getPublisherElement(), -1);
6947    for (int i = 0; i < element.getContact().size(); i++)
6948      composeContactDetail(t, "EventDefinition", "contact", element.getContact().get(i), i);
6949    if (element.hasDescriptionElement())
6950      composeMarkdown(t, "EventDefinition", "description", element.getDescriptionElement(), -1);
6951    for (int i = 0; i < element.getUseContext().size(); i++)
6952      composeUsageContext(t, "EventDefinition", "useContext", element.getUseContext().get(i), i);
6953    for (int i = 0; i < element.getJurisdiction().size(); i++)
6954      composeCodeableConcept(t, "EventDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
6955    if (element.hasPurposeElement())
6956      composeMarkdown(t, "EventDefinition", "purpose", element.getPurposeElement(), -1);
6957    if (element.hasUsageElement())
6958      composeString(t, "EventDefinition", "usage", element.getUsageElement(), -1);
6959    if (element.hasCopyrightElement())
6960      composeMarkdown(t, "EventDefinition", "copyright", element.getCopyrightElement(), -1);
6961    if (element.hasApprovalDateElement())
6962      composeDate(t, "EventDefinition", "approvalDate", element.getApprovalDateElement(), -1);
6963    if (element.hasLastReviewDateElement())
6964      composeDate(t, "EventDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
6965    if (element.hasEffectivePeriod())
6966      composePeriod(t, "EventDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
6967    for (int i = 0; i < element.getTopic().size(); i++)
6968      composeCodeableConcept(t, "EventDefinition", "topic", element.getTopic().get(i), i);
6969    for (int i = 0; i < element.getAuthor().size(); i++)
6970      composeContactDetail(t, "EventDefinition", "author", element.getAuthor().get(i), i);
6971    for (int i = 0; i < element.getEditor().size(); i++)
6972      composeContactDetail(t, "EventDefinition", "editor", element.getEditor().get(i), i);
6973    for (int i = 0; i < element.getReviewer().size(); i++)
6974      composeContactDetail(t, "EventDefinition", "reviewer", element.getReviewer().get(i), i);
6975    for (int i = 0; i < element.getEndorser().size(); i++)
6976      composeContactDetail(t, "EventDefinition", "endorser", element.getEndorser().get(i), i);
6977    for (int i = 0; i < element.getRelatedArtifact().size(); i++)
6978      composeRelatedArtifact(t, "EventDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
6979    for (int i = 0; i < element.getTrigger().size(); i++)
6980      composeTriggerDefinition(t, "EventDefinition", "trigger", element.getTrigger().get(i), i);
6981  }
6982
6983  protected void composeEvidence(Complex parent, String parentType, String name, Evidence element, int index) {
6984    if (element == null) 
6985      return;
6986    Complex t;
6987    if (Utilities.noString(parentType))
6988      t = parent;
6989    else {
6990      t = parent.predicate("fhir:"+parentType+'.'+name);
6991    }
6992    composeDomainResource(t, "Evidence", name, element, index);
6993    if (element.hasUrlElement())
6994      composeUri(t, "Evidence", "url", element.getUrlElement(), -1);
6995    for (int i = 0; i < element.getIdentifier().size(); i++)
6996      composeIdentifier(t, "Evidence", "identifier", element.getIdentifier().get(i), i);
6997    if (element.hasVersionElement())
6998      composeString(t, "Evidence", "version", element.getVersionElement(), -1);
6999    if (element.hasNameElement())
7000      composeString(t, "Evidence", "name", element.getNameElement(), -1);
7001    if (element.hasTitleElement())
7002      composeString(t, "Evidence", "title", element.getTitleElement(), -1);
7003    if (element.hasShortTitleElement())
7004      composeString(t, "Evidence", "shortTitle", element.getShortTitleElement(), -1);
7005    if (element.hasSubtitleElement())
7006      composeString(t, "Evidence", "subtitle", element.getSubtitleElement(), -1);
7007    if (element.hasStatusElement())
7008      composeEnum(t, "Evidence", "status", element.getStatusElement(), -1);
7009    if (element.hasDateElement())
7010      composeDateTime(t, "Evidence", "date", element.getDateElement(), -1);
7011    if (element.hasPublisherElement())
7012      composeString(t, "Evidence", "publisher", element.getPublisherElement(), -1);
7013    for (int i = 0; i < element.getContact().size(); i++)
7014      composeContactDetail(t, "Evidence", "contact", element.getContact().get(i), i);
7015    if (element.hasDescriptionElement())
7016      composeMarkdown(t, "Evidence", "description", element.getDescriptionElement(), -1);
7017    for (int i = 0; i < element.getNote().size(); i++)
7018      composeAnnotation(t, "Evidence", "note", element.getNote().get(i), i);
7019    for (int i = 0; i < element.getUseContext().size(); i++)
7020      composeUsageContext(t, "Evidence", "useContext", element.getUseContext().get(i), i);
7021    for (int i = 0; i < element.getJurisdiction().size(); i++)
7022      composeCodeableConcept(t, "Evidence", "jurisdiction", element.getJurisdiction().get(i), i);
7023    if (element.hasCopyrightElement())
7024      composeMarkdown(t, "Evidence", "copyright", element.getCopyrightElement(), -1);
7025    if (element.hasApprovalDateElement())
7026      composeDate(t, "Evidence", "approvalDate", element.getApprovalDateElement(), -1);
7027    if (element.hasLastReviewDateElement())
7028      composeDate(t, "Evidence", "lastReviewDate", element.getLastReviewDateElement(), -1);
7029    if (element.hasEffectivePeriod())
7030      composePeriod(t, "Evidence", "effectivePeriod", element.getEffectivePeriod(), -1);
7031    for (int i = 0; i < element.getTopic().size(); i++)
7032      composeCodeableConcept(t, "Evidence", "topic", element.getTopic().get(i), i);
7033    for (int i = 0; i < element.getAuthor().size(); i++)
7034      composeContactDetail(t, "Evidence", "author", element.getAuthor().get(i), i);
7035    for (int i = 0; i < element.getEditor().size(); i++)
7036      composeContactDetail(t, "Evidence", "editor", element.getEditor().get(i), i);
7037    for (int i = 0; i < element.getReviewer().size(); i++)
7038      composeContactDetail(t, "Evidence", "reviewer", element.getReviewer().get(i), i);
7039    for (int i = 0; i < element.getEndorser().size(); i++)
7040      composeContactDetail(t, "Evidence", "endorser", element.getEndorser().get(i), i);
7041    for (int i = 0; i < element.getRelatedArtifact().size(); i++)
7042      composeRelatedArtifact(t, "Evidence", "relatedArtifact", element.getRelatedArtifact().get(i), i);
7043    if (element.hasExposureBackground())
7044      composeReference(t, "Evidence", "exposureBackground", element.getExposureBackground(), -1);
7045    for (int i = 0; i < element.getExposureVariant().size(); i++)
7046      composeReference(t, "Evidence", "exposureVariant", element.getExposureVariant().get(i), i);
7047    for (int i = 0; i < element.getOutcome().size(); i++)
7048      composeReference(t, "Evidence", "outcome", element.getOutcome().get(i), i);
7049  }
7050
7051  protected void composeEvidenceVariable(Complex parent, String parentType, String name, EvidenceVariable element, int index) {
7052    if (element == null) 
7053      return;
7054    Complex t;
7055    if (Utilities.noString(parentType))
7056      t = parent;
7057    else {
7058      t = parent.predicate("fhir:"+parentType+'.'+name);
7059    }
7060    composeDomainResource(t, "EvidenceVariable", name, element, index);
7061    if (element.hasUrlElement())
7062      composeUri(t, "EvidenceVariable", "url", element.getUrlElement(), -1);
7063    for (int i = 0; i < element.getIdentifier().size(); i++)
7064      composeIdentifier(t, "EvidenceVariable", "identifier", element.getIdentifier().get(i), i);
7065    if (element.hasVersionElement())
7066      composeString(t, "EvidenceVariable", "version", element.getVersionElement(), -1);
7067    if (element.hasNameElement())
7068      composeString(t, "EvidenceVariable", "name", element.getNameElement(), -1);
7069    if (element.hasTitleElement())
7070      composeString(t, "EvidenceVariable", "title", element.getTitleElement(), -1);
7071    if (element.hasShortTitleElement())
7072      composeString(t, "EvidenceVariable", "shortTitle", element.getShortTitleElement(), -1);
7073    if (element.hasSubtitleElement())
7074      composeString(t, "EvidenceVariable", "subtitle", element.getSubtitleElement(), -1);
7075    if (element.hasStatusElement())
7076      composeEnum(t, "EvidenceVariable", "status", element.getStatusElement(), -1);
7077    if (element.hasDateElement())
7078      composeDateTime(t, "EvidenceVariable", "date", element.getDateElement(), -1);
7079    if (element.hasPublisherElement())
7080      composeString(t, "EvidenceVariable", "publisher", element.getPublisherElement(), -1);
7081    for (int i = 0; i < element.getContact().size(); i++)
7082      composeContactDetail(t, "EvidenceVariable", "contact", element.getContact().get(i), i);
7083    if (element.hasDescriptionElement())
7084      composeMarkdown(t, "EvidenceVariable", "description", element.getDescriptionElement(), -1);
7085    for (int i = 0; i < element.getNote().size(); i++)
7086      composeAnnotation(t, "EvidenceVariable", "note", element.getNote().get(i), i);
7087    for (int i = 0; i < element.getUseContext().size(); i++)
7088      composeUsageContext(t, "EvidenceVariable", "useContext", element.getUseContext().get(i), i);
7089    for (int i = 0; i < element.getJurisdiction().size(); i++)
7090      composeCodeableConcept(t, "EvidenceVariable", "jurisdiction", element.getJurisdiction().get(i), i);
7091    if (element.hasCopyrightElement())
7092      composeMarkdown(t, "EvidenceVariable", "copyright", element.getCopyrightElement(), -1);
7093    if (element.hasApprovalDateElement())
7094      composeDate(t, "EvidenceVariable", "approvalDate", element.getApprovalDateElement(), -1);
7095    if (element.hasLastReviewDateElement())
7096      composeDate(t, "EvidenceVariable", "lastReviewDate", element.getLastReviewDateElement(), -1);
7097    if (element.hasEffectivePeriod())
7098      composePeriod(t, "EvidenceVariable", "effectivePeriod", element.getEffectivePeriod(), -1);
7099    for (int i = 0; i < element.getTopic().size(); i++)
7100      composeCodeableConcept(t, "EvidenceVariable", "topic", element.getTopic().get(i), i);
7101    for (int i = 0; i < element.getAuthor().size(); i++)
7102      composeContactDetail(t, "EvidenceVariable", "author", element.getAuthor().get(i), i);
7103    for (int i = 0; i < element.getEditor().size(); i++)
7104      composeContactDetail(t, "EvidenceVariable", "editor", element.getEditor().get(i), i);
7105    for (int i = 0; i < element.getReviewer().size(); i++)
7106      composeContactDetail(t, "EvidenceVariable", "reviewer", element.getReviewer().get(i), i);
7107    for (int i = 0; i < element.getEndorser().size(); i++)
7108      composeContactDetail(t, "EvidenceVariable", "endorser", element.getEndorser().get(i), i);
7109    for (int i = 0; i < element.getRelatedArtifact().size(); i++)
7110      composeRelatedArtifact(t, "EvidenceVariable", "relatedArtifact", element.getRelatedArtifact().get(i), i);
7111    if (element.hasTypeElement())
7112      composeEnum(t, "EvidenceVariable", "type", element.getTypeElement(), -1);
7113    for (int i = 0; i < element.getCharacteristic().size(); i++)
7114      composeEvidenceVariableEvidenceVariableCharacteristicComponent(t, "EvidenceVariable", "characteristic", element.getCharacteristic().get(i), i);
7115  }
7116
7117  protected void composeEvidenceVariableEvidenceVariableCharacteristicComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicComponent element, int index) {
7118    if (element == null) 
7119      return;
7120    Complex t;
7121    if (Utilities.noString(parentType))
7122      t = parent;
7123    else {
7124      t = parent.predicate("fhir:"+parentType+'.'+name);
7125    }
7126    composeBackboneElement(t, "characteristic", name, element, index);
7127    if (element.hasDescriptionElement())
7128      composeString(t, "EvidenceVariable", "description", element.getDescriptionElement(), -1);
7129    if (element.hasDefinition())
7130      composeType(t, "EvidenceVariable", "definition", element.getDefinition(), -1);
7131    for (int i = 0; i < element.getUsageContext().size(); i++)
7132      composeUsageContext(t, "EvidenceVariable", "usageContext", element.getUsageContext().get(i), i);
7133    if (element.hasExcludeElement())
7134      composeBoolean(t, "EvidenceVariable", "exclude", element.getExcludeElement(), -1);
7135    if (element.hasParticipantEffective())
7136      composeType(t, "EvidenceVariable", "participantEffective", element.getParticipantEffective(), -1);
7137    if (element.hasTimeFromStart())
7138      composeDuration(t, "EvidenceVariable", "timeFromStart", element.getTimeFromStart(), -1);
7139    if (element.hasGroupMeasureElement())
7140      composeEnum(t, "EvidenceVariable", "groupMeasure", element.getGroupMeasureElement(), -1);
7141  }
7142
7143  protected void composeExampleScenario(Complex parent, String parentType, String name, ExampleScenario element, int index) {
7144    if (element == null) 
7145      return;
7146    Complex t;
7147    if (Utilities.noString(parentType))
7148      t = parent;
7149    else {
7150      t = parent.predicate("fhir:"+parentType+'.'+name);
7151    }
7152    composeDomainResource(t, "ExampleScenario", name, element, index);
7153    if (element.hasUrlElement())
7154      composeUri(t, "ExampleScenario", "url", element.getUrlElement(), -1);
7155    for (int i = 0; i < element.getIdentifier().size(); i++)
7156      composeIdentifier(t, "ExampleScenario", "identifier", element.getIdentifier().get(i), i);
7157    if (element.hasVersionElement())
7158      composeString(t, "ExampleScenario", "version", element.getVersionElement(), -1);
7159    if (element.hasNameElement())
7160      composeString(t, "ExampleScenario", "name", element.getNameElement(), -1);
7161    if (element.hasStatusElement())
7162      composeEnum(t, "ExampleScenario", "status", element.getStatusElement(), -1);
7163    if (element.hasExperimentalElement())
7164      composeBoolean(t, "ExampleScenario", "experimental", element.getExperimentalElement(), -1);
7165    if (element.hasDateElement())
7166      composeDateTime(t, "ExampleScenario", "date", element.getDateElement(), -1);
7167    if (element.hasPublisherElement())
7168      composeString(t, "ExampleScenario", "publisher", element.getPublisherElement(), -1);
7169    for (int i = 0; i < element.getContact().size(); i++)
7170      composeContactDetail(t, "ExampleScenario", "contact", element.getContact().get(i), i);
7171    for (int i = 0; i < element.getUseContext().size(); i++)
7172      composeUsageContext(t, "ExampleScenario", "useContext", element.getUseContext().get(i), i);
7173    for (int i = 0; i < element.getJurisdiction().size(); i++)
7174      composeCodeableConcept(t, "ExampleScenario", "jurisdiction", element.getJurisdiction().get(i), i);
7175    if (element.hasCopyrightElement())
7176      composeMarkdown(t, "ExampleScenario", "copyright", element.getCopyrightElement(), -1);
7177    if (element.hasPurposeElement())
7178      composeMarkdown(t, "ExampleScenario", "purpose", element.getPurposeElement(), -1);
7179    for (int i = 0; i < element.getActor().size(); i++)
7180      composeExampleScenarioExampleScenarioActorComponent(t, "ExampleScenario", "actor", element.getActor().get(i), i);
7181    for (int i = 0; i < element.getInstance().size(); i++)
7182      composeExampleScenarioExampleScenarioInstanceComponent(t, "ExampleScenario", "instance", element.getInstance().get(i), i);
7183    for (int i = 0; i < element.getProcess().size(); i++)
7184      composeExampleScenarioExampleScenarioProcessComponent(t, "ExampleScenario", "process", element.getProcess().get(i), i);
7185    for (int i = 0; i < element.getWorkflow().size(); i++)
7186      composeCanonical(t, "ExampleScenario", "workflow", element.getWorkflow().get(i), i);
7187  }
7188
7189  protected void composeExampleScenarioExampleScenarioActorComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioActorComponent element, int index) {
7190    if (element == null) 
7191      return;
7192    Complex t;
7193    if (Utilities.noString(parentType))
7194      t = parent;
7195    else {
7196      t = parent.predicate("fhir:"+parentType+'.'+name);
7197    }
7198    composeBackboneElement(t, "actor", name, element, index);
7199    if (element.hasActorIdElement())
7200      composeString(t, "ExampleScenario", "actorId", element.getActorIdElement(), -1);
7201    if (element.hasTypeElement())
7202      composeEnum(t, "ExampleScenario", "type", element.getTypeElement(), -1);
7203    if (element.hasNameElement())
7204      composeString(t, "ExampleScenario", "name", element.getNameElement(), -1);
7205    if (element.hasDescriptionElement())
7206      composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1);
7207  }
7208
7209  protected void composeExampleScenarioExampleScenarioInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceComponent element, int index) {
7210    if (element == null) 
7211      return;
7212    Complex t;
7213    if (Utilities.noString(parentType))
7214      t = parent;
7215    else {
7216      t = parent.predicate("fhir:"+parentType+'.'+name);
7217    }
7218    composeBackboneElement(t, "instance", name, element, index);
7219    if (element.hasResourceIdElement())
7220      composeString(t, "ExampleScenario", "resourceId", element.getResourceIdElement(), -1);
7221    if (element.hasResourceTypeElement())
7222      composeEnum(t, "ExampleScenario", "resourceType", element.getResourceTypeElement(), -1);
7223    if (element.hasNameElement())
7224      composeString(t, "ExampleScenario", "name", element.getNameElement(), -1);
7225    if (element.hasDescriptionElement())
7226      composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1);
7227    for (int i = 0; i < element.getVersion().size(); i++)
7228      composeExampleScenarioExampleScenarioInstanceVersionComponent(t, "ExampleScenario", "version", element.getVersion().get(i), i);
7229    for (int i = 0; i < element.getContainedInstance().size(); i++)
7230      composeExampleScenarioExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenario", "containedInstance", element.getContainedInstance().get(i), i);
7231  }
7232
7233  protected void composeExampleScenarioExampleScenarioInstanceVersionComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceVersionComponent 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, "version", name, element, index);
7243    if (element.hasVersionIdElement())
7244      composeString(t, "ExampleScenario", "versionId", element.getVersionIdElement(), -1);
7245    if (element.hasDescriptionElement())
7246      composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1);
7247  }
7248
7249  protected void composeExampleScenarioExampleScenarioInstanceContainedInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceContainedInstanceComponent 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, "containedInstance", name, element, index);
7259    if (element.hasResourceIdElement())
7260      composeString(t, "ExampleScenario", "resourceId", element.getResourceIdElement(), -1);
7261    if (element.hasVersionIdElement())
7262      composeString(t, "ExampleScenario", "versionId", element.getVersionIdElement(), -1);
7263  }
7264
7265  protected void composeExampleScenarioExampleScenarioProcessComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessComponent element, int index) {
7266    if (element == null) 
7267      return;
7268    Complex t;
7269    if (Utilities.noString(parentType))
7270      t = parent;
7271    else {
7272      t = parent.predicate("fhir:"+parentType+'.'+name);
7273    }
7274    composeBackboneElement(t, "process", name, element, index);
7275    if (element.hasTitleElement())
7276      composeString(t, "ExampleScenario", "title", element.getTitleElement(), -1);
7277    if (element.hasDescriptionElement())
7278      composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1);
7279    if (element.hasPreConditionsElement())
7280      composeMarkdown(t, "ExampleScenario", "preConditions", element.getPreConditionsElement(), -1);
7281    if (element.hasPostConditionsElement())
7282      composeMarkdown(t, "ExampleScenario", "postConditions", element.getPostConditionsElement(), -1);
7283    for (int i = 0; i < element.getStep().size(); i++)
7284      composeExampleScenarioExampleScenarioProcessStepComponent(t, "ExampleScenario", "step", element.getStep().get(i), i);
7285  }
7286
7287  protected void composeExampleScenarioExampleScenarioProcessStepComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepComponent element, int index) {
7288    if (element == null) 
7289      return;
7290    Complex t;
7291    if (Utilities.noString(parentType))
7292      t = parent;
7293    else {
7294      t = parent.predicate("fhir:"+parentType+'.'+name);
7295    }
7296    composeBackboneElement(t, "step", name, element, index);
7297    for (int i = 0; i < element.getProcess().size(); i++)
7298      composeExampleScenarioExampleScenarioProcessComponent(t, "ExampleScenario", "process", element.getProcess().get(i), i);
7299    if (element.hasPauseElement())
7300      composeBoolean(t, "ExampleScenario", "pause", element.getPauseElement(), -1);
7301    if (element.hasOperation())
7302      composeExampleScenarioExampleScenarioProcessStepOperationComponent(t, "ExampleScenario", "operation", element.getOperation(), -1);
7303    for (int i = 0; i < element.getAlternative().size(); i++)
7304      composeExampleScenarioExampleScenarioProcessStepAlternativeComponent(t, "ExampleScenario", "alternative", element.getAlternative().get(i), i);
7305  }
7306
7307  protected void composeExampleScenarioExampleScenarioProcessStepOperationComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepOperationComponent element, int index) {
7308    if (element == null) 
7309      return;
7310    Complex t;
7311    if (Utilities.noString(parentType))
7312      t = parent;
7313    else {
7314      t = parent.predicate("fhir:"+parentType+'.'+name);
7315    }
7316    composeBackboneElement(t, "operation", name, element, index);
7317    if (element.hasNumberElement())
7318      composeString(t, "ExampleScenario", "number", element.getNumberElement(), -1);
7319    if (element.hasTypeElement())
7320      composeString(t, "ExampleScenario", "type", element.getTypeElement(), -1);
7321    if (element.hasNameElement())
7322      composeString(t, "ExampleScenario", "name", element.getNameElement(), -1);
7323    if (element.hasInitiatorElement())
7324      composeString(t, "ExampleScenario", "initiator", element.getInitiatorElement(), -1);
7325    if (element.hasReceiverElement())
7326      composeString(t, "ExampleScenario", "receiver", element.getReceiverElement(), -1);
7327    if (element.hasDescriptionElement())
7328      composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1);
7329    if (element.hasInitiatorActiveElement())
7330      composeBoolean(t, "ExampleScenario", "initiatorActive", element.getInitiatorActiveElement(), -1);
7331    if (element.hasReceiverActiveElement())
7332      composeBoolean(t, "ExampleScenario", "receiverActive", element.getReceiverActiveElement(), -1);
7333    if (element.hasRequest())
7334      composeExampleScenarioExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenario", "request", element.getRequest(), -1);
7335    if (element.hasResponse())
7336      composeExampleScenarioExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenario", "response", element.getResponse(), -1);
7337  }
7338
7339  protected void composeExampleScenarioExampleScenarioProcessStepAlternativeComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepAlternativeComponent element, int index) {
7340    if (element == null) 
7341      return;
7342    Complex t;
7343    if (Utilities.noString(parentType))
7344      t = parent;
7345    else {
7346      t = parent.predicate("fhir:"+parentType+'.'+name);
7347    }
7348    composeBackboneElement(t, "alternative", name, element, index);
7349    if (element.hasTitleElement())
7350      composeString(t, "ExampleScenario", "title", element.getTitleElement(), -1);
7351    if (element.hasDescriptionElement())
7352      composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1);
7353    for (int i = 0; i < element.getStep().size(); i++)
7354      composeExampleScenarioExampleScenarioProcessStepComponent(t, "ExampleScenario", "step", element.getStep().get(i), i);
7355  }
7356
7357  protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) {
7358    if (element == null) 
7359      return;
7360    Complex t;
7361    if (Utilities.noString(parentType))
7362      t = parent;
7363    else {
7364      t = parent.predicate("fhir:"+parentType+'.'+name);
7365    }
7366    composeDomainResource(t, "ExplanationOfBenefit", name, element, index);
7367    for (int i = 0; i < element.getIdentifier().size(); i++)
7368      composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i);
7369    if (element.hasStatusElement())
7370      composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1);
7371    if (element.hasType())
7372      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
7373    if (element.hasSubType())
7374      composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType(), -1);
7375    if (element.hasUseElement())
7376      composeEnum(t, "ExplanationOfBenefit", "use", element.getUseElement(), -1);
7377    if (element.hasPatient())
7378      composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1);
7379    if (element.hasBillablePeriod())
7380      composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1);
7381    if (element.hasCreatedElement())
7382      composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1);
7383    if (element.hasEnterer())
7384      composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1);
7385    if (element.hasInsurer())
7386      composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1);
7387    if (element.hasProvider())
7388      composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1);
7389    if (element.hasPriority())
7390      composeCodeableConcept(t, "ExplanationOfBenefit", "priority", element.getPriority(), -1);
7391    if (element.hasFundsReserveRequested())
7392      composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserveRequested", element.getFundsReserveRequested(), -1);
7393    if (element.hasFundsReserve())
7394      composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserve", element.getFundsReserve(), -1);
7395    for (int i = 0; i < element.getRelated().size(); i++)
7396      composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i);
7397    if (element.hasPrescription())
7398      composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1);
7399    if (element.hasOriginalPrescription())
7400      composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1);
7401    if (element.hasPayee())
7402      composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1);
7403    if (element.hasReferral())
7404      composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1);
7405    if (element.hasFacility())
7406      composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1);
7407    if (element.hasClaim())
7408      composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1);
7409    if (element.hasClaimResponse())
7410      composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1);
7411    if (element.hasOutcomeElement())
7412      composeEnum(t, "ExplanationOfBenefit", "outcome", element.getOutcomeElement(), -1);
7413    if (element.hasDispositionElement())
7414      composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1);
7415    for (int i = 0; i < element.getPreAuthRef().size(); i++)
7416      composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i);
7417    for (int i = 0; i < element.getPreAuthRefPeriod().size(); i++)
7418      composePeriod(t, "ExplanationOfBenefit", "preAuthRefPeriod", element.getPreAuthRefPeriod().get(i), i);
7419    for (int i = 0; i < element.getCareTeam().size(); i++)
7420      composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i);
7421    for (int i = 0; i < element.getSupportingInfo().size(); i++)
7422      composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "supportingInfo", element.getSupportingInfo().get(i), i);
7423    for (int i = 0; i < element.getDiagnosis().size(); i++)
7424      composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i);
7425    for (int i = 0; i < element.getProcedure().size(); i++)
7426      composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i);
7427    if (element.hasPrecedenceElement())
7428      composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1);
7429    for (int i = 0; i < element.getInsurance().size(); i++)
7430      composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance().get(i), i);
7431    if (element.hasAccident())
7432      composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1);
7433    for (int i = 0; i < element.getItem().size(); i++)
7434      composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i);
7435    for (int i = 0; i < element.getAddItem().size(); i++)
7436      composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i);
7437    for (int i = 0; i < element.getAdjudication().size(); i++)
7438      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
7439    for (int i = 0; i < element.getTotal().size(); i++)
7440      composeExplanationOfBenefitTotalComponent(t, "ExplanationOfBenefit", "total", element.getTotal().get(i), i);
7441    if (element.hasPayment())
7442      composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1);
7443    if (element.hasFormCode())
7444      composeCodeableConcept(t, "ExplanationOfBenefit", "formCode", element.getFormCode(), -1);
7445    if (element.hasForm())
7446      composeAttachment(t, "ExplanationOfBenefit", "form", element.getForm(), -1);
7447    for (int i = 0; i < element.getProcessNote().size(); i++)
7448      composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i);
7449    if (element.hasBenefitPeriod())
7450      composePeriod(t, "ExplanationOfBenefit", "benefitPeriod", element.getBenefitPeriod(), -1);
7451    for (int i = 0; i < element.getBenefitBalance().size(); i++)
7452      composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i);
7453  }
7454
7455  protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) {
7456    if (element == null) 
7457      return;
7458    Complex t;
7459    if (Utilities.noString(parentType))
7460      t = parent;
7461    else {
7462      t = parent.predicate("fhir:"+parentType+'.'+name);
7463    }
7464    composeBackboneElement(t, "related", name, element, index);
7465    if (element.hasClaim())
7466      composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1);
7467    if (element.hasRelationship())
7468      composeCodeableConcept(t, "ExplanationOfBenefit", "relationship", element.getRelationship(), -1);
7469    if (element.hasReference())
7470      composeIdentifier(t, "ExplanationOfBenefit", "reference", element.getReference(), -1);
7471  }
7472
7473  protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) {
7474    if (element == null) 
7475      return;
7476    Complex t;
7477    if (Utilities.noString(parentType))
7478      t = parent;
7479    else {
7480      t = parent.predicate("fhir:"+parentType+'.'+name);
7481    }
7482    composeBackboneElement(t, "payee", name, element, index);
7483    if (element.hasType())
7484      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
7485    if (element.hasParty())
7486      composeReference(t, "ExplanationOfBenefit", "party", element.getParty(), -1);
7487  }
7488
7489  protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) {
7490    if (element == null) 
7491      return;
7492    Complex t;
7493    if (Utilities.noString(parentType))
7494      t = parent;
7495    else {
7496      t = parent.predicate("fhir:"+parentType+'.'+name);
7497    }
7498    composeBackboneElement(t, "careTeam", name, element, index);
7499    if (element.hasSequenceElement())
7500      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
7501    if (element.hasProvider())
7502      composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1);
7503    if (element.hasResponsibleElement())
7504      composeBoolean(t, "ExplanationOfBenefit", "responsible", element.getResponsibleElement(), -1);
7505    if (element.hasRole())
7506      composeCodeableConcept(t, "ExplanationOfBenefit", "role", element.getRole(), -1);
7507    if (element.hasQualification())
7508      composeCodeableConcept(t, "ExplanationOfBenefit", "qualification", element.getQualification(), -1);
7509  }
7510
7511  protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) {
7512    if (element == null) 
7513      return;
7514    Complex t;
7515    if (Utilities.noString(parentType))
7516      t = parent;
7517    else {
7518      t = parent.predicate("fhir:"+parentType+'.'+name);
7519    }
7520    composeBackboneElement(t, "supportingInfo", name, element, index);
7521    if (element.hasSequenceElement())
7522      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
7523    if (element.hasCategory())
7524      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
7525    if (element.hasCode())
7526      composeCodeableConcept(t, "ExplanationOfBenefit", "code", element.getCode(), -1);
7527    if (element.hasTiming())
7528      composeType(t, "ExplanationOfBenefit", "timing", element.getTiming(), -1);
7529    if (element.hasValue())
7530      composeType(t, "ExplanationOfBenefit", "value", element.getValue(), -1);
7531    if (element.hasReason())
7532      composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1);
7533  }
7534
7535  protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) {
7536    if (element == null) 
7537      return;
7538    Complex t;
7539    if (Utilities.noString(parentType))
7540      t = parent;
7541    else {
7542      t = parent.predicate("fhir:"+parentType+'.'+name);
7543    }
7544    composeBackboneElement(t, "diagnosis", name, element, index);
7545    if (element.hasSequenceElement())
7546      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
7547    if (element.hasDiagnosis())
7548      composeType(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis(), -1);
7549    for (int i = 0; i < element.getType().size(); i++)
7550      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType().get(i), i);
7551    if (element.hasOnAdmission())
7552      composeCodeableConcept(t, "ExplanationOfBenefit", "onAdmission", element.getOnAdmission(), -1);
7553    if (element.hasPackageCode())
7554      composeCodeableConcept(t, "ExplanationOfBenefit", "packageCode", element.getPackageCode(), -1);
7555  }
7556
7557  protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) {
7558    if (element == null) 
7559      return;
7560    Complex t;
7561    if (Utilities.noString(parentType))
7562      t = parent;
7563    else {
7564      t = parent.predicate("fhir:"+parentType+'.'+name);
7565    }
7566    composeBackboneElement(t, "procedure", name, element, index);
7567    if (element.hasSequenceElement())
7568      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
7569    for (int i = 0; i < element.getType().size(); i++)
7570      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType().get(i), i);
7571    if (element.hasDateElement())
7572      composeDateTime(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1);
7573    if (element.hasProcedure())
7574      composeType(t, "ExplanationOfBenefit", "procedure", element.getProcedure(), -1);
7575    for (int i = 0; i < element.getUdi().size(); i++)
7576      composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i);
7577  }
7578
7579  protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) {
7580    if (element == null) 
7581      return;
7582    Complex t;
7583    if (Utilities.noString(parentType))
7584      t = parent;
7585    else {
7586      t = parent.predicate("fhir:"+parentType+'.'+name);
7587    }
7588    composeBackboneElement(t, "insurance", name, element, index);
7589    if (element.hasFocalElement())
7590      composeBoolean(t, "ExplanationOfBenefit", "focal", element.getFocalElement(), -1);
7591    if (element.hasCoverage())
7592      composeReference(t, "ExplanationOfBenefit", "coverage", element.getCoverage(), -1);
7593    for (int i = 0; i < element.getPreAuthRef().size(); i++)
7594      composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i);
7595  }
7596
7597  protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) {
7598    if (element == null) 
7599      return;
7600    Complex t;
7601    if (Utilities.noString(parentType))
7602      t = parent;
7603    else {
7604      t = parent.predicate("fhir:"+parentType+'.'+name);
7605    }
7606    composeBackboneElement(t, "accident", name, element, index);
7607    if (element.hasDateElement())
7608      composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1);
7609    if (element.hasType())
7610      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
7611    if (element.hasLocation())
7612      composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1);
7613  }
7614
7615  protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent 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, "item", name, element, index);
7625    if (element.hasSequenceElement())
7626      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
7627    for (int i = 0; i < element.getCareTeamSequence().size(); i++)
7628      composePositiveInt(t, "ExplanationOfBenefit", "careTeamSequence", element.getCareTeamSequence().get(i), i);
7629    for (int i = 0; i < element.getDiagnosisSequence().size(); i++)
7630      composePositiveInt(t, "ExplanationOfBenefit", "diagnosisSequence", element.getDiagnosisSequence().get(i), i);
7631    for (int i = 0; i < element.getProcedureSequence().size(); i++)
7632      composePositiveInt(t, "ExplanationOfBenefit", "procedureSequence", element.getProcedureSequence().get(i), i);
7633    for (int i = 0; i < element.getInformationSequence().size(); i++)
7634      composePositiveInt(t, "ExplanationOfBenefit", "informationSequence", element.getInformationSequence().get(i), i);
7635    if (element.hasRevenue())
7636      composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1);
7637    if (element.hasCategory())
7638      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
7639    if (element.hasProductOrService())
7640      composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1);
7641    for (int i = 0; i < element.getModifier().size(); i++)
7642      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
7643    for (int i = 0; i < element.getProgramCode().size(); i++)
7644      composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i);
7645    if (element.hasServiced())
7646      composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1);
7647    if (element.hasLocation())
7648      composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1);
7649    if (element.hasQuantity())
7650      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
7651    if (element.hasUnitPrice())
7652      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
7653    if (element.hasFactorElement())
7654      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
7655    if (element.hasNet())
7656      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
7657    for (int i = 0; i < element.getUdi().size(); i++)
7658      composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i);
7659    if (element.hasBodySite())
7660      composeCodeableConcept(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1);
7661    for (int i = 0; i < element.getSubSite().size(); i++)
7662      composeCodeableConcept(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i);
7663    for (int i = 0; i < element.getEncounter().size(); i++)
7664      composeReference(t, "ExplanationOfBenefit", "encounter", element.getEncounter().get(i), i);
7665    for (int i = 0; i < element.getNoteNumber().size(); i++)
7666      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
7667    for (int i = 0; i < element.getAdjudication().size(); i++)
7668      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
7669    for (int i = 0; i < element.getDetail().size(); i++)
7670      composeExplanationOfBenefitDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i);
7671  }
7672
7673  protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) {
7674    if (element == null) 
7675      return;
7676    Complex t;
7677    if (Utilities.noString(parentType))
7678      t = parent;
7679    else {
7680      t = parent.predicate("fhir:"+parentType+'.'+name);
7681    }
7682    composeBackboneElement(t, "adjudication", name, element, index);
7683    if (element.hasCategory())
7684      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
7685    if (element.hasReason())
7686      composeCodeableConcept(t, "ExplanationOfBenefit", "reason", element.getReason(), -1);
7687    if (element.hasAmount())
7688      composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1);
7689    if (element.hasValueElement())
7690      composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1);
7691  }
7692
7693  protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) {
7694    if (element == null) 
7695      return;
7696    Complex t;
7697    if (Utilities.noString(parentType))
7698      t = parent;
7699    else {
7700      t = parent.predicate("fhir:"+parentType+'.'+name);
7701    }
7702    composeBackboneElement(t, "detail", name, element, index);
7703    if (element.hasSequenceElement())
7704      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
7705    if (element.hasRevenue())
7706      composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1);
7707    if (element.hasCategory())
7708      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
7709    if (element.hasProductOrService())
7710      composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1);
7711    for (int i = 0; i < element.getModifier().size(); i++)
7712      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
7713    for (int i = 0; i < element.getProgramCode().size(); i++)
7714      composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i);
7715    if (element.hasQuantity())
7716      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
7717    if (element.hasUnitPrice())
7718      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
7719    if (element.hasFactorElement())
7720      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
7721    if (element.hasNet())
7722      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
7723    for (int i = 0; i < element.getUdi().size(); i++)
7724      composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i);
7725    for (int i = 0; i < element.getNoteNumber().size(); i++)
7726      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
7727    for (int i = 0; i < element.getAdjudication().size(); i++)
7728      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
7729    for (int i = 0; i < element.getSubDetail().size(); i++)
7730      composeExplanationOfBenefitSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i);
7731  }
7732
7733  protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) {
7734    if (element == null) 
7735      return;
7736    Complex t;
7737    if (Utilities.noString(parentType))
7738      t = parent;
7739    else {
7740      t = parent.predicate("fhir:"+parentType+'.'+name);
7741    }
7742    composeBackboneElement(t, "subDetail", name, element, index);
7743    if (element.hasSequenceElement())
7744      composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1);
7745    if (element.hasRevenue())
7746      composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1);
7747    if (element.hasCategory())
7748      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
7749    if (element.hasProductOrService())
7750      composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1);
7751    for (int i = 0; i < element.getModifier().size(); i++)
7752      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
7753    for (int i = 0; i < element.getProgramCode().size(); i++)
7754      composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i);
7755    if (element.hasQuantity())
7756      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
7757    if (element.hasUnitPrice())
7758      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
7759    if (element.hasFactorElement())
7760      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
7761    if (element.hasNet())
7762      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
7763    for (int i = 0; i < element.getUdi().size(); i++)
7764      composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i);
7765    for (int i = 0; i < element.getNoteNumber().size(); i++)
7766      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
7767    for (int i = 0; i < element.getAdjudication().size(); i++)
7768      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
7769  }
7770
7771  protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) {
7772    if (element == null) 
7773      return;
7774    Complex t;
7775    if (Utilities.noString(parentType))
7776      t = parent;
7777    else {
7778      t = parent.predicate("fhir:"+parentType+'.'+name);
7779    }
7780    composeBackboneElement(t, "addItem", name, element, index);
7781    for (int i = 0; i < element.getItemSequence().size(); i++)
7782      composePositiveInt(t, "ExplanationOfBenefit", "itemSequence", element.getItemSequence().get(i), i);
7783    for (int i = 0; i < element.getDetailSequence().size(); i++)
7784      composePositiveInt(t, "ExplanationOfBenefit", "detailSequence", element.getDetailSequence().get(i), i);
7785    for (int i = 0; i < element.getSubDetailSequence().size(); i++)
7786      composePositiveInt(t, "ExplanationOfBenefit", "subDetailSequence", element.getSubDetailSequence().get(i), i);
7787    for (int i = 0; i < element.getProvider().size(); i++)
7788      composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider().get(i), i);
7789    if (element.hasProductOrService())
7790      composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1);
7791    for (int i = 0; i < element.getModifier().size(); i++)
7792      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
7793    for (int i = 0; i < element.getProgramCode().size(); i++)
7794      composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i);
7795    if (element.hasServiced())
7796      composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1);
7797    if (element.hasLocation())
7798      composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1);
7799    if (element.hasQuantity())
7800      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
7801    if (element.hasUnitPrice())
7802      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
7803    if (element.hasFactorElement())
7804      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
7805    if (element.hasNet())
7806      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
7807    if (element.hasBodySite())
7808      composeCodeableConcept(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1);
7809    for (int i = 0; i < element.getSubSite().size(); i++)
7810      composeCodeableConcept(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i);
7811    for (int i = 0; i < element.getNoteNumber().size(); i++)
7812      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
7813    for (int i = 0; i < element.getAdjudication().size(); i++)
7814      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
7815    for (int i = 0; i < element.getDetail().size(); i++)
7816      composeExplanationOfBenefitAddedItemDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i);
7817  }
7818
7819  protected void composeExplanationOfBenefitAddedItemDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailComponent element, int index) {
7820    if (element == null) 
7821      return;
7822    Complex t;
7823    if (Utilities.noString(parentType))
7824      t = parent;
7825    else {
7826      t = parent.predicate("fhir:"+parentType+'.'+name);
7827    }
7828    composeBackboneElement(t, "detail", name, element, index);
7829    if (element.hasProductOrService())
7830      composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1);
7831    for (int i = 0; i < element.getModifier().size(); i++)
7832      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
7833    if (element.hasQuantity())
7834      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
7835    if (element.hasUnitPrice())
7836      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
7837    if (element.hasFactorElement())
7838      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
7839    if (element.hasNet())
7840      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
7841    for (int i = 0; i < element.getNoteNumber().size(); i++)
7842      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
7843    for (int i = 0; i < element.getAdjudication().size(); i++)
7844      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
7845    for (int i = 0; i < element.getSubDetail().size(); i++)
7846      composeExplanationOfBenefitAddedItemDetailSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i);
7847  }
7848
7849  protected void composeExplanationOfBenefitAddedItemDetailSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailSubDetailComponent element, int index) {
7850    if (element == null) 
7851      return;
7852    Complex t;
7853    if (Utilities.noString(parentType))
7854      t = parent;
7855    else {
7856      t = parent.predicate("fhir:"+parentType+'.'+name);
7857    }
7858    composeBackboneElement(t, "subDetail", name, element, index);
7859    if (element.hasProductOrService())
7860      composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1);
7861    for (int i = 0; i < element.getModifier().size(); i++)
7862      composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i);
7863    if (element.hasQuantity())
7864      composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1);
7865    if (element.hasUnitPrice())
7866      composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1);
7867    if (element.hasFactorElement())
7868      composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1);
7869    if (element.hasNet())
7870      composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1);
7871    for (int i = 0; i < element.getNoteNumber().size(); i++)
7872      composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i);
7873    for (int i = 0; i < element.getAdjudication().size(); i++)
7874      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
7875  }
7876
7877  protected void composeExplanationOfBenefitTotalComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.TotalComponent element, int index) {
7878    if (element == null) 
7879      return;
7880    Complex t;
7881    if (Utilities.noString(parentType))
7882      t = parent;
7883    else {
7884      t = parent.predicate("fhir:"+parentType+'.'+name);
7885    }
7886    composeBackboneElement(t, "total", name, element, index);
7887    if (element.hasCategory())
7888      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
7889    if (element.hasAmount())
7890      composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1);
7891  }
7892
7893  protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) {
7894    if (element == null) 
7895      return;
7896    Complex t;
7897    if (Utilities.noString(parentType))
7898      t = parent;
7899    else {
7900      t = parent.predicate("fhir:"+parentType+'.'+name);
7901    }
7902    composeBackboneElement(t, "payment", name, element, index);
7903    if (element.hasType())
7904      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
7905    if (element.hasAdjustment())
7906      composeMoney(t, "ExplanationOfBenefit", "adjustment", element.getAdjustment(), -1);
7907    if (element.hasAdjustmentReason())
7908      composeCodeableConcept(t, "ExplanationOfBenefit", "adjustmentReason", element.getAdjustmentReason(), -1);
7909    if (element.hasDateElement())
7910      composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1);
7911    if (element.hasAmount())
7912      composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1);
7913    if (element.hasIdentifier())
7914      composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier(), -1);
7915  }
7916
7917  protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) {
7918    if (element == null) 
7919      return;
7920    Complex t;
7921    if (Utilities.noString(parentType))
7922      t = parent;
7923    else {
7924      t = parent.predicate("fhir:"+parentType+'.'+name);
7925    }
7926    composeBackboneElement(t, "processNote", name, element, index);
7927    if (element.hasNumberElement())
7928      composePositiveInt(t, "ExplanationOfBenefit", "number", element.getNumberElement(), -1);
7929    if (element.hasTypeElement())
7930      composeEnum(t, "ExplanationOfBenefit", "type", element.getTypeElement(), -1);
7931    if (element.hasTextElement())
7932      composeString(t, "ExplanationOfBenefit", "text", element.getTextElement(), -1);
7933    if (element.hasLanguage())
7934      composeCodeableConcept(t, "ExplanationOfBenefit", "language", element.getLanguage(), -1);
7935  }
7936
7937  protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) {
7938    if (element == null) 
7939      return;
7940    Complex t;
7941    if (Utilities.noString(parentType))
7942      t = parent;
7943    else {
7944      t = parent.predicate("fhir:"+parentType+'.'+name);
7945    }
7946    composeBackboneElement(t, "benefitBalance", name, element, index);
7947    if (element.hasCategory())
7948      composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1);
7949    if (element.hasExcludedElement())
7950      composeBoolean(t, "ExplanationOfBenefit", "excluded", element.getExcludedElement(), -1);
7951    if (element.hasNameElement())
7952      composeString(t, "ExplanationOfBenefit", "name", element.getNameElement(), -1);
7953    if (element.hasDescriptionElement())
7954      composeString(t, "ExplanationOfBenefit", "description", element.getDescriptionElement(), -1);
7955    if (element.hasNetwork())
7956      composeCodeableConcept(t, "ExplanationOfBenefit", "network", element.getNetwork(), -1);
7957    if (element.hasUnit())
7958      composeCodeableConcept(t, "ExplanationOfBenefit", "unit", element.getUnit(), -1);
7959    if (element.hasTerm())
7960      composeCodeableConcept(t, "ExplanationOfBenefit", "term", element.getTerm(), -1);
7961    for (int i = 0; i < element.getFinancial().size(); i++)
7962      composeExplanationOfBenefitBenefitComponent(t, "ExplanationOfBenefit", "financial", element.getFinancial().get(i), i);
7963  }
7964
7965  protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) {
7966    if (element == null) 
7967      return;
7968    Complex t;
7969    if (Utilities.noString(parentType))
7970      t = parent;
7971    else {
7972      t = parent.predicate("fhir:"+parentType+'.'+name);
7973    }
7974    composeBackboneElement(t, "financial", name, element, index);
7975    if (element.hasType())
7976      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
7977    if (element.hasAllowed())
7978      composeType(t, "ExplanationOfBenefit", "allowed", element.getAllowed(), -1);
7979    if (element.hasUsed())
7980      composeType(t, "ExplanationOfBenefit", "used", element.getUsed(), -1);
7981  }
7982
7983  protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) {
7984    if (element == null) 
7985      return;
7986    Complex t;
7987    if (Utilities.noString(parentType))
7988      t = parent;
7989    else {
7990      t = parent.predicate("fhir:"+parentType+'.'+name);
7991    }
7992    composeDomainResource(t, "FamilyMemberHistory", name, element, index);
7993    for (int i = 0; i < element.getIdentifier().size(); i++)
7994      composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i);
7995    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++)
7996      composeCanonical(t, "FamilyMemberHistory", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
7997    for (int i = 0; i < element.getInstantiatesUri().size(); i++)
7998      composeUri(t, "FamilyMemberHistory", "instantiatesUri", element.getInstantiatesUri().get(i), i);
7999    if (element.hasStatusElement())
8000      composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1);
8001    if (element.hasDataAbsentReason())
8002      composeCodeableConcept(t, "FamilyMemberHistory", "dataAbsentReason", element.getDataAbsentReason(), -1);
8003    if (element.hasPatient())
8004      composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1);
8005    if (element.hasDateElement())
8006      composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1);
8007    if (element.hasNameElement())
8008      composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1);
8009    if (element.hasRelationship())
8010      composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1);
8011    if (element.hasSex())
8012      composeCodeableConcept(t, "FamilyMemberHistory", "sex", element.getSex(), -1);
8013    if (element.hasBorn())
8014      composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1);
8015    if (element.hasAge())
8016      composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1);
8017    if (element.hasEstimatedAgeElement())
8018      composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1);
8019    if (element.hasDeceased())
8020      composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1);
8021    for (int i = 0; i < element.getReasonCode().size(); i++)
8022      composeCodeableConcept(t, "FamilyMemberHistory", "reasonCode", element.getReasonCode().get(i), i);
8023    for (int i = 0; i < element.getReasonReference().size(); i++)
8024      composeReference(t, "FamilyMemberHistory", "reasonReference", element.getReasonReference().get(i), i);
8025    for (int i = 0; i < element.getNote().size(); i++)
8026      composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i);
8027    for (int i = 0; i < element.getCondition().size(); i++)
8028      composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i);
8029  }
8030
8031  protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) {
8032    if (element == null) 
8033      return;
8034    Complex t;
8035    if (Utilities.noString(parentType))
8036      t = parent;
8037    else {
8038      t = parent.predicate("fhir:"+parentType+'.'+name);
8039    }
8040    composeBackboneElement(t, "condition", name, element, index);
8041    if (element.hasCode())
8042      composeCodeableConcept(t, "FamilyMemberHistory", "code", element.getCode(), -1);
8043    if (element.hasOutcome())
8044      composeCodeableConcept(t, "FamilyMemberHistory", "outcome", element.getOutcome(), -1);
8045    if (element.hasContributedToDeathElement())
8046      composeBoolean(t, "FamilyMemberHistory", "contributedToDeath", element.getContributedToDeathElement(), -1);
8047    if (element.hasOnset())
8048      composeType(t, "FamilyMemberHistory", "onset", element.getOnset(), -1);
8049    for (int i = 0; i < element.getNote().size(); i++)
8050      composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i);
8051  }
8052
8053  protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) {
8054    if (element == null) 
8055      return;
8056    Complex t;
8057    if (Utilities.noString(parentType))
8058      t = parent;
8059    else {
8060      t = parent.predicate("fhir:"+parentType+'.'+name);
8061    }
8062    composeDomainResource(t, "Flag", name, element, index);
8063    for (int i = 0; i < element.getIdentifier().size(); i++)
8064      composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i);
8065    if (element.hasStatusElement())
8066      composeEnum(t, "Flag", "status", element.getStatusElement(), -1);
8067    for (int i = 0; i < element.getCategory().size(); i++)
8068      composeCodeableConcept(t, "Flag", "category", element.getCategory().get(i), i);
8069    if (element.hasCode())
8070      composeCodeableConcept(t, "Flag", "code", element.getCode(), -1);
8071    if (element.hasSubject())
8072      composeReference(t, "Flag", "subject", element.getSubject(), -1);
8073    if (element.hasPeriod())
8074      composePeriod(t, "Flag", "period", element.getPeriod(), -1);
8075    if (element.hasEncounter())
8076      composeReference(t, "Flag", "encounter", element.getEncounter(), -1);
8077    if (element.hasAuthor())
8078      composeReference(t, "Flag", "author", element.getAuthor(), -1);
8079  }
8080
8081  protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) {
8082    if (element == null) 
8083      return;
8084    Complex t;
8085    if (Utilities.noString(parentType))
8086      t = parent;
8087    else {
8088      t = parent.predicate("fhir:"+parentType+'.'+name);
8089    }
8090    composeDomainResource(t, "Goal", name, element, index);
8091    for (int i = 0; i < element.getIdentifier().size(); i++)
8092      composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i);
8093    if (element.hasLifecycleStatusElement())
8094      composeEnum(t, "Goal", "lifecycleStatus", element.getLifecycleStatusElement(), -1);
8095    if (element.hasAchievementStatus())
8096      composeCodeableConcept(t, "Goal", "achievementStatus", element.getAchievementStatus(), -1);
8097    for (int i = 0; i < element.getCategory().size(); i++)
8098      composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i);
8099    if (element.hasPriority())
8100      composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1);
8101    if (element.hasDescription())
8102      composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1);
8103    if (element.hasSubject())
8104      composeReference(t, "Goal", "subject", element.getSubject(), -1);
8105    if (element.hasStart())
8106      composeType(t, "Goal", "start", element.getStart(), -1);
8107    for (int i = 0; i < element.getTarget().size(); i++)
8108      composeGoalGoalTargetComponent(t, "Goal", "target", element.getTarget().get(i), i);
8109    if (element.hasStatusDateElement())
8110      composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1);
8111    if (element.hasStatusReasonElement())
8112      composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1);
8113    if (element.hasExpressedBy())
8114      composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1);
8115    for (int i = 0; i < element.getAddresses().size(); i++)
8116      composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i);
8117    for (int i = 0; i < element.getNote().size(); i++)
8118      composeAnnotation(t, "Goal", "note", element.getNote().get(i), i);
8119    for (int i = 0; i < element.getOutcomeCode().size(); i++)
8120      composeCodeableConcept(t, "Goal", "outcomeCode", element.getOutcomeCode().get(i), i);
8121    for (int i = 0; i < element.getOutcomeReference().size(); i++)
8122      composeReference(t, "Goal", "outcomeReference", element.getOutcomeReference().get(i), i);
8123  }
8124
8125  protected void composeGoalGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent 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, "target", name, element, index);
8135    if (element.hasMeasure())
8136      composeCodeableConcept(t, "Goal", "measure", element.getMeasure(), -1);
8137    if (element.hasDetail())
8138      composeType(t, "Goal", "detail", element.getDetail(), -1);
8139    if (element.hasDue())
8140      composeType(t, "Goal", "due", element.getDue(), -1);
8141  }
8142
8143  protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) {
8144    if (element == null) 
8145      return;
8146    Complex t;
8147    if (Utilities.noString(parentType))
8148      t = parent;
8149    else {
8150      t = parent.predicate("fhir:"+parentType+'.'+name);
8151    }
8152    composeDomainResource(t, "GraphDefinition", name, element, index);
8153    if (element.hasUrlElement())
8154      composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1);
8155    if (element.hasVersionElement())
8156      composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1);
8157    if (element.hasNameElement())
8158      composeString(t, "GraphDefinition", "name", element.getNameElement(), -1);
8159    if (element.hasStatusElement())
8160      composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1);
8161    if (element.hasExperimentalElement())
8162      composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1);
8163    if (element.hasDateElement())
8164      composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1);
8165    if (element.hasPublisherElement())
8166      composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1);
8167    for (int i = 0; i < element.getContact().size(); i++)
8168      composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i);
8169    if (element.hasDescriptionElement())
8170      composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
8171    for (int i = 0; i < element.getUseContext().size(); i++)
8172      composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i);
8173    for (int i = 0; i < element.getJurisdiction().size(); i++)
8174      composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
8175    if (element.hasPurposeElement())
8176      composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1);
8177    if (element.hasStartElement())
8178      composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1);
8179    if (element.hasProfileElement())
8180      composeCanonical(t, "GraphDefinition", "profile", element.getProfileElement(), -1);
8181    for (int i = 0; i < element.getLink().size(); i++)
8182      composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i);
8183  }
8184
8185  protected void composeGraphDefinitionGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) {
8186    if (element == null) 
8187      return;
8188    Complex t;
8189    if (Utilities.noString(parentType))
8190      t = parent;
8191    else {
8192      t = parent.predicate("fhir:"+parentType+'.'+name);
8193    }
8194    composeBackboneElement(t, "link", name, element, index);
8195    if (element.hasPathElement())
8196      composeString(t, "GraphDefinition", "path", element.getPathElement(), -1);
8197    if (element.hasSliceNameElement())
8198      composeString(t, "GraphDefinition", "sliceName", element.getSliceNameElement(), -1);
8199    if (element.hasMinElement())
8200      composeInteger(t, "GraphDefinition", "min", element.getMinElement(), -1);
8201    if (element.hasMaxElement())
8202      composeString(t, "GraphDefinition", "max", element.getMaxElement(), -1);
8203    if (element.hasDescriptionElement())
8204      composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
8205    for (int i = 0; i < element.getTarget().size(); i++)
8206      composeGraphDefinitionGraphDefinitionLinkTargetComponent(t, "GraphDefinition", "target", element.getTarget().get(i), i);
8207  }
8208
8209  protected void composeGraphDefinitionGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) {
8210    if (element == null) 
8211      return;
8212    Complex t;
8213    if (Utilities.noString(parentType))
8214      t = parent;
8215    else {
8216      t = parent.predicate("fhir:"+parentType+'.'+name);
8217    }
8218    composeBackboneElement(t, "target", name, element, index);
8219    if (element.hasTypeElement())
8220      composeCode(t, "GraphDefinition", "type", element.getTypeElement(), -1);
8221    if (element.hasParamsElement())
8222      composeString(t, "GraphDefinition", "params", element.getParamsElement(), -1);
8223    if (element.hasProfileElement())
8224      composeCanonical(t, "GraphDefinition", "profile", element.getProfileElement(), -1);
8225    for (int i = 0; i < element.getCompartment().size(); i++)
8226      composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinition", "compartment", element.getCompartment().get(i), i);
8227    for (int i = 0; i < element.getLink().size(); i++)
8228      composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i);
8229  }
8230
8231  protected void composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent element, int index) {
8232    if (element == null) 
8233      return;
8234    Complex t;
8235    if (Utilities.noString(parentType))
8236      t = parent;
8237    else {
8238      t = parent.predicate("fhir:"+parentType+'.'+name);
8239    }
8240    composeBackboneElement(t, "compartment", name, element, index);
8241    if (element.hasUseElement())
8242      composeEnum(t, "GraphDefinition", "use", element.getUseElement(), -1);
8243    if (element.hasCodeElement())
8244      composeEnum(t, "GraphDefinition", "code", element.getCodeElement(), -1);
8245    if (element.hasRuleElement())
8246      composeEnum(t, "GraphDefinition", "rule", element.getRuleElement(), -1);
8247    if (element.hasExpressionElement())
8248      composeString(t, "GraphDefinition", "expression", element.getExpressionElement(), -1);
8249    if (element.hasDescriptionElement())
8250      composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
8251  }
8252
8253  protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) {
8254    if (element == null) 
8255      return;
8256    Complex t;
8257    if (Utilities.noString(parentType))
8258      t = parent;
8259    else {
8260      t = parent.predicate("fhir:"+parentType+'.'+name);
8261    }
8262    composeDomainResource(t, "Group", name, element, index);
8263    for (int i = 0; i < element.getIdentifier().size(); i++)
8264      composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i);
8265    if (element.hasActiveElement())
8266      composeBoolean(t, "Group", "active", element.getActiveElement(), -1);
8267    if (element.hasTypeElement())
8268      composeEnum(t, "Group", "type", element.getTypeElement(), -1);
8269    if (element.hasActualElement())
8270      composeBoolean(t, "Group", "actual", element.getActualElement(), -1);
8271    if (element.hasCode())
8272      composeCodeableConcept(t, "Group", "code", element.getCode(), -1);
8273    if (element.hasNameElement())
8274      composeString(t, "Group", "name", element.getNameElement(), -1);
8275    if (element.hasQuantityElement())
8276      composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1);
8277    if (element.hasManagingEntity())
8278      composeReference(t, "Group", "managingEntity", element.getManagingEntity(), -1);
8279    for (int i = 0; i < element.getCharacteristic().size(); i++)
8280      composeGroupGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i);
8281    for (int i = 0; i < element.getMember().size(); i++)
8282      composeGroupGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i);
8283  }
8284
8285  protected void composeGroupGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) {
8286    if (element == null) 
8287      return;
8288    Complex t;
8289    if (Utilities.noString(parentType))
8290      t = parent;
8291    else {
8292      t = parent.predicate("fhir:"+parentType+'.'+name);
8293    }
8294    composeBackboneElement(t, "characteristic", name, element, index);
8295    if (element.hasCode())
8296      composeCodeableConcept(t, "Group", "code", element.getCode(), -1);
8297    if (element.hasValue())
8298      composeType(t, "Group", "value", element.getValue(), -1);
8299    if (element.hasExcludeElement())
8300      composeBoolean(t, "Group", "exclude", element.getExcludeElement(), -1);
8301    if (element.hasPeriod())
8302      composePeriod(t, "Group", "period", element.getPeriod(), -1);
8303  }
8304
8305  protected void composeGroupGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) {
8306    if (element == null) 
8307      return;
8308    Complex t;
8309    if (Utilities.noString(parentType))
8310      t = parent;
8311    else {
8312      t = parent.predicate("fhir:"+parentType+'.'+name);
8313    }
8314    composeBackboneElement(t, "member", name, element, index);
8315    if (element.hasEntity())
8316      composeReference(t, "Group", "entity", element.getEntity(), -1);
8317    if (element.hasPeriod())
8318      composePeriod(t, "Group", "period", element.getPeriod(), -1);
8319    if (element.hasInactiveElement())
8320      composeBoolean(t, "Group", "inactive", element.getInactiveElement(), -1);
8321  }
8322
8323  protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) {
8324    if (element == null) 
8325      return;
8326    Complex t;
8327    if (Utilities.noString(parentType))
8328      t = parent;
8329    else {
8330      t = parent.predicate("fhir:"+parentType+'.'+name);
8331    }
8332    composeDomainResource(t, "GuidanceResponse", name, element, index);
8333    if (element.hasRequestIdentifier())
8334      composeIdentifier(t, "GuidanceResponse", "requestIdentifier", element.getRequestIdentifier(), -1);
8335    for (int i = 0; i < element.getIdentifier().size(); i++)
8336      composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier().get(i), i);
8337    if (element.hasModule())
8338      composeType(t, "GuidanceResponse", "module", element.getModule(), -1);
8339    if (element.hasStatusElement())
8340      composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1);
8341    if (element.hasSubject())
8342      composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1);
8343    if (element.hasEncounter())
8344      composeReference(t, "GuidanceResponse", "encounter", element.getEncounter(), -1);
8345    if (element.hasOccurrenceDateTimeElement())
8346      composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1);
8347    if (element.hasPerformer())
8348      composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1);
8349    for (int i = 0; i < element.getReasonCode().size(); i++)
8350      composeCodeableConcept(t, "GuidanceResponse", "reasonCode", element.getReasonCode().get(i), i);
8351    for (int i = 0; i < element.getReasonReference().size(); i++)
8352      composeReference(t, "GuidanceResponse", "reasonReference", element.getReasonReference().get(i), i);
8353    for (int i = 0; i < element.getNote().size(); i++)
8354      composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i);
8355    for (int i = 0; i < element.getEvaluationMessage().size(); i++)
8356      composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i);
8357    if (element.hasOutputParameters())
8358      composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1);
8359    if (element.hasResult())
8360      composeReference(t, "GuidanceResponse", "result", element.getResult(), -1);
8361    for (int i = 0; i < element.getDataRequirement().size(); i++)
8362      composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i);
8363  }
8364
8365  protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) {
8366    if (element == null) 
8367      return;
8368    Complex t;
8369    if (Utilities.noString(parentType))
8370      t = parent;
8371    else {
8372      t = parent.predicate("fhir:"+parentType+'.'+name);
8373    }
8374    composeDomainResource(t, "HealthcareService", name, element, index);
8375    for (int i = 0; i < element.getIdentifier().size(); i++)
8376      composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i);
8377    if (element.hasActiveElement())
8378      composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1);
8379    if (element.hasProvidedBy())
8380      composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1);
8381    for (int i = 0; i < element.getCategory().size(); i++)
8382      composeCodeableConcept(t, "HealthcareService", "category", element.getCategory().get(i), i);
8383    for (int i = 0; i < element.getType().size(); i++)
8384      composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i);
8385    for (int i = 0; i < element.getSpecialty().size(); i++)
8386      composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i);
8387    for (int i = 0; i < element.getLocation().size(); i++)
8388      composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i);
8389    if (element.hasNameElement())
8390      composeString(t, "HealthcareService", "name", element.getNameElement(), -1);
8391    if (element.hasCommentElement())
8392      composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1);
8393    if (element.hasExtraDetailsElement())
8394      composeMarkdown(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1);
8395    if (element.hasPhoto())
8396      composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1);
8397    for (int i = 0; i < element.getTelecom().size(); i++)
8398      composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i);
8399    for (int i = 0; i < element.getCoverageArea().size(); i++)
8400      composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i);
8401    for (int i = 0; i < element.getServiceProvisionCode().size(); i++)
8402      composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i);
8403    for (int i = 0; i < element.getEligibility().size(); i++)
8404      composeHealthcareServiceHealthcareServiceEligibilityComponent(t, "HealthcareService", "eligibility", element.getEligibility().get(i), i);
8405    for (int i = 0; i < element.getProgram().size(); i++)
8406      composeCodeableConcept(t, "HealthcareService", "program", element.getProgram().get(i), i);
8407    for (int i = 0; i < element.getCharacteristic().size(); i++)
8408      composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i);
8409    for (int i = 0; i < element.getCommunication().size(); i++)
8410      composeCodeableConcept(t, "HealthcareService", "communication", element.getCommunication().get(i), i);
8411    for (int i = 0; i < element.getReferralMethod().size(); i++)
8412      composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i);
8413    if (element.hasAppointmentRequiredElement())
8414      composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1);
8415    for (int i = 0; i < element.getAvailableTime().size(); i++)
8416      composeHealthcareServiceHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i);
8417    for (int i = 0; i < element.getNotAvailable().size(); i++)
8418      composeHealthcareServiceHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i);
8419    if (element.hasAvailabilityExceptionsElement())
8420      composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1);
8421    for (int i = 0; i < element.getEndpoint().size(); i++)
8422      composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i);
8423  }
8424
8425  protected void composeHealthcareServiceHealthcareServiceEligibilityComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceEligibilityComponent element, int index) {
8426    if (element == null) 
8427      return;
8428    Complex t;
8429    if (Utilities.noString(parentType))
8430      t = parent;
8431    else {
8432      t = parent.predicate("fhir:"+parentType+'.'+name);
8433    }
8434    composeBackboneElement(t, "eligibility", name, element, index);
8435    if (element.hasCode())
8436      composeCodeableConcept(t, "HealthcareService", "code", element.getCode(), -1);
8437    if (element.hasCommentElement())
8438      composeMarkdown(t, "HealthcareService", "comment", element.getCommentElement(), -1);
8439  }
8440
8441  protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) {
8442    if (element == null) 
8443      return;
8444    Complex t;
8445    if (Utilities.noString(parentType))
8446      t = parent;
8447    else {
8448      t = parent.predicate("fhir:"+parentType+'.'+name);
8449    }
8450    composeBackboneElement(t, "availableTime", name, element, index);
8451    for (int i = 0; i < element.getDaysOfWeek().size(); i++)
8452      composeEnum(t, "HealthcareService", "daysOfWeek", element.getDaysOfWeek().get(i), i);
8453    if (element.hasAllDayElement())
8454      composeBoolean(t, "HealthcareService", "allDay", element.getAllDayElement(), -1);
8455    if (element.hasAvailableStartTimeElement())
8456      composeTime(t, "HealthcareService", "availableStartTime", element.getAvailableStartTimeElement(), -1);
8457    if (element.hasAvailableEndTimeElement())
8458      composeTime(t, "HealthcareService", "availableEndTime", element.getAvailableEndTimeElement(), -1);
8459  }
8460
8461  protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) {
8462    if (element == null) 
8463      return;
8464    Complex t;
8465    if (Utilities.noString(parentType))
8466      t = parent;
8467    else {
8468      t = parent.predicate("fhir:"+parentType+'.'+name);
8469    }
8470    composeBackboneElement(t, "notAvailable", name, element, index);
8471    if (element.hasDescriptionElement())
8472      composeString(t, "HealthcareService", "description", element.getDescriptionElement(), -1);
8473    if (element.hasDuring())
8474      composePeriod(t, "HealthcareService", "during", element.getDuring(), -1);
8475  }
8476
8477  protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) {
8478    if (element == null) 
8479      return;
8480    Complex t;
8481    if (Utilities.noString(parentType))
8482      t = parent;
8483    else {
8484      t = parent.predicate("fhir:"+parentType+'.'+name);
8485    }
8486    composeDomainResource(t, "ImagingStudy", name, element, index);
8487    for (int i = 0; i < element.getIdentifier().size(); i++)
8488      composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i);
8489    if (element.hasStatusElement())
8490      composeEnum(t, "ImagingStudy", "status", element.getStatusElement(), -1);
8491    for (int i = 0; i < element.getModality().size(); i++)
8492      composeCoding(t, "ImagingStudy", "modality", element.getModality().get(i), i);
8493    if (element.hasSubject())
8494      composeReference(t, "ImagingStudy", "subject", element.getSubject(), -1);
8495    if (element.hasEncounter())
8496      composeReference(t, "ImagingStudy", "encounter", element.getEncounter(), -1);
8497    if (element.hasStartedElement())
8498      composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1);
8499    for (int i = 0; i < element.getBasedOn().size(); i++)
8500      composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i);
8501    if (element.hasReferrer())
8502      composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1);
8503    for (int i = 0; i < element.getInterpreter().size(); i++)
8504      composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i);
8505    for (int i = 0; i < element.getEndpoint().size(); i++)
8506      composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i);
8507    if (element.hasNumberOfSeriesElement())
8508      composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1);
8509    if (element.hasNumberOfInstancesElement())
8510      composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
8511    if (element.hasProcedureReference())
8512      composeReference(t, "ImagingStudy", "procedureReference", element.getProcedureReference(), -1);
8513    for (int i = 0; i < element.getProcedureCode().size(); i++)
8514      composeCodeableConcept(t, "ImagingStudy", "procedureCode", element.getProcedureCode().get(i), i);
8515    if (element.hasLocation())
8516      composeReference(t, "ImagingStudy", "location", element.getLocation(), -1);
8517    for (int i = 0; i < element.getReasonCode().size(); i++)
8518      composeCodeableConcept(t, "ImagingStudy", "reasonCode", element.getReasonCode().get(i), i);
8519    for (int i = 0; i < element.getReasonReference().size(); i++)
8520      composeReference(t, "ImagingStudy", "reasonReference", element.getReasonReference().get(i), i);
8521    for (int i = 0; i < element.getNote().size(); i++)
8522      composeAnnotation(t, "ImagingStudy", "note", element.getNote().get(i), i);
8523    if (element.hasDescriptionElement())
8524      composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1);
8525    for (int i = 0; i < element.getSeries().size(); i++)
8526      composeImagingStudyImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i);
8527  }
8528
8529  protected void composeImagingStudyImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) {
8530    if (element == null) 
8531      return;
8532    Complex t;
8533    if (Utilities.noString(parentType))
8534      t = parent;
8535    else {
8536      t = parent.predicate("fhir:"+parentType+'.'+name);
8537    }
8538    composeBackboneElement(t, "series", name, element, index);
8539    if (element.hasUidElement())
8540      composeId(t, "ImagingStudy", "uid", element.getUidElement(), -1);
8541    if (element.hasNumberElement())
8542      composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1);
8543    if (element.hasModality())
8544      composeCoding(t, "ImagingStudy", "modality", element.getModality(), -1);
8545    if (element.hasDescriptionElement())
8546      composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1);
8547    if (element.hasNumberOfInstancesElement())
8548      composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
8549    for (int i = 0; i < element.getEndpoint().size(); i++)
8550      composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i);
8551    if (element.hasBodySite())
8552      composeCoding(t, "ImagingStudy", "bodySite", element.getBodySite(), -1);
8553    if (element.hasLaterality())
8554      composeCoding(t, "ImagingStudy", "laterality", element.getLaterality(), -1);
8555    for (int i = 0; i < element.getSpecimen().size(); i++)
8556      composeReference(t, "ImagingStudy", "specimen", element.getSpecimen().get(i), i);
8557    if (element.hasStartedElement())
8558      composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1);
8559    for (int i = 0; i < element.getPerformer().size(); i++)
8560      composeImagingStudyImagingStudySeriesPerformerComponent(t, "ImagingStudy", "performer", element.getPerformer().get(i), i);
8561    for (int i = 0; i < element.getInstance().size(); i++)
8562      composeImagingStudyImagingStudySeriesInstanceComponent(t, "ImagingStudy", "instance", element.getInstance().get(i), i);
8563  }
8564
8565  protected void composeImagingStudyImagingStudySeriesPerformerComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesPerformerComponent element, int index) {
8566    if (element == null) 
8567      return;
8568    Complex t;
8569    if (Utilities.noString(parentType))
8570      t = parent;
8571    else {
8572      t = parent.predicate("fhir:"+parentType+'.'+name);
8573    }
8574    composeBackboneElement(t, "performer", name, element, index);
8575    if (element.hasFunction())
8576      composeCodeableConcept(t, "ImagingStudy", "function", element.getFunction(), -1);
8577    if (element.hasActor())
8578      composeReference(t, "ImagingStudy", "actor", element.getActor(), -1);
8579  }
8580
8581  protected void composeImagingStudyImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) {
8582    if (element == null) 
8583      return;
8584    Complex t;
8585    if (Utilities.noString(parentType))
8586      t = parent;
8587    else {
8588      t = parent.predicate("fhir:"+parentType+'.'+name);
8589    }
8590    composeBackboneElement(t, "instance", name, element, index);
8591    if (element.hasUidElement())
8592      composeId(t, "ImagingStudy", "uid", element.getUidElement(), -1);
8593    if (element.hasSopClass())
8594      composeCoding(t, "ImagingStudy", "sopClass", element.getSopClass(), -1);
8595    if (element.hasNumberElement())
8596      composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1);
8597    if (element.hasTitleElement())
8598      composeString(t, "ImagingStudy", "title", element.getTitleElement(), -1);
8599  }
8600
8601  protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) {
8602    if (element == null) 
8603      return;
8604    Complex t;
8605    if (Utilities.noString(parentType))
8606      t = parent;
8607    else {
8608      t = parent.predicate("fhir:"+parentType+'.'+name);
8609    }
8610    composeDomainResource(t, "Immunization", name, element, index);
8611    for (int i = 0; i < element.getIdentifier().size(); i++)
8612      composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i);
8613    if (element.hasStatusElement())
8614      composeEnum(t, "Immunization", "status", element.getStatusElement(), -1);
8615    if (element.hasStatusReason())
8616      composeCodeableConcept(t, "Immunization", "statusReason", element.getStatusReason(), -1);
8617    if (element.hasVaccineCode())
8618      composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1);
8619    if (element.hasPatient())
8620      composeReference(t, "Immunization", "patient", element.getPatient(), -1);
8621    if (element.hasEncounter())
8622      composeReference(t, "Immunization", "encounter", element.getEncounter(), -1);
8623    if (element.hasOccurrence())
8624      composeType(t, "Immunization", "occurrence", element.getOccurrence(), -1);
8625    if (element.hasRecordedElement())
8626      composeDateTime(t, "Immunization", "recorded", element.getRecordedElement(), -1);
8627    if (element.hasPrimarySourceElement())
8628      composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1);
8629    if (element.hasReportOrigin())
8630      composeCodeableConcept(t, "Immunization", "reportOrigin", element.getReportOrigin(), -1);
8631    if (element.hasLocation())
8632      composeReference(t, "Immunization", "location", element.getLocation(), -1);
8633    if (element.hasManufacturer())
8634      composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1);
8635    if (element.hasLotNumberElement())
8636      composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1);
8637    if (element.hasExpirationDateElement())
8638      composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1);
8639    if (element.hasSite())
8640      composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1);
8641    if (element.hasRoute())
8642      composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1);
8643    if (element.hasDoseQuantity())
8644      composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1);
8645    for (int i = 0; i < element.getPerformer().size(); i++)
8646      composeImmunizationImmunizationPerformerComponent(t, "Immunization", "performer", element.getPerformer().get(i), i);
8647    for (int i = 0; i < element.getNote().size(); i++)
8648      composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i);
8649    for (int i = 0; i < element.getReasonCode().size(); i++)
8650      composeCodeableConcept(t, "Immunization", "reasonCode", element.getReasonCode().get(i), i);
8651    for (int i = 0; i < element.getReasonReference().size(); i++)
8652      composeReference(t, "Immunization", "reasonReference", element.getReasonReference().get(i), i);
8653    if (element.hasIsSubpotentElement())
8654      composeBoolean(t, "Immunization", "isSubpotent", element.getIsSubpotentElement(), -1);
8655    for (int i = 0; i < element.getSubpotentReason().size(); i++)
8656      composeCodeableConcept(t, "Immunization", "subpotentReason", element.getSubpotentReason().get(i), i);
8657    for (int i = 0; i < element.getEducation().size(); i++)
8658      composeImmunizationImmunizationEducationComponent(t, "Immunization", "education", element.getEducation().get(i), i);
8659    for (int i = 0; i < element.getProgramEligibility().size(); i++)
8660      composeCodeableConcept(t, "Immunization", "programEligibility", element.getProgramEligibility().get(i), i);
8661    if (element.hasFundingSource())
8662      composeCodeableConcept(t, "Immunization", "fundingSource", element.getFundingSource(), -1);
8663    for (int i = 0; i < element.getReaction().size(); i++)
8664      composeImmunizationImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i);
8665    for (int i = 0; i < element.getProtocolApplied().size(); i++)
8666      composeImmunizationImmunizationProtocolAppliedComponent(t, "Immunization", "protocolApplied", element.getProtocolApplied().get(i), i);
8667  }
8668
8669  protected void composeImmunizationImmunizationPerformerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPerformerComponent element, int index) {
8670    if (element == null) 
8671      return;
8672    Complex t;
8673    if (Utilities.noString(parentType))
8674      t = parent;
8675    else {
8676      t = parent.predicate("fhir:"+parentType+'.'+name);
8677    }
8678    composeBackboneElement(t, "performer", name, element, index);
8679    if (element.hasFunction())
8680      composeCodeableConcept(t, "Immunization", "function", element.getFunction(), -1);
8681    if (element.hasActor())
8682      composeReference(t, "Immunization", "actor", element.getActor(), -1);
8683  }
8684
8685  protected void composeImmunizationImmunizationEducationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationEducationComponent element, int index) {
8686    if (element == null) 
8687      return;
8688    Complex t;
8689    if (Utilities.noString(parentType))
8690      t = parent;<