
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;<