001package org.hl7.fhir.r4.formats; 002 003/*- 004 * #%L 005 * org.hl7.fhir.r4 006 * %% 007 * Copyright (C) 2014 - 2019 Health Level 7 008 * %% 009 * Licensed under the Apache License, Version 2.0 (the "License"); 010 * you may not use this file except in compliance with the License. 011 * You may obtain a copy of the License at 012 * 013 * http://www.apache.org/licenses/LICENSE-2.0 014 * 015 * Unless required by applicable law or agreed to in writing, software 016 * distributed under the License is distributed on an "AS IS" BASIS, 017 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 018 * See the License for the specific language governing permissions and 019 * limitations under the License. 020 * #L% 021 */ 022 023/* 024 Copyright (c) 2011+, HL7, Inc. 025 All rights reserved. 026 027 Redistribution and use in source and binary forms, with or without modification, 028 are permitted provided that the following conditions are met: 029 030 * Redistributions of source code must retain the above copyright notice, this 031 list of conditions and the following disclaimer. 032 * Redistributions in binary form must reproduce the above copyright notice, 033 this list of conditions and the following disclaimer in the documentation 034 and/or other materials provided with the distribution. 035 * Neither the name of HL7 nor the names of its contributors may be used to 036 endorse or promote products derived from this software without specific 037 prior written permission. 038 039 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 040 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 041 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 042 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 043 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 044 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 045 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 046 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 047 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 048 POSSIBILITY OF SUCH DAMAGE. 049 050*/ 051 052// Generated on Thu, Dec 13, 2018 14:07+1100 for FHIR v4.0.0 053import org.hl7.fhir.r4.model.*; 054import org.hl7.fhir.r4.utils.formats.Turtle.Complex; 055import org.hl7.fhir.utilities.Utilities; 056 057public class RdfParser extends RdfParserBase { 058 059 public RdfParser() { 060 super(); 061 } 062 063 public RdfParser(boolean allowUnknownContent) { 064 super(); 065 setAllowUnknownContent(allowUnknownContent); 066 } 067 068 069 protected void composeElement(Complex t, String parentType, String name, Element element, int index) { 070 if (element == null) 071 return; 072 if (index > -1) 073 t.predicate("fhir:index", Integer.toString(index)); 074 if (element.hasIdElement()) 075 composeString(t, "Element", "id", element.getIdElement(), -1); 076 for (int i = 0; i < element.getExtension().size(); i++) 077 composeExtension(t, "Element", "extension", element.getExtension().get(i), i); 078 } 079 080 protected void composeBackboneElement(Complex t, String tType, String name, BackboneElement element, int index) { 081 composeElement(t, tType, name, element, index); 082 for (int i = 0; i < element.getModifierExtension().size(); i++) 083 composeExtension(t, "Element", "modifierExtension", element.getModifierExtension().get(i), i); 084 } 085 086 private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) { 087 if (value == null) 088 return; 089 Complex t = parent.predicate("fhir:"+parentType+"."+name); 090 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 091 composeElement(t, parentType, name, value, index); 092 decorateCode(t, value); 093 } 094 095 096 protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) { 097 if (value == null) 098 return; 099 Complex t = parent.predicate("fhir:"+parentType+"."+name); 100 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 101 composeElement(t, parentType, name, value, index); 102 } 103 104 protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) { 105 if (value == null) 106 return; 107 Complex t = parent.predicate("fhir:"+parentType+"."+name); 108 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 109 composeElement(t, parentType, name, value, index); 110 } 111 112 protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) { 113 if (value == null) 114 return; 115 Complex t = parent.predicate("fhir:"+parentType+"."+name); 116 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 117 composeElement(t, parentType, name, value, index); 118 decorateCode(t, value); 119 } 120 121 protected void composeString(Complex parent, String parentType, String name, StringType value, int index) { 122 if (value == null) 123 return; 124 Complex t = parent.predicate("fhir:"+parentType+"."+name); 125 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 126 composeElement(t, parentType, name, value, index); 127 } 128 129 protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) { 130 if (value == null) 131 return; 132 Complex t = parent.predicate("fhir:"+parentType+"."+name); 133 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 134 composeElement(t, parentType, name, value, index); 135 } 136 137 protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) { 138 if (value == null) 139 return; 140 Complex t = parent.predicate("fhir:"+parentType+"."+name); 141 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 142 composeElement(t, parentType, name, value, index); 143 } 144 145 protected void composeCanonical(Complex parent, String parentType, String name, CanonicalType value, int index) { 146 if (value == null) 147 return; 148 Complex t = parent.predicate("fhir:"+parentType+"."+name); 149 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 150 composeElement(t, parentType, name, value, index); 151 } 152 153 protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) { 154 if (value == null) 155 return; 156 Complex t = parent.predicate("fhir:"+parentType+"."+name); 157 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 158 composeElement(t, parentType, name, value, index); 159 } 160 161 protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) { 162 if (value == null) 163 return; 164 Complex t = parent.predicate("fhir:"+parentType+"."+name); 165 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 166 composeElement(t, parentType, name, value, index); 167 } 168 169 protected void composeUrl(Complex parent, String parentType, String name, UrlType value, int index) { 170 if (value == null) 171 return; 172 Complex t = parent.predicate("fhir:"+parentType+"."+name); 173 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 174 composeElement(t, parentType, name, value, index); 175 } 176 177 protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) { 178 if (value == null) 179 return; 180 Complex t = parent.predicate("fhir:"+parentType+"."+name); 181 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 182 composeElement(t, parentType, name, value, index); 183 } 184 185 protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) { 186 if (value == null) 187 return; 188 Complex t = parent.predicate("fhir:"+parentType+"."+name); 189 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 190 composeElement(t, parentType, name, value, index); 191 } 192 193 protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) { 194 if (value == null) 195 return; 196 Complex t = parent.predicate("fhir:"+parentType+"."+name); 197 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 198 composeElement(t, parentType, name, value, index); 199 } 200 201 protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) { 202 if (value == null) 203 return; 204 Complex t = parent.predicate("fhir:"+parentType+"."+name); 205 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 206 composeElement(t, parentType, name, value, index); 207 } 208 209 protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) { 210 if (value == null) 211 return; 212 Complex t = parent.predicate("fhir:"+parentType+"."+name); 213 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 214 composeElement(t, parentType, name, value, index); 215 } 216 217 protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) { 218 if (value == null) 219 return; 220 Complex t = parent.predicate("fhir:"+parentType+"."+name); 221 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 222 composeElement(t, parentType, name, value, index); 223 } 224 225 protected void composeId(Complex parent, String parentType, String name, IdType value, int index) { 226 if (value == null) 227 return; 228 Complex t = parent.predicate("fhir:"+parentType+"."+name); 229 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 230 composeElement(t, parentType, name, value, index); 231 } 232 233 protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) { 234 if (value == null) 235 return; 236 Complex t = parent.predicate("fhir:"+parentType+"."+name); 237 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 238 composeElement(t, parentType, name, value, index); 239 } 240 241 protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) { 242 if (value == null) 243 return; 244 Complex t = parent.predicate("fhir:"+parentType+"."+name); 245 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 246 composeElement(t, parentType, name, value, index); 247 } 248 249 protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) { 250 if (element == null) 251 return; 252 Complex t; 253 if (Utilities.noString(parentType)) 254 t = parent; 255 else { 256 t = parent.predicate("fhir:"+parentType+'.'+name); 257 } 258 composeElement(t, "Extension", name, element, index); 259 if (element.hasUrlElement()) 260 composeUri(t, "Extension", "url", element.getUrlElement(), -1); 261 if (element.hasValue()) 262 composeType(t, "Extension", "value", element.getValue(), -1); 263 } 264 265 protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) { 266 if (element == null) 267 return; 268 Complex t; 269 if (Utilities.noString(parentType)) 270 t = parent; 271 else { 272 t = parent.predicate("fhir:"+parentType+'.'+name); 273 } 274 composeElement(t, "Narrative", name, element, index); 275 if (element.hasStatusElement()) 276 composeEnum(t, "Narrative", "status", element.getStatusElement(), -1); 277 if (element.hasDiv()) 278 composeXhtml(t, "Narrative", "div", element.getDiv(), -1); 279 } 280 281 protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) { 282 if (element == null) 283 return; 284 Complex t; 285 if (Utilities.noString(parentType)) 286 t = parent; 287 else { 288 t = parent.predicate("fhir:"+parentType+'.'+name); 289 } 290 composeElement(t, "Meta", name, element, index); 291 if (element.hasVersionIdElement()) 292 composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1); 293 if (element.hasLastUpdatedElement()) 294 composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1); 295 if (element.hasSourceElement()) 296 composeUri(t, "Meta", "source", element.getSourceElement(), -1); 297 for (int i = 0; i < element.getProfile().size(); i++) 298 composeCanonical(t, "Meta", "profile", element.getProfile().get(i), i); 299 for (int i = 0; i < element.getSecurity().size(); i++) 300 composeCoding(t, "Meta", "security", element.getSecurity().get(i), i); 301 for (int i = 0; i < element.getTag().size(); i++) 302 composeCoding(t, "Meta", "tag", element.getTag().get(i), i); 303 } 304 305 protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) { 306 if (element == null) 307 return; 308 Complex t; 309 if (Utilities.noString(parentType)) 310 t = parent; 311 else { 312 t = parent.predicate("fhir:"+parentType+'.'+name); 313 } 314 composeElement(t, "Address", name, element, index); 315 if (element.hasUseElement()) 316 composeEnum(t, "Address", "use", element.getUseElement(), -1); 317 if (element.hasTypeElement()) 318 composeEnum(t, "Address", "type", element.getTypeElement(), -1); 319 if (element.hasTextElement()) 320 composeString(t, "Address", "text", element.getTextElement(), -1); 321 for (int i = 0; i < element.getLine().size(); i++) 322 composeString(t, "Address", "line", element.getLine().get(i), i); 323 if (element.hasCityElement()) 324 composeString(t, "Address", "city", element.getCityElement(), -1); 325 if (element.hasDistrictElement()) 326 composeString(t, "Address", "district", element.getDistrictElement(), -1); 327 if (element.hasStateElement()) 328 composeString(t, "Address", "state", element.getStateElement(), -1); 329 if (element.hasPostalCodeElement()) 330 composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1); 331 if (element.hasCountryElement()) 332 composeString(t, "Address", "country", element.getCountryElement(), -1); 333 if (element.hasPeriod()) 334 composePeriod(t, "Address", "period", element.getPeriod(), -1); 335 } 336 337 protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) { 338 if (element == null) 339 return; 340 Complex t; 341 if (Utilities.noString(parentType)) 342 t = parent; 343 else { 344 t = parent.predicate("fhir:"+parentType+'.'+name); 345 } 346 composeElement(t, "Contributor", name, element, index); 347 if (element.hasTypeElement()) 348 composeEnum(t, "Contributor", "type", element.getTypeElement(), -1); 349 if (element.hasNameElement()) 350 composeString(t, "Contributor", "name", element.getNameElement(), -1); 351 for (int i = 0; i < element.getContact().size(); i++) 352 composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i); 353 } 354 355 protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) { 356 if (element == null) 357 return; 358 Complex t; 359 if (Utilities.noString(parentType)) 360 t = parent; 361 else { 362 t = parent.predicate("fhir:"+parentType+'.'+name); 363 } 364 composeElement(t, "Attachment", name, element, index); 365 if (element.hasContentTypeElement()) 366 composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1); 367 if (element.hasLanguageElement()) 368 composeCode(t, "Attachment", "language", element.getLanguageElement(), -1); 369 if (element.hasDataElement()) 370 composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1); 371 if (element.hasUrlElement()) 372 composeUrl(t, "Attachment", "url", element.getUrlElement(), -1); 373 if (element.hasSizeElement()) 374 composeUnsignedInt(t, "Attachment", "size", element.getSizeElement(), -1); 375 if (element.hasHashElement()) 376 composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1); 377 if (element.hasTitleElement()) 378 composeString(t, "Attachment", "title", element.getTitleElement(), -1); 379 if (element.hasCreationElement()) 380 composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1); 381 } 382 383 protected void composeCount(Complex parent, String parentType, String name, Count element, int index) { 384 if (element == null) 385 return; 386 Complex t; 387 if (Utilities.noString(parentType)) 388 t = parent; 389 else { 390 t = parent.predicate("fhir:"+parentType+'.'+name); 391 } 392 composeElement(t, "Count", name, element, index); 393 } 394 395 protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) { 396 if (element == null) 397 return; 398 Complex t; 399 if (Utilities.noString(parentType)) 400 t = parent; 401 else { 402 t = parent.predicate("fhir:"+parentType+'.'+name); 403 } 404 composeElement(t, "DataRequirement", name, element, index); 405 if (element.hasTypeElement()) 406 composeCode(t, "DataRequirement", "type", element.getTypeElement(), -1); 407 for (int i = 0; i < element.getProfile().size(); i++) 408 composeCanonical(t, "DataRequirement", "profile", element.getProfile().get(i), i); 409 if (element.hasSubject()) 410 composeType(t, "DataRequirement", "subject", element.getSubject(), -1); 411 for (int i = 0; i < element.getMustSupport().size(); i++) 412 composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i); 413 for (int i = 0; i < element.getCodeFilter().size(); i++) 414 composeDataRequirementDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i); 415 for (int i = 0; i < element.getDateFilter().size(); i++) 416 composeDataRequirementDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i); 417 if (element.hasLimitElement()) 418 composePositiveInt(t, "DataRequirement", "limit", element.getLimitElement(), -1); 419 for (int i = 0; i < element.getSort().size(); i++) 420 composeDataRequirementDataRequirementSortComponent(t, "DataRequirement", "sort", element.getSort().get(i), i); 421 } 422 423 protected void composeDataRequirementDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) { 424 if (element == null) 425 return; 426 Complex t; 427 if (Utilities.noString(parentType)) 428 t = parent; 429 else { 430 t = parent.predicate("fhir:"+parentType+'.'+name); 431 } 432 composeElement(t, "codeFilter", name, element, index); 433 if (element.hasPathElement()) 434 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 435 if (element.hasSearchParamElement()) 436 composeString(t, "DataRequirement", "searchParam", element.getSearchParamElement(), -1); 437 if (element.hasValueSetElement()) 438 composeCanonical(t, "DataRequirement", "valueSet", element.getValueSetElement(), -1); 439 for (int i = 0; i < element.getCode().size(); i++) 440 composeCoding(t, "DataRequirement", "code", element.getCode().get(i), i); 441 } 442 443 protected void composeDataRequirementDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) { 444 if (element == null) 445 return; 446 Complex t; 447 if (Utilities.noString(parentType)) 448 t = parent; 449 else { 450 t = parent.predicate("fhir:"+parentType+'.'+name); 451 } 452 composeElement(t, "dateFilter", name, element, index); 453 if (element.hasPathElement()) 454 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 455 if (element.hasSearchParamElement()) 456 composeString(t, "DataRequirement", "searchParam", element.getSearchParamElement(), -1); 457 if (element.hasValue()) 458 composeType(t, "DataRequirement", "value", element.getValue(), -1); 459 } 460 461 protected void composeDataRequirementDataRequirementSortComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementSortComponent element, int index) { 462 if (element == null) 463 return; 464 Complex t; 465 if (Utilities.noString(parentType)) 466 t = parent; 467 else { 468 t = parent.predicate("fhir:"+parentType+'.'+name); 469 } 470 composeElement(t, "sort", name, element, index); 471 if (element.hasPathElement()) 472 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 473 if (element.hasDirectionElement()) 474 composeEnum(t, "DataRequirement", "direction", element.getDirectionElement(), -1); 475 } 476 477 protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) { 478 if (element == null) 479 return; 480 Complex t; 481 if (Utilities.noString(parentType)) 482 t = parent; 483 else { 484 t = parent.predicate("fhir:"+parentType+'.'+name); 485 } 486 composeElement(t, "Dosage", name, element, index); 487 if (element.hasSequenceElement()) 488 composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1); 489 if (element.hasTextElement()) 490 composeString(t, "Dosage", "text", element.getTextElement(), -1); 491 for (int i = 0; i < element.getAdditionalInstruction().size(); i++) 492 composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i); 493 if (element.hasPatientInstructionElement()) 494 composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1); 495 if (element.hasTiming()) 496 composeTiming(t, "Dosage", "timing", element.getTiming(), -1); 497 if (element.hasAsNeeded()) 498 composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1); 499 if (element.hasSite()) 500 composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1); 501 if (element.hasRoute()) 502 composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1); 503 if (element.hasMethod()) 504 composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1); 505 for (int i = 0; i < element.getDoseAndRate().size(); i++) 506 composeDosageDosageDoseAndRateComponent(t, "Dosage", "doseAndRate", element.getDoseAndRate().get(i), i); 507 if (element.hasMaxDosePerPeriod()) 508 composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1); 509 if (element.hasMaxDosePerAdministration()) 510 composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1); 511 if (element.hasMaxDosePerLifetime()) 512 composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1); 513 } 514 515 protected void composeDosageDosageDoseAndRateComponent(Complex parent, String parentType, String name, Dosage.DosageDoseAndRateComponent element, int index) { 516 if (element == null) 517 return; 518 Complex t; 519 if (Utilities.noString(parentType)) 520 t = parent; 521 else { 522 t = parent.predicate("fhir:"+parentType+'.'+name); 523 } 524 composeElement(t, "doseAndRate", name, element, index); 525 if (element.hasType()) 526 composeCodeableConcept(t, "Dosage", "type", element.getType(), -1); 527 if (element.hasDose()) 528 composeType(t, "Dosage", "dose", element.getDose(), -1); 529 if (element.hasRate()) 530 composeType(t, "Dosage", "rate", element.getRate(), -1); 531 } 532 533 protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) { 534 if (element == null) 535 return; 536 Complex t; 537 if (Utilities.noString(parentType)) 538 t = parent; 539 else { 540 t = parent.predicate("fhir:"+parentType+'.'+name); 541 } 542 composeElement(t, "Money", name, element, index); 543 if (element.hasValueElement()) 544 composeDecimal(t, "Money", "value", element.getValueElement(), -1); 545 if (element.hasCurrencyElement()) 546 composeCode(t, "Money", "currency", element.getCurrencyElement(), -1); 547 } 548 549 protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) { 550 if (element == null) 551 return; 552 Complex t; 553 if (Utilities.noString(parentType)) 554 t = parent; 555 else { 556 t = parent.predicate("fhir:"+parentType+'.'+name); 557 } 558 composeElement(t, "HumanName", name, element, index); 559 if (element.hasUseElement()) 560 composeEnum(t, "HumanName", "use", element.getUseElement(), -1); 561 if (element.hasTextElement()) 562 composeString(t, "HumanName", "text", element.getTextElement(), -1); 563 if (element.hasFamilyElement()) 564 composeString(t, "HumanName", "family", element.getFamilyElement(), -1); 565 for (int i = 0; i < element.getGiven().size(); i++) 566 composeString(t, "HumanName", "given", element.getGiven().get(i), i); 567 for (int i = 0; i < element.getPrefix().size(); i++) 568 composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i); 569 for (int i = 0; i < element.getSuffix().size(); i++) 570 composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i); 571 if (element.hasPeriod()) 572 composePeriod(t, "HumanName", "period", element.getPeriod(), -1); 573 } 574 575 protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) { 576 if (element == null) 577 return; 578 Complex t; 579 if (Utilities.noString(parentType)) 580 t = parent; 581 else { 582 t = parent.predicate("fhir:"+parentType+'.'+name); 583 } 584 composeElement(t, "ContactPoint", name, element, index); 585 if (element.hasSystemElement()) 586 composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1); 587 if (element.hasValueElement()) 588 composeString(t, "ContactPoint", "value", element.getValueElement(), -1); 589 if (element.hasUseElement()) 590 composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1); 591 if (element.hasRankElement()) 592 composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1); 593 if (element.hasPeriod()) 594 composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1); 595 } 596 597 protected void composeMarketingStatus(Complex parent, String parentType, String name, MarketingStatus element, int index) { 598 if (element == null) 599 return; 600 Complex t; 601 if (Utilities.noString(parentType)) 602 t = parent; 603 else { 604 t = parent.predicate("fhir:"+parentType+'.'+name); 605 } 606 composeElement(t, "MarketingStatus", name, element, index); 607 if (element.hasCountry()) 608 composeCodeableConcept(t, "MarketingStatus", "country", element.getCountry(), -1); 609 if (element.hasJurisdiction()) 610 composeCodeableConcept(t, "MarketingStatus", "jurisdiction", element.getJurisdiction(), -1); 611 if (element.hasStatus()) 612 composeCodeableConcept(t, "MarketingStatus", "status", element.getStatus(), -1); 613 if (element.hasDateRange()) 614 composePeriod(t, "MarketingStatus", "dateRange", element.getDateRange(), -1); 615 if (element.hasRestoreDateElement()) 616 composeDateTime(t, "MarketingStatus", "restoreDate", element.getRestoreDateElement(), -1); 617 } 618 619 protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) { 620 if (element == null) 621 return; 622 Complex t; 623 if (Utilities.noString(parentType)) 624 t = parent; 625 else { 626 t = parent.predicate("fhir:"+parentType+'.'+name); 627 } 628 composeElement(t, "Identifier", name, element, index); 629 if (element.hasUseElement()) 630 composeEnum(t, "Identifier", "use", element.getUseElement(), -1); 631 if (element.hasType()) 632 composeCodeableConcept(t, "Identifier", "type", element.getType(), -1); 633 if (element.hasSystemElement()) 634 composeUri(t, "Identifier", "system", element.getSystemElement(), -1); 635 if (element.hasValueElement()) 636 composeString(t, "Identifier", "value", element.getValueElement(), -1); 637 if (element.hasPeriod()) 638 composePeriod(t, "Identifier", "period", element.getPeriod(), -1); 639 if (element.hasAssigner()) 640 composeReference(t, "Identifier", "assigner", element.getAssigner(), -1); 641 } 642 643 protected void composeSubstanceAmount(Complex parent, String parentType, String name, SubstanceAmount element, int index) { 644 if (element == null) 645 return; 646 Complex t; 647 if (Utilities.noString(parentType)) 648 t = parent; 649 else { 650 t = parent.predicate("fhir:"+parentType+'.'+name); 651 } 652 composeElement(t, "SubstanceAmount", name, element, index); 653 if (element.hasAmount()) 654 composeType(t, "SubstanceAmount", "amount", element.getAmount(), -1); 655 if (element.hasAmountType()) 656 composeCodeableConcept(t, "SubstanceAmount", "amountType", element.getAmountType(), -1); 657 if (element.hasAmountTextElement()) 658 composeString(t, "SubstanceAmount", "amountText", element.getAmountTextElement(), -1); 659 if (element.hasReferenceRange()) 660 composeSubstanceAmountSubstanceAmountReferenceRangeComponent(t, "SubstanceAmount", "referenceRange", element.getReferenceRange(), -1); 661 } 662 663 protected void composeSubstanceAmountSubstanceAmountReferenceRangeComponent(Complex parent, String parentType, String name, SubstanceAmount.SubstanceAmountReferenceRangeComponent element, int index) { 664 if (element == null) 665 return; 666 Complex t; 667 if (Utilities.noString(parentType)) 668 t = parent; 669 else { 670 t = parent.predicate("fhir:"+parentType+'.'+name); 671 } 672 composeElement(t, "referenceRange", name, element, index); 673 if (element.hasLowLimit()) 674 composeQuantity(t, "SubstanceAmount", "lowLimit", element.getLowLimit(), -1); 675 if (element.hasHighLimit()) 676 composeQuantity(t, "SubstanceAmount", "highLimit", element.getHighLimit(), -1); 677 } 678 679 protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) { 680 if (element == null) 681 return; 682 Complex t; 683 if (Utilities.noString(parentType)) 684 t = parent; 685 else { 686 t = parent.predicate("fhir:"+parentType+'.'+name); 687 } 688 composeElement(t, "Coding", name, element, index); 689 decorateCoding(t, element); 690 if (element.hasSystemElement()) 691 composeUri(t, "Coding", "system", element.getSystemElement(), -1); 692 if (element.hasVersionElement()) 693 composeString(t, "Coding", "version", element.getVersionElement(), -1); 694 if (element.hasCodeElement()) 695 composeCode(t, "Coding", "code", element.getCodeElement(), -1); 696 if (element.hasDisplayElement()) 697 composeString(t, "Coding", "display", element.getDisplayElement(), -1); 698 if (element.hasUserSelectedElement()) 699 composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1); 700 } 701 702 protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) { 703 if (element == null) 704 return; 705 Complex t; 706 if (Utilities.noString(parentType)) 707 t = parent; 708 else { 709 t = parent.predicate("fhir:"+parentType+'.'+name); 710 } 711 composeElement(t, "SampledData", name, element, index); 712 if (element.hasOrigin()) 713 composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1); 714 if (element.hasPeriodElement()) 715 composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1); 716 if (element.hasFactorElement()) 717 composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1); 718 if (element.hasLowerLimitElement()) 719 composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1); 720 if (element.hasUpperLimitElement()) 721 composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1); 722 if (element.hasDimensionsElement()) 723 composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1); 724 if (element.hasDataElement()) 725 composeString(t, "SampledData", "data", element.getDataElement(), -1); 726 } 727 728 protected void composePopulation(Complex parent, String parentType, String name, Population element, int index) { 729 if (element == null) 730 return; 731 Complex t; 732 if (Utilities.noString(parentType)) 733 t = parent; 734 else { 735 t = parent.predicate("fhir:"+parentType+'.'+name); 736 } 737 composeElement(t, "Population", name, element, index); 738 if (element.hasAge()) 739 composeType(t, "Population", "age", element.getAge(), -1); 740 if (element.hasGender()) 741 composeCodeableConcept(t, "Population", "gender", element.getGender(), -1); 742 if (element.hasRace()) 743 composeCodeableConcept(t, "Population", "race", element.getRace(), -1); 744 if (element.hasPhysiologicalCondition()) 745 composeCodeableConcept(t, "Population", "physiologicalCondition", element.getPhysiologicalCondition(), -1); 746 } 747 748 protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) { 749 if (element == null) 750 return; 751 Complex t; 752 if (Utilities.noString(parentType)) 753 t = parent; 754 else { 755 t = parent.predicate("fhir:"+parentType+'.'+name); 756 } 757 composeElement(t, "Ratio", name, element, index); 758 if (element.hasNumerator()) 759 composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1); 760 if (element.hasDenominator()) 761 composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1); 762 } 763 764 protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) { 765 if (element == null) 766 return; 767 Complex t; 768 if (Utilities.noString(parentType)) 769 t = parent; 770 else { 771 t = parent.predicate("fhir:"+parentType+'.'+name); 772 } 773 composeElement(t, "Distance", name, element, index); 774 } 775 776 protected void composeAge(Complex parent, String parentType, String name, Age element, int index) { 777 if (element == null) 778 return; 779 Complex t; 780 if (Utilities.noString(parentType)) 781 t = parent; 782 else { 783 t = parent.predicate("fhir:"+parentType+'.'+name); 784 } 785 composeElement(t, "Age", name, element, index); 786 } 787 788 protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) { 789 if (element == null) 790 return; 791 Complex t; 792 if (Utilities.noString(parentType)) 793 t = parent; 794 else { 795 t = parent.predicate("fhir:"+parentType+'.'+name); 796 } 797 composeElement(t, "Reference", name, element, index); 798 if (element.hasReferenceElement()) 799 composeString(t, "Reference", "reference", element.getReferenceElement_(), -1); 800 if (element.hasTypeElement()) 801 composeUri(t, "Reference", "type", element.getTypeElement(), -1); 802 if (element.hasIdentifier()) 803 composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1); 804 if (element.hasDisplayElement()) 805 composeString(t, "Reference", "display", element.getDisplayElement(), -1); 806 } 807 808 protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) { 809 if (element == null) 810 return; 811 Complex t; 812 if (Utilities.noString(parentType)) 813 t = parent; 814 else { 815 t = parent.predicate("fhir:"+parentType+'.'+name); 816 } 817 composeElement(t, "TriggerDefinition", name, element, index); 818 if (element.hasTypeElement()) 819 composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1); 820 if (element.hasNameElement()) 821 composeString(t, "TriggerDefinition", "name", element.getNameElement(), -1); 822 if (element.hasTiming()) 823 composeType(t, "TriggerDefinition", "timing", element.getTiming(), -1); 824 for (int i = 0; i < element.getData().size(); i++) 825 composeDataRequirement(t, "TriggerDefinition", "data", element.getData().get(i), i); 826 if (element.hasCondition()) 827 composeExpression(t, "TriggerDefinition", "condition", element.getCondition(), -1); 828 } 829 830 protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) { 831 if (element == null) 832 return; 833 Complex t; 834 if (Utilities.noString(parentType)) 835 t = parent; 836 else { 837 t = parent.predicate("fhir:"+parentType+'.'+name); 838 } 839 composeElement(t, "Quantity", name, element, index); 840 if (element.hasValueElement()) 841 composeDecimal(t, "Quantity", "value", element.getValueElement(), -1); 842 if (element.hasComparatorElement()) 843 composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1); 844 if (element.hasUnitElement()) 845 composeString(t, "Quantity", "unit", element.getUnitElement(), -1); 846 if (element.hasSystemElement()) 847 composeUri(t, "Quantity", "system", element.getSystemElement(), -1); 848 if (element.hasCodeElement()) 849 composeCode(t, "Quantity", "code", element.getCodeElement(), -1); 850 } 851 852 protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) { 853 if (element == null) 854 return; 855 Complex t; 856 if (Utilities.noString(parentType)) 857 t = parent; 858 else { 859 t = parent.predicate("fhir:"+parentType+'.'+name); 860 } 861 composeElement(t, "Period", name, element, index); 862 if (element.hasStartElement()) 863 composeDateTime(t, "Period", "start", element.getStartElement(), -1); 864 if (element.hasEndElement()) 865 composeDateTime(t, "Period", "end", element.getEndElement(), -1); 866 } 867 868 protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) { 869 if (element == null) 870 return; 871 Complex t; 872 if (Utilities.noString(parentType)) 873 t = parent; 874 else { 875 t = parent.predicate("fhir:"+parentType+'.'+name); 876 } 877 composeElement(t, "Duration", name, element, index); 878 } 879 880 protected void composeRange(Complex parent, String parentType, String name, Range element, int index) { 881 if (element == null) 882 return; 883 Complex t; 884 if (Utilities.noString(parentType)) 885 t = parent; 886 else { 887 t = parent.predicate("fhir:"+parentType+'.'+name); 888 } 889 composeElement(t, "Range", name, element, index); 890 if (element.hasLow()) 891 composeQuantity(t, "Range", "low", element.getLow(), -1); 892 if (element.hasHigh()) 893 composeQuantity(t, "Range", "high", element.getHigh(), -1); 894 } 895 896 protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) { 897 if (element == null) 898 return; 899 Complex t; 900 if (Utilities.noString(parentType)) 901 t = parent; 902 else { 903 t = parent.predicate("fhir:"+parentType+'.'+name); 904 } 905 composeElement(t, "RelatedArtifact", name, element, index); 906 if (element.hasTypeElement()) 907 composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1); 908 if (element.hasLabelElement()) 909 composeString(t, "RelatedArtifact", "label", element.getLabelElement(), -1); 910 if (element.hasDisplayElement()) 911 composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1); 912 if (element.hasCitationElement()) 913 composeMarkdown(t, "RelatedArtifact", "citation", element.getCitationElement(), -1); 914 if (element.hasUrlElement()) 915 composeUrl(t, "RelatedArtifact", "url", element.getUrlElement(), -1); 916 if (element.hasDocument()) 917 composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1); 918 if (element.hasResourceElement()) 919 composeCanonical(t, "RelatedArtifact", "resource", element.getResourceElement(), -1); 920 } 921 922 protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) { 923 if (element == null) 924 return; 925 Complex t; 926 if (Utilities.noString(parentType)) 927 t = parent; 928 else { 929 t = parent.predicate("fhir:"+parentType+'.'+name); 930 } 931 composeElement(t, "Annotation", name, element, index); 932 if (element.hasAuthor()) 933 composeType(t, "Annotation", "author", element.getAuthor(), -1); 934 if (element.hasTimeElement()) 935 composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1); 936 if (element.hasTextElement()) 937 composeMarkdown(t, "Annotation", "text", element.getTextElement(), -1); 938 } 939 940 protected void composeProductShelfLife(Complex parent, String parentType, String name, ProductShelfLife element, int index) { 941 if (element == null) 942 return; 943 Complex t; 944 if (Utilities.noString(parentType)) 945 t = parent; 946 else { 947 t = parent.predicate("fhir:"+parentType+'.'+name); 948 } 949 composeElement(t, "ProductShelfLife", name, element, index); 950 if (element.hasIdentifier()) 951 composeIdentifier(t, "ProductShelfLife", "identifier", element.getIdentifier(), -1); 952 if (element.hasType()) 953 composeCodeableConcept(t, "ProductShelfLife", "type", element.getType(), -1); 954 if (element.hasPeriod()) 955 composeQuantity(t, "ProductShelfLife", "period", element.getPeriod(), -1); 956 for (int i = 0; i < element.getSpecialPrecautionsForStorage().size(); i++) 957 composeCodeableConcept(t, "ProductShelfLife", "specialPrecautionsForStorage", element.getSpecialPrecautionsForStorage().get(i), i); 958 } 959 960 protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) { 961 if (element == null) 962 return; 963 Complex t; 964 if (Utilities.noString(parentType)) 965 t = parent; 966 else { 967 t = parent.predicate("fhir:"+parentType+'.'+name); 968 } 969 composeElement(t, "ContactDetail", name, element, index); 970 if (element.hasNameElement()) 971 composeString(t, "ContactDetail", "name", element.getNameElement(), -1); 972 for (int i = 0; i < element.getTelecom().size(); i++) 973 composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i); 974 } 975 976 protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) { 977 if (element == null) 978 return; 979 Complex t; 980 if (Utilities.noString(parentType)) 981 t = parent; 982 else { 983 t = parent.predicate("fhir:"+parentType+'.'+name); 984 } 985 composeElement(t, "UsageContext", name, element, index); 986 if (element.hasCode()) 987 composeCoding(t, "UsageContext", "code", element.getCode(), -1); 988 if (element.hasValue()) 989 composeType(t, "UsageContext", "value", element.getValue(), -1); 990 } 991 992 protected void composeExpression(Complex parent, String parentType, String name, Expression element, int index) { 993 if (element == null) 994 return; 995 Complex t; 996 if (Utilities.noString(parentType)) 997 t = parent; 998 else { 999 t = parent.predicate("fhir:"+parentType+'.'+name); 1000 } 1001 composeElement(t, "Expression", name, element, index); 1002 if (element.hasDescriptionElement()) 1003 composeString(t, "Expression", "description", element.getDescriptionElement(), -1); 1004 if (element.hasNameElement()) 1005 composeId(t, "Expression", "name", element.getNameElement(), -1); 1006 if (element.hasLanguageElement()) 1007 composeCode(t, "Expression", "language", element.getLanguageElement(), -1); 1008 if (element.hasExpressionElement()) 1009 composeString(t, "Expression", "expression", element.getExpressionElement(), -1); 1010 if (element.hasReferenceElement()) 1011 composeUri(t, "Expression", "reference", element.getReferenceElement(), -1); 1012 } 1013 1014 protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) { 1015 if (element == null) 1016 return; 1017 Complex t; 1018 if (Utilities.noString(parentType)) 1019 t = parent; 1020 else { 1021 t = parent.predicate("fhir:"+parentType+'.'+name); 1022 } 1023 composeElement(t, "Signature", name, element, index); 1024 for (int i = 0; i < element.getType().size(); i++) 1025 composeCoding(t, "Signature", "type", element.getType().get(i), i); 1026 if (element.hasWhenElement()) 1027 composeInstant(t, "Signature", "when", element.getWhenElement(), -1); 1028 if (element.hasWho()) 1029 composeReference(t, "Signature", "who", element.getWho(), -1); 1030 if (element.hasOnBehalfOf()) 1031 composeReference(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1); 1032 if (element.hasTargetFormatElement()) 1033 composeCode(t, "Signature", "targetFormat", element.getTargetFormatElement(), -1); 1034 if (element.hasSigFormatElement()) 1035 composeCode(t, "Signature", "sigFormat", element.getSigFormatElement(), -1); 1036 if (element.hasDataElement()) 1037 composeBase64Binary(t, "Signature", "data", element.getDataElement(), -1); 1038 } 1039 1040 protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) { 1041 if (element == null) 1042 return; 1043 Complex t; 1044 if (Utilities.noString(parentType)) 1045 t = parent; 1046 else { 1047 t = parent.predicate("fhir:"+parentType+'.'+name); 1048 } 1049 composeElement(t, "Timing", name, element, index); 1050 for (int i = 0; i < element.getEvent().size(); i++) 1051 composeDateTime(t, "Timing", "event", element.getEvent().get(i), i); 1052 if (element.hasRepeat()) 1053 composeTimingTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1); 1054 if (element.hasCode()) 1055 composeCodeableConcept(t, "Timing", "code", element.getCode(), -1); 1056 } 1057 1058 protected void composeTimingTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) { 1059 if (element == null) 1060 return; 1061 Complex t; 1062 if (Utilities.noString(parentType)) 1063 t = parent; 1064 else { 1065 t = parent.predicate("fhir:"+parentType+'.'+name); 1066 } 1067 composeElement(t, "repeat", name, element, index); 1068 if (element.hasBounds()) 1069 composeType(t, "Timing", "bounds", element.getBounds(), -1); 1070 if (element.hasCountElement()) 1071 composePositiveInt(t, "Timing", "count", element.getCountElement(), -1); 1072 if (element.hasCountMaxElement()) 1073 composePositiveInt(t, "Timing", "countMax", element.getCountMaxElement(), -1); 1074 if (element.hasDurationElement()) 1075 composeDecimal(t, "Timing", "duration", element.getDurationElement(), -1); 1076 if (element.hasDurationMaxElement()) 1077 composeDecimal(t, "Timing", "durationMax", element.getDurationMaxElement(), -1); 1078 if (element.hasDurationUnitElement()) 1079 composeEnum(t, "Timing", "durationUnit", element.getDurationUnitElement(), -1); 1080 if (element.hasFrequencyElement()) 1081 composePositiveInt(t, "Timing", "frequency", element.getFrequencyElement(), -1); 1082 if (element.hasFrequencyMaxElement()) 1083 composePositiveInt(t, "Timing", "frequencyMax", element.getFrequencyMaxElement(), -1); 1084 if (element.hasPeriodElement()) 1085 composeDecimal(t, "Timing", "period", element.getPeriodElement(), -1); 1086 if (element.hasPeriodMaxElement()) 1087 composeDecimal(t, "Timing", "periodMax", element.getPeriodMaxElement(), -1); 1088 if (element.hasPeriodUnitElement()) 1089 composeEnum(t, "Timing", "periodUnit", element.getPeriodUnitElement(), -1); 1090 for (int i = 0; i < element.getDayOfWeek().size(); i++) 1091 composeEnum(t, "Timing", "dayOfWeek", element.getDayOfWeek().get(i), i); 1092 for (int i = 0; i < element.getTimeOfDay().size(); i++) 1093 composeTime(t, "Timing", "timeOfDay", element.getTimeOfDay().get(i), i); 1094 for (int i = 0; i < element.getWhen().size(); i++) 1095 composeEnum(t, "Timing", "when", element.getWhen().get(i), i); 1096 if (element.hasOffsetElement()) 1097 composeUnsignedInt(t, "Timing", "offset", element.getOffsetElement(), -1); 1098 } 1099 1100 protected void composeProdCharacteristic(Complex parent, String parentType, String name, ProdCharacteristic element, int index) { 1101 if (element == null) 1102 return; 1103 Complex t; 1104 if (Utilities.noString(parentType)) 1105 t = parent; 1106 else { 1107 t = parent.predicate("fhir:"+parentType+'.'+name); 1108 } 1109 composeElement(t, "ProdCharacteristic", name, element, index); 1110 if (element.hasHeight()) 1111 composeQuantity(t, "ProdCharacteristic", "height", element.getHeight(), -1); 1112 if (element.hasWidth()) 1113 composeQuantity(t, "ProdCharacteristic", "width", element.getWidth(), -1); 1114 if (element.hasDepth()) 1115 composeQuantity(t, "ProdCharacteristic", "depth", element.getDepth(), -1); 1116 if (element.hasWeight()) 1117 composeQuantity(t, "ProdCharacteristic", "weight", element.getWeight(), -1); 1118 if (element.hasNominalVolume()) 1119 composeQuantity(t, "ProdCharacteristic", "nominalVolume", element.getNominalVolume(), -1); 1120 if (element.hasExternalDiameter()) 1121 composeQuantity(t, "ProdCharacteristic", "externalDiameter", element.getExternalDiameter(), -1); 1122 if (element.hasShapeElement()) 1123 composeString(t, "ProdCharacteristic", "shape", element.getShapeElement(), -1); 1124 for (int i = 0; i < element.getColor().size(); i++) 1125 composeString(t, "ProdCharacteristic", "color", element.getColor().get(i), i); 1126 for (int i = 0; i < element.getImprint().size(); i++) 1127 composeString(t, "ProdCharacteristic", "imprint", element.getImprint().get(i), i); 1128 for (int i = 0; i < element.getImage().size(); i++) 1129 composeAttachment(t, "ProdCharacteristic", "image", element.getImage().get(i), i); 1130 if (element.hasScoring()) 1131 composeCodeableConcept(t, "ProdCharacteristic", "scoring", element.getScoring(), -1); 1132 } 1133 1134 protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) { 1135 if (element == null) 1136 return; 1137 Complex t; 1138 if (Utilities.noString(parentType)) 1139 t = parent; 1140 else { 1141 t = parent.predicate("fhir:"+parentType+'.'+name); 1142 } 1143 composeElement(t, "CodeableConcept", name, element, index); 1144 decorateCodeableConcept(t, element); 1145 for (int i = 0; i < element.getCoding().size(); i++) 1146 composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i); 1147 if (element.hasTextElement()) 1148 composeString(t, "CodeableConcept", "text", element.getTextElement(), -1); 1149 } 1150 1151 protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) { 1152 if (element == null) 1153 return; 1154 Complex t; 1155 if (Utilities.noString(parentType)) 1156 t = parent; 1157 else { 1158 t = parent.predicate("fhir:"+parentType+'.'+name); 1159 } 1160 composeElement(t, "ParameterDefinition", name, element, index); 1161 if (element.hasNameElement()) 1162 composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1); 1163 if (element.hasUseElement()) 1164 composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1); 1165 if (element.hasMinElement()) 1166 composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1); 1167 if (element.hasMaxElement()) 1168 composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1); 1169 if (element.hasDocumentationElement()) 1170 composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1); 1171 if (element.hasTypeElement()) 1172 composeCode(t, "ParameterDefinition", "type", element.getTypeElement(), -1); 1173 if (element.hasProfileElement()) 1174 composeCanonical(t, "ParameterDefinition", "profile", element.getProfileElement(), -1); 1175 } 1176 1177 protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) { 1178 if (element == null) 1179 return; 1180 Complex t; 1181 if (Utilities.noString(parentType)) 1182 t = parent; 1183 else { 1184 t = parent.predicate("fhir:"+parentType+'.'+name); 1185 } 1186 composeElement(t, "ElementDefinition", name, element, index); 1187 if (element.hasPathElement()) 1188 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1189 for (int i = 0; i < element.getRepresentation().size(); i++) 1190 composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i); 1191 if (element.hasSliceNameElement()) 1192 composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1); 1193 if (element.hasSliceIsConstrainingElement()) 1194 composeBoolean(t, "ElementDefinition", "sliceIsConstraining", element.getSliceIsConstrainingElement(), -1); 1195 if (element.hasLabelElement()) 1196 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 1197 for (int i = 0; i < element.getCode().size(); i++) 1198 composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i); 1199 if (element.hasSlicing()) 1200 composeElementDefinitionElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1); 1201 if (element.hasShortElement()) 1202 composeString(t, "ElementDefinition", "short", element.getShortElement(), -1); 1203 if (element.hasDefinitionElement()) 1204 composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1); 1205 if (element.hasCommentElement()) 1206 composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 1207 if (element.hasRequirementsElement()) 1208 composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 1209 for (int i = 0; i < element.getAlias().size(); i++) 1210 composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i); 1211 if (element.hasMinElement()) 1212 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 1213 if (element.hasMaxElement()) 1214 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 1215 if (element.hasBase()) 1216 composeElementDefinitionElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1); 1217 if (element.hasContentReferenceElement()) 1218 composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1); 1219 for (int i = 0; i < element.getType().size(); i++) 1220 composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i); 1221 if (element.hasDefaultValue()) 1222 composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1); 1223 if (element.hasMeaningWhenMissingElement()) 1224 composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1); 1225 if (element.hasOrderMeaningElement()) 1226 composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1); 1227 if (element.hasFixed()) 1228 composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1); 1229 if (element.hasPattern()) 1230 composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1); 1231 for (int i = 0; i < element.getExample().size(); i++) 1232 composeElementDefinitionElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i); 1233 if (element.hasMinValue()) 1234 composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1); 1235 if (element.hasMaxValue()) 1236 composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1); 1237 if (element.hasMaxLengthElement()) 1238 composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1); 1239 for (int i = 0; i < element.getCondition().size(); i++) 1240 composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i); 1241 for (int i = 0; i < element.getConstraint().size(); i++) 1242 composeElementDefinitionElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i); 1243 if (element.hasMustSupportElement()) 1244 composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1); 1245 if (element.hasIsModifierElement()) 1246 composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1); 1247 if (element.hasIsModifierReasonElement()) 1248 composeString(t, "ElementDefinition", "isModifierReason", element.getIsModifierReasonElement(), -1); 1249 if (element.hasIsSummaryElement()) 1250 composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1); 1251 if (element.hasBinding()) 1252 composeElementDefinitionElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1); 1253 for (int i = 0; i < element.getMapping().size(); i++) 1254 composeElementDefinitionElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i); 1255 } 1256 1257 protected void composeElementDefinitionElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) { 1258 if (element == null) 1259 return; 1260 Complex t; 1261 if (Utilities.noString(parentType)) 1262 t = parent; 1263 else { 1264 t = parent.predicate("fhir:"+parentType+'.'+name); 1265 } 1266 composeElement(t, "slicing", name, element, index); 1267 for (int i = 0; i < element.getDiscriminator().size(); i++) 1268 composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinition", "discriminator", element.getDiscriminator().get(i), i); 1269 if (element.hasDescriptionElement()) 1270 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 1271 if (element.hasOrderedElement()) 1272 composeBoolean(t, "ElementDefinition", "ordered", element.getOrderedElement(), -1); 1273 if (element.hasRulesElement()) 1274 composeEnum(t, "ElementDefinition", "rules", element.getRulesElement(), -1); 1275 } 1276 1277 protected void composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) { 1278 if (element == null) 1279 return; 1280 Complex t; 1281 if (Utilities.noString(parentType)) 1282 t = parent; 1283 else { 1284 t = parent.predicate("fhir:"+parentType+'.'+name); 1285 } 1286 composeElement(t, "discriminator", name, element, index); 1287 if (element.hasTypeElement()) 1288 composeEnum(t, "ElementDefinition", "type", element.getTypeElement(), -1); 1289 if (element.hasPathElement()) 1290 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1291 } 1292 1293 protected void composeElementDefinitionElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) { 1294 if (element == null) 1295 return; 1296 Complex t; 1297 if (Utilities.noString(parentType)) 1298 t = parent; 1299 else { 1300 t = parent.predicate("fhir:"+parentType+'.'+name); 1301 } 1302 composeElement(t, "base", name, element, index); 1303 if (element.hasPathElement()) 1304 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1305 if (element.hasMinElement()) 1306 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 1307 if (element.hasMaxElement()) 1308 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 1309 } 1310 1311 protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) { 1312 if (element == null) 1313 return; 1314 Complex t; 1315 if (Utilities.noString(parentType)) 1316 t = parent; 1317 else { 1318 t = parent.predicate("fhir:"+parentType+'.'+name); 1319 } 1320 composeElement(t, "type", name, element, index); 1321 if (element.hasCodeElement()) 1322 composeUri(t, "ElementDefinition", "code", element.getCodeElement(), -1); 1323 for (int i = 0; i < element.getProfile().size(); i++) 1324 composeCanonical(t, "ElementDefinition", "profile", element.getProfile().get(i), i); 1325 for (int i = 0; i < element.getTargetProfile().size(); i++) 1326 composeCanonical(t, "ElementDefinition", "targetProfile", element.getTargetProfile().get(i), i); 1327 for (int i = 0; i < element.getAggregation().size(); i++) 1328 composeEnum(t, "ElementDefinition", "aggregation", element.getAggregation().get(i), i); 1329 if (element.hasVersioningElement()) 1330 composeEnum(t, "ElementDefinition", "versioning", element.getVersioningElement(), -1); 1331 } 1332 1333 protected void composeElementDefinitionElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) { 1334 if (element == null) 1335 return; 1336 Complex t; 1337 if (Utilities.noString(parentType)) 1338 t = parent; 1339 else { 1340 t = parent.predicate("fhir:"+parentType+'.'+name); 1341 } 1342 composeElement(t, "example", name, element, index); 1343 if (element.hasLabelElement()) 1344 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 1345 if (element.hasValue()) 1346 composeType(t, "ElementDefinition", "value", element.getValue(), -1); 1347 } 1348 1349 protected void composeElementDefinitionElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) { 1350 if (element == null) 1351 return; 1352 Complex t; 1353 if (Utilities.noString(parentType)) 1354 t = parent; 1355 else { 1356 t = parent.predicate("fhir:"+parentType+'.'+name); 1357 } 1358 composeElement(t, "constraint", name, element, index); 1359 if (element.hasKeyElement()) 1360 composeId(t, "ElementDefinition", "key", element.getKeyElement(), -1); 1361 if (element.hasRequirementsElement()) 1362 composeString(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 1363 if (element.hasSeverityElement()) 1364 composeEnum(t, "ElementDefinition", "severity", element.getSeverityElement(), -1); 1365 if (element.hasHumanElement()) 1366 composeString(t, "ElementDefinition", "human", element.getHumanElement(), -1); 1367 if (element.hasExpressionElement()) 1368 composeString(t, "ElementDefinition", "expression", element.getExpressionElement(), -1); 1369 if (element.hasXpathElement()) 1370 composeString(t, "ElementDefinition", "xpath", element.getXpathElement(), -1); 1371 if (element.hasSourceElement()) 1372 composeCanonical(t, "ElementDefinition", "source", element.getSourceElement(), -1); 1373 } 1374 1375 protected void composeElementDefinitionElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) { 1376 if (element == null) 1377 return; 1378 Complex t; 1379 if (Utilities.noString(parentType)) 1380 t = parent; 1381 else { 1382 t = parent.predicate("fhir:"+parentType+'.'+name); 1383 } 1384 composeElement(t, "binding", name, element, index); 1385 if (element.hasStrengthElement()) 1386 composeEnum(t, "ElementDefinition", "strength", element.getStrengthElement(), -1); 1387 if (element.hasDescriptionElement()) 1388 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 1389 if (element.hasValueSetElement()) 1390 composeCanonical(t, "ElementDefinition", "valueSet", element.getValueSetElement(), -1); 1391 } 1392 1393 protected void composeElementDefinitionElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) { 1394 if (element == null) 1395 return; 1396 Complex t; 1397 if (Utilities.noString(parentType)) 1398 t = parent; 1399 else { 1400 t = parent.predicate("fhir:"+parentType+'.'+name); 1401 } 1402 composeElement(t, "mapping", name, element, index); 1403 if (element.hasIdentityElement()) 1404 composeId(t, "ElementDefinition", "identity", element.getIdentityElement(), -1); 1405 if (element.hasLanguageElement()) 1406 composeCode(t, "ElementDefinition", "language", element.getLanguageElement(), -1); 1407 if (element.hasMapElement()) 1408 composeString(t, "ElementDefinition", "map", element.getMapElement(), -1); 1409 if (element.hasCommentElement()) 1410 composeString(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 1411 } 1412 1413 protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) { 1414 composeResource(t, parentType, name, element, index); 1415 if (element.hasText()) 1416 composeNarrative(t, "DomainResource", "text", element.getText(), -1); 1417 for (int i = 0; i < element.getContained().size(); i++) 1418 composeResource(t, "DomainResource", "contained", element.getContained().get(i), i); 1419 for (int i = 0; i < element.getExtension().size(); i++) 1420 composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i); 1421 for (int i = 0; i < element.getModifierExtension().size(); i++) 1422 composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i); 1423 } 1424 1425 protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) { 1426 if (element == null) 1427 return; 1428 Complex t; 1429 if (Utilities.noString(parentType)) 1430 t = parent; 1431 else { 1432 t = parent.predicate("fhir:"+parentType+'.'+name); 1433 } 1434 composeResource(t, "Parameters", name, element, index); 1435 for (int i = 0; i < element.getParameter().size(); i++) 1436 composeParametersParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i); 1437 } 1438 1439 protected void composeParametersParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) { 1440 if (element == null) 1441 return; 1442 Complex t; 1443 if (Utilities.noString(parentType)) 1444 t = parent; 1445 else { 1446 t = parent.predicate("fhir:"+parentType+'.'+name); 1447 } 1448 composeBackboneElement(t, "parameter", name, element, index); 1449 if (element.hasNameElement()) 1450 composeString(t, "Parameters", "name", element.getNameElement(), -1); 1451 if (element.hasValue()) 1452 composeType(t, "Parameters", "value", element.getValue(), -1); 1453 if (element.hasResource()) 1454 composeResource(t, "Parameters", "resource", element.getResource(), -1); 1455 for (int i = 0; i < element.getPart().size(); i++) 1456 composeParametersParametersParameterComponent(t, "Parameters", "part", element.getPart().get(i), i); 1457 } 1458 1459 protected void composeResource(Complex t, String parentType, String name, Resource element, int index) { 1460 if (element.hasIdElement()) 1461 composeId(t, "Resource", "id", element.getIdElement(), -1); 1462 if (element.hasMeta()) 1463 composeMeta(t, "Resource", "meta", element.getMeta(), -1); 1464 if (element.hasImplicitRulesElement()) 1465 composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1); 1466 if (element.hasLanguageElement()) 1467 composeCode(t, "Resource", "language", element.getLanguageElement(), -1); 1468 } 1469 1470 protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) { 1471 if (element == null) 1472 return; 1473 Complex t; 1474 if (Utilities.noString(parentType)) 1475 t = parent; 1476 else { 1477 t = parent.predicate("fhir:"+parentType+'.'+name); 1478 } 1479 composeDomainResource(t, "Account", name, element, index); 1480 for (int i = 0; i < element.getIdentifier().size(); i++) 1481 composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i); 1482 if (element.hasStatusElement()) 1483 composeEnum(t, "Account", "status", element.getStatusElement(), -1); 1484 if (element.hasType()) 1485 composeCodeableConcept(t, "Account", "type", element.getType(), -1); 1486 if (element.hasNameElement()) 1487 composeString(t, "Account", "name", element.getNameElement(), -1); 1488 for (int i = 0; i < element.getSubject().size(); i++) 1489 composeReference(t, "Account", "subject", element.getSubject().get(i), i); 1490 if (element.hasServicePeriod()) 1491 composePeriod(t, "Account", "servicePeriod", element.getServicePeriod(), -1); 1492 for (int i = 0; i < element.getCoverage().size(); i++) 1493 composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i); 1494 if (element.hasOwner()) 1495 composeReference(t, "Account", "owner", element.getOwner(), -1); 1496 if (element.hasDescriptionElement()) 1497 composeString(t, "Account", "description", element.getDescriptionElement(), -1); 1498 for (int i = 0; i < element.getGuarantor().size(); i++) 1499 composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i); 1500 if (element.hasPartOf()) 1501 composeReference(t, "Account", "partOf", element.getPartOf(), -1); 1502 } 1503 1504 protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) { 1505 if (element == null) 1506 return; 1507 Complex t; 1508 if (Utilities.noString(parentType)) 1509 t = parent; 1510 else { 1511 t = parent.predicate("fhir:"+parentType+'.'+name); 1512 } 1513 composeBackboneElement(t, "coverage", name, element, index); 1514 if (element.hasCoverage()) 1515 composeReference(t, "Account", "coverage", element.getCoverage(), -1); 1516 if (element.hasPriorityElement()) 1517 composePositiveInt(t, "Account", "priority", element.getPriorityElement(), -1); 1518 } 1519 1520 protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) { 1521 if (element == null) 1522 return; 1523 Complex t; 1524 if (Utilities.noString(parentType)) 1525 t = parent; 1526 else { 1527 t = parent.predicate("fhir:"+parentType+'.'+name); 1528 } 1529 composeBackboneElement(t, "guarantor", name, element, index); 1530 if (element.hasParty()) 1531 composeReference(t, "Account", "party", element.getParty(), -1); 1532 if (element.hasOnHoldElement()) 1533 composeBoolean(t, "Account", "onHold", element.getOnHoldElement(), -1); 1534 if (element.hasPeriod()) 1535 composePeriod(t, "Account", "period", element.getPeriod(), -1); 1536 } 1537 1538 protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) { 1539 if (element == null) 1540 return; 1541 Complex t; 1542 if (Utilities.noString(parentType)) 1543 t = parent; 1544 else { 1545 t = parent.predicate("fhir:"+parentType+'.'+name); 1546 } 1547 composeDomainResource(t, "ActivityDefinition", name, element, index); 1548 if (element.hasUrlElement()) 1549 composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1); 1550 for (int i = 0; i < element.getIdentifier().size(); i++) 1551 composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i); 1552 if (element.hasVersionElement()) 1553 composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1); 1554 if (element.hasNameElement()) 1555 composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1); 1556 if (element.hasTitleElement()) 1557 composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1); 1558 if (element.hasSubtitleElement()) 1559 composeString(t, "ActivityDefinition", "subtitle", element.getSubtitleElement(), -1); 1560 if (element.hasStatusElement()) 1561 composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1); 1562 if (element.hasExperimentalElement()) 1563 composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1); 1564 if (element.hasSubject()) 1565 composeType(t, "ActivityDefinition", "subject", element.getSubject(), -1); 1566 if (element.hasDateElement()) 1567 composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1); 1568 if (element.hasPublisherElement()) 1569 composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1); 1570 for (int i = 0; i < element.getContact().size(); i++) 1571 composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i); 1572 if (element.hasDescriptionElement()) 1573 composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 1574 for (int i = 0; i < element.getUseContext().size(); i++) 1575 composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i); 1576 for (int i = 0; i < element.getJurisdiction().size(); i++) 1577 composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 1578 if (element.hasPurposeElement()) 1579 composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1); 1580 if (element.hasUsageElement()) 1581 composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1); 1582 if (element.hasCopyrightElement()) 1583 composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1); 1584 if (element.hasApprovalDateElement()) 1585 composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1); 1586 if (element.hasLastReviewDateElement()) 1587 composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 1588 if (element.hasEffectivePeriod()) 1589 composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 1590 for (int i = 0; i < element.getTopic().size(); i++) 1591 composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i); 1592 for (int i = 0; i < element.getAuthor().size(); i++) 1593 composeContactDetail(t, "ActivityDefinition", "author", element.getAuthor().get(i), i); 1594 for (int i = 0; i < element.getEditor().size(); i++) 1595 composeContactDetail(t, "ActivityDefinition", "editor", element.getEditor().get(i), i); 1596 for (int i = 0; i < element.getReviewer().size(); i++) 1597 composeContactDetail(t, "ActivityDefinition", "reviewer", element.getReviewer().get(i), i); 1598 for (int i = 0; i < element.getEndorser().size(); i++) 1599 composeContactDetail(t, "ActivityDefinition", "endorser", element.getEndorser().get(i), i); 1600 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 1601 composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 1602 for (int i = 0; i < element.getLibrary().size(); i++) 1603 composeCanonical(t, "ActivityDefinition", "library", element.getLibrary().get(i), i); 1604 if (element.hasKindElement()) 1605 composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1); 1606 if (element.hasProfileElement()) 1607 composeCanonical(t, "ActivityDefinition", "profile", element.getProfileElement(), -1); 1608 if (element.hasCode()) 1609 composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1); 1610 if (element.hasIntentElement()) 1611 composeEnum(t, "ActivityDefinition", "intent", element.getIntentElement(), -1); 1612 if (element.hasPriorityElement()) 1613 composeEnum(t, "ActivityDefinition", "priority", element.getPriorityElement(), -1); 1614 if (element.hasDoNotPerformElement()) 1615 composeBoolean(t, "ActivityDefinition", "doNotPerform", element.getDoNotPerformElement(), -1); 1616 if (element.hasTiming()) 1617 composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1); 1618 if (element.hasLocation()) 1619 composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1); 1620 for (int i = 0; i < element.getParticipant().size(); i++) 1621 composeActivityDefinitionActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i); 1622 if (element.hasProduct()) 1623 composeType(t, "ActivityDefinition", "product", element.getProduct(), -1); 1624 if (element.hasQuantity()) 1625 composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1); 1626 for (int i = 0; i < element.getDosage().size(); i++) 1627 composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i); 1628 for (int i = 0; i < element.getBodySite().size(); i++) 1629 composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i); 1630 for (int i = 0; i < element.getSpecimenRequirement().size(); i++) 1631 composeReference(t, "ActivityDefinition", "specimenRequirement", element.getSpecimenRequirement().get(i), i); 1632 for (int i = 0; i < element.getObservationRequirement().size(); i++) 1633 composeReference(t, "ActivityDefinition", "observationRequirement", element.getObservationRequirement().get(i), i); 1634 for (int i = 0; i < element.getObservationResultRequirement().size(); i++) 1635 composeReference(t, "ActivityDefinition", "observationResultRequirement", element.getObservationResultRequirement().get(i), i); 1636 if (element.hasTransformElement()) 1637 composeCanonical(t, "ActivityDefinition", "transform", element.getTransformElement(), -1); 1638 for (int i = 0; i < element.getDynamicValue().size(); i++) 1639 composeActivityDefinitionActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 1640 } 1641 1642 protected void composeActivityDefinitionActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) { 1643 if (element == null) 1644 return; 1645 Complex t; 1646 if (Utilities.noString(parentType)) 1647 t = parent; 1648 else { 1649 t = parent.predicate("fhir:"+parentType+'.'+name); 1650 } 1651 composeBackboneElement(t, "participant", name, element, index); 1652 if (element.hasTypeElement()) 1653 composeEnum(t, "ActivityDefinition", "type", element.getTypeElement(), -1); 1654 if (element.hasRole()) 1655 composeCodeableConcept(t, "ActivityDefinition", "role", element.getRole(), -1); 1656 } 1657 1658 protected void composeActivityDefinitionActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) { 1659 if (element == null) 1660 return; 1661 Complex t; 1662 if (Utilities.noString(parentType)) 1663 t = parent; 1664 else { 1665 t = parent.predicate("fhir:"+parentType+'.'+name); 1666 } 1667 composeBackboneElement(t, "dynamicValue", name, element, index); 1668 if (element.hasPathElement()) 1669 composeString(t, "ActivityDefinition", "path", element.getPathElement(), -1); 1670 if (element.hasExpression()) 1671 composeExpression(t, "ActivityDefinition", "expression", element.getExpression(), -1); 1672 } 1673 1674 protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) { 1675 if (element == null) 1676 return; 1677 Complex t; 1678 if (Utilities.noString(parentType)) 1679 t = parent; 1680 else { 1681 t = parent.predicate("fhir:"+parentType+'.'+name); 1682 } 1683 composeDomainResource(t, "AdverseEvent", name, element, index); 1684 if (element.hasIdentifier()) 1685 composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier(), -1); 1686 if (element.hasActualityElement()) 1687 composeEnum(t, "AdverseEvent", "actuality", element.getActualityElement(), -1); 1688 for (int i = 0; i < element.getCategory().size(); i++) 1689 composeCodeableConcept(t, "AdverseEvent", "category", element.getCategory().get(i), i); 1690 if (element.hasEvent()) 1691 composeCodeableConcept(t, "AdverseEvent", "event", element.getEvent(), -1); 1692 if (element.hasSubject()) 1693 composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1); 1694 if (element.hasEncounter()) 1695 composeReference(t, "AdverseEvent", "encounter", element.getEncounter(), -1); 1696 if (element.hasDateElement()) 1697 composeDateTime(t, "AdverseEvent", "date", element.getDateElement(), -1); 1698 if (element.hasDetectedElement()) 1699 composeDateTime(t, "AdverseEvent", "detected", element.getDetectedElement(), -1); 1700 if (element.hasRecordedDateElement()) 1701 composeDateTime(t, "AdverseEvent", "recordedDate", element.getRecordedDateElement(), -1); 1702 for (int i = 0; i < element.getResultingCondition().size(); i++) 1703 composeReference(t, "AdverseEvent", "resultingCondition", element.getResultingCondition().get(i), i); 1704 if (element.hasLocation()) 1705 composeReference(t, "AdverseEvent", "location", element.getLocation(), -1); 1706 if (element.hasSeriousness()) 1707 composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1); 1708 if (element.hasSeverity()) 1709 composeCodeableConcept(t, "AdverseEvent", "severity", element.getSeverity(), -1); 1710 if (element.hasOutcome()) 1711 composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1); 1712 if (element.hasRecorder()) 1713 composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1); 1714 for (int i = 0; i < element.getContributor().size(); i++) 1715 composeReference(t, "AdverseEvent", "contributor", element.getContributor().get(i), i); 1716 for (int i = 0; i < element.getSuspectEntity().size(); i++) 1717 composeAdverseEventAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i); 1718 for (int i = 0; i < element.getSubjectMedicalHistory().size(); i++) 1719 composeReference(t, "AdverseEvent", "subjectMedicalHistory", element.getSubjectMedicalHistory().get(i), i); 1720 for (int i = 0; i < element.getReferenceDocument().size(); i++) 1721 composeReference(t, "AdverseEvent", "referenceDocument", element.getReferenceDocument().get(i), i); 1722 for (int i = 0; i < element.getStudy().size(); i++) 1723 composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i); 1724 } 1725 1726 protected void composeAdverseEventAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) { 1727 if (element == null) 1728 return; 1729 Complex t; 1730 if (Utilities.noString(parentType)) 1731 t = parent; 1732 else { 1733 t = parent.predicate("fhir:"+parentType+'.'+name); 1734 } 1735 composeBackboneElement(t, "suspectEntity", name, element, index); 1736 if (element.hasInstance()) 1737 composeReference(t, "AdverseEvent", "instance", element.getInstance(), -1); 1738 for (int i = 0; i < element.getCausality().size(); i++) 1739 composeAdverseEventAdverseEventSuspectEntityCausalityComponent(t, "AdverseEvent", "causality", element.getCausality().get(i), i); 1740 } 1741 1742 protected void composeAdverseEventAdverseEventSuspectEntityCausalityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityCausalityComponent element, int index) { 1743 if (element == null) 1744 return; 1745 Complex t; 1746 if (Utilities.noString(parentType)) 1747 t = parent; 1748 else { 1749 t = parent.predicate("fhir:"+parentType+'.'+name); 1750 } 1751 composeBackboneElement(t, "causality", name, element, index); 1752 if (element.hasAssessment()) 1753 composeCodeableConcept(t, "AdverseEvent", "assessment", element.getAssessment(), -1); 1754 if (element.hasProductRelatednessElement()) 1755 composeString(t, "AdverseEvent", "productRelatedness", element.getProductRelatednessElement(), -1); 1756 if (element.hasAuthor()) 1757 composeReference(t, "AdverseEvent", "author", element.getAuthor(), -1); 1758 if (element.hasMethod()) 1759 composeCodeableConcept(t, "AdverseEvent", "method", element.getMethod(), -1); 1760 } 1761 1762 protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) { 1763 if (element == null) 1764 return; 1765 Complex t; 1766 if (Utilities.noString(parentType)) 1767 t = parent; 1768 else { 1769 t = parent.predicate("fhir:"+parentType+'.'+name); 1770 } 1771 composeDomainResource(t, "AllergyIntolerance", name, element, index); 1772 for (int i = 0; i < element.getIdentifier().size(); i++) 1773 composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i); 1774 if (element.hasClinicalStatus()) 1775 composeCodeableConcept(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatus(), -1); 1776 if (element.hasVerificationStatus()) 1777 composeCodeableConcept(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatus(), -1); 1778 if (element.hasTypeElement()) 1779 composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1); 1780 for (int i = 0; i < element.getCategory().size(); i++) 1781 composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i); 1782 if (element.hasCriticalityElement()) 1783 composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1); 1784 if (element.hasCode()) 1785 composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1); 1786 if (element.hasPatient()) 1787 composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1); 1788 if (element.hasEncounter()) 1789 composeReference(t, "AllergyIntolerance", "encounter", element.getEncounter(), -1); 1790 if (element.hasOnset()) 1791 composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1); 1792 if (element.hasRecordedDateElement()) 1793 composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1); 1794 if (element.hasRecorder()) 1795 composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1); 1796 if (element.hasAsserter()) 1797 composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1); 1798 if (element.hasLastOccurrenceElement()) 1799 composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1); 1800 for (int i = 0; i < element.getNote().size(); i++) 1801 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1802 for (int i = 0; i < element.getReaction().size(); i++) 1803 composeAllergyIntoleranceAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i); 1804 } 1805 1806 protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) { 1807 if (element == null) 1808 return; 1809 Complex t; 1810 if (Utilities.noString(parentType)) 1811 t = parent; 1812 else { 1813 t = parent.predicate("fhir:"+parentType+'.'+name); 1814 } 1815 composeBackboneElement(t, "reaction", name, element, index); 1816 if (element.hasSubstance()) 1817 composeCodeableConcept(t, "AllergyIntolerance", "substance", element.getSubstance(), -1); 1818 for (int i = 0; i < element.getManifestation().size(); i++) 1819 composeCodeableConcept(t, "AllergyIntolerance", "manifestation", element.getManifestation().get(i), i); 1820 if (element.hasDescriptionElement()) 1821 composeString(t, "AllergyIntolerance", "description", element.getDescriptionElement(), -1); 1822 if (element.hasOnsetElement()) 1823 composeDateTime(t, "AllergyIntolerance", "onset", element.getOnsetElement(), -1); 1824 if (element.hasSeverityElement()) 1825 composeEnum(t, "AllergyIntolerance", "severity", element.getSeverityElement(), -1); 1826 if (element.hasExposureRoute()) 1827 composeCodeableConcept(t, "AllergyIntolerance", "exposureRoute", element.getExposureRoute(), -1); 1828 for (int i = 0; i < element.getNote().size(); i++) 1829 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1830 } 1831 1832 protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) { 1833 if (element == null) 1834 return; 1835 Complex t; 1836 if (Utilities.noString(parentType)) 1837 t = parent; 1838 else { 1839 t = parent.predicate("fhir:"+parentType+'.'+name); 1840 } 1841 composeDomainResource(t, "Appointment", name, element, index); 1842 for (int i = 0; i < element.getIdentifier().size(); i++) 1843 composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i); 1844 if (element.hasStatusElement()) 1845 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1846 if (element.hasCancelationReason()) 1847 composeCodeableConcept(t, "Appointment", "cancelationReason", element.getCancelationReason(), -1); 1848 for (int i = 0; i < element.getServiceCategory().size(); i++) 1849 composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory().get(i), i); 1850 for (int i = 0; i < element.getServiceType().size(); i++) 1851 composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i); 1852 for (int i = 0; i < element.getSpecialty().size(); i++) 1853 composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i); 1854 if (element.hasAppointmentType()) 1855 composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1); 1856 for (int i = 0; i < element.getReasonCode().size(); i++) 1857 composeCodeableConcept(t, "Appointment", "reasonCode", element.getReasonCode().get(i), i); 1858 for (int i = 0; i < element.getReasonReference().size(); i++) 1859 composeReference(t, "Appointment", "reasonReference", element.getReasonReference().get(i), i); 1860 if (element.hasPriorityElement()) 1861 composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1); 1862 if (element.hasDescriptionElement()) 1863 composeString(t, "Appointment", "description", element.getDescriptionElement(), -1); 1864 for (int i = 0; i < element.getSupportingInformation().size(); i++) 1865 composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i); 1866 if (element.hasStartElement()) 1867 composeInstant(t, "Appointment", "start", element.getStartElement(), -1); 1868 if (element.hasEndElement()) 1869 composeInstant(t, "Appointment", "end", element.getEndElement(), -1); 1870 if (element.hasMinutesDurationElement()) 1871 composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1); 1872 for (int i = 0; i < element.getSlot().size(); i++) 1873 composeReference(t, "Appointment", "slot", element.getSlot().get(i), i); 1874 if (element.hasCreatedElement()) 1875 composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1); 1876 if (element.hasCommentElement()) 1877 composeString(t, "Appointment", "comment", element.getCommentElement(), -1); 1878 if (element.hasPatientInstructionElement()) 1879 composeString(t, "Appointment", "patientInstruction", element.getPatientInstructionElement(), -1); 1880 for (int i = 0; i < element.getBasedOn().size(); i++) 1881 composeReference(t, "Appointment", "basedOn", element.getBasedOn().get(i), i); 1882 for (int i = 0; i < element.getParticipant().size(); i++) 1883 composeAppointmentAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i); 1884 for (int i = 0; i < element.getRequestedPeriod().size(); i++) 1885 composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i); 1886 } 1887 1888 protected void composeAppointmentAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) { 1889 if (element == null) 1890 return; 1891 Complex t; 1892 if (Utilities.noString(parentType)) 1893 t = parent; 1894 else { 1895 t = parent.predicate("fhir:"+parentType+'.'+name); 1896 } 1897 composeBackboneElement(t, "participant", name, element, index); 1898 for (int i = 0; i < element.getType().size(); i++) 1899 composeCodeableConcept(t, "Appointment", "type", element.getType().get(i), i); 1900 if (element.hasActor()) 1901 composeReference(t, "Appointment", "actor", element.getActor(), -1); 1902 if (element.hasRequiredElement()) 1903 composeEnum(t, "Appointment", "required", element.getRequiredElement(), -1); 1904 if (element.hasStatusElement()) 1905 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1906 if (element.hasPeriod()) 1907 composePeriod(t, "Appointment", "period", element.getPeriod(), -1); 1908 } 1909 1910 protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) { 1911 if (element == null) 1912 return; 1913 Complex t; 1914 if (Utilities.noString(parentType)) 1915 t = parent; 1916 else { 1917 t = parent.predicate("fhir:"+parentType+'.'+name); 1918 } 1919 composeDomainResource(t, "AppointmentResponse", name, element, index); 1920 for (int i = 0; i < element.getIdentifier().size(); i++) 1921 composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i); 1922 if (element.hasAppointment()) 1923 composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1); 1924 if (element.hasStartElement()) 1925 composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1); 1926 if (element.hasEndElement()) 1927 composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1); 1928 for (int i = 0; i < element.getParticipantType().size(); i++) 1929 composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i); 1930 if (element.hasActor()) 1931 composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1); 1932 if (element.hasParticipantStatusElement()) 1933 composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1); 1934 if (element.hasCommentElement()) 1935 composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1); 1936 } 1937 1938 protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) { 1939 if (element == null) 1940 return; 1941 Complex t; 1942 if (Utilities.noString(parentType)) 1943 t = parent; 1944 else { 1945 t = parent.predicate("fhir:"+parentType+'.'+name); 1946 } 1947 composeDomainResource(t, "AuditEvent", name, element, index); 1948 if (element.hasType()) 1949 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1950 for (int i = 0; i < element.getSubtype().size(); i++) 1951 composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i); 1952 if (element.hasActionElement()) 1953 composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1); 1954 if (element.hasPeriod()) 1955 composePeriod(t, "AuditEvent", "period", element.getPeriod(), -1); 1956 if (element.hasRecordedElement()) 1957 composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1); 1958 if (element.hasOutcomeElement()) 1959 composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1); 1960 if (element.hasOutcomeDescElement()) 1961 composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1); 1962 for (int i = 0; i < element.getPurposeOfEvent().size(); i++) 1963 composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i); 1964 for (int i = 0; i < element.getAgent().size(); i++) 1965 composeAuditEventAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i); 1966 if (element.hasSource()) 1967 composeAuditEventAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1); 1968 for (int i = 0; i < element.getEntity().size(); i++) 1969 composeAuditEventAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i); 1970 } 1971 1972 protected void composeAuditEventAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) { 1973 if (element == null) 1974 return; 1975 Complex t; 1976 if (Utilities.noString(parentType)) 1977 t = parent; 1978 else { 1979 t = parent.predicate("fhir:"+parentType+'.'+name); 1980 } 1981 composeBackboneElement(t, "agent", name, element, index); 1982 if (element.hasType()) 1983 composeCodeableConcept(t, "AuditEvent", "type", element.getType(), -1); 1984 for (int i = 0; i < element.getRole().size(); i++) 1985 composeCodeableConcept(t, "AuditEvent", "role", element.getRole().get(i), i); 1986 if (element.hasWho()) 1987 composeReference(t, "AuditEvent", "who", element.getWho(), -1); 1988 if (element.hasAltIdElement()) 1989 composeString(t, "AuditEvent", "altId", element.getAltIdElement(), -1); 1990 if (element.hasNameElement()) 1991 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1992 if (element.hasRequestorElement()) 1993 composeBoolean(t, "AuditEvent", "requestor", element.getRequestorElement(), -1); 1994 if (element.hasLocation()) 1995 composeReference(t, "AuditEvent", "location", element.getLocation(), -1); 1996 for (int i = 0; i < element.getPolicy().size(); i++) 1997 composeUri(t, "AuditEvent", "policy", element.getPolicy().get(i), i); 1998 if (element.hasMedia()) 1999 composeCoding(t, "AuditEvent", "media", element.getMedia(), -1); 2000 if (element.hasNetwork()) 2001 composeAuditEventAuditEventAgentNetworkComponent(t, "AuditEvent", "network", element.getNetwork(), -1); 2002 for (int i = 0; i < element.getPurposeOfUse().size(); i++) 2003 composeCodeableConcept(t, "AuditEvent", "purposeOfUse", element.getPurposeOfUse().get(i), i); 2004 } 2005 2006 protected void composeAuditEventAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) { 2007 if (element == null) 2008 return; 2009 Complex t; 2010 if (Utilities.noString(parentType)) 2011 t = parent; 2012 else { 2013 t = parent.predicate("fhir:"+parentType+'.'+name); 2014 } 2015 composeBackboneElement(t, "network", name, element, index); 2016 if (element.hasAddressElement()) 2017 composeString(t, "AuditEvent", "address", element.getAddressElement(), -1); 2018 if (element.hasTypeElement()) 2019 composeEnum(t, "AuditEvent", "type", element.getTypeElement(), -1); 2020 } 2021 2022 protected void composeAuditEventAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) { 2023 if (element == null) 2024 return; 2025 Complex t; 2026 if (Utilities.noString(parentType)) 2027 t = parent; 2028 else { 2029 t = parent.predicate("fhir:"+parentType+'.'+name); 2030 } 2031 composeBackboneElement(t, "source", name, element, index); 2032 if (element.hasSiteElement()) 2033 composeString(t, "AuditEvent", "site", element.getSiteElement(), -1); 2034 if (element.hasObserver()) 2035 composeReference(t, "AuditEvent", "observer", element.getObserver(), -1); 2036 for (int i = 0; i < element.getType().size(); i++) 2037 composeCoding(t, "AuditEvent", "type", element.getType().get(i), i); 2038 } 2039 2040 protected void composeAuditEventAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) { 2041 if (element == null) 2042 return; 2043 Complex t; 2044 if (Utilities.noString(parentType)) 2045 t = parent; 2046 else { 2047 t = parent.predicate("fhir:"+parentType+'.'+name); 2048 } 2049 composeBackboneElement(t, "entity", name, element, index); 2050 if (element.hasWhat()) 2051 composeReference(t, "AuditEvent", "what", element.getWhat(), -1); 2052 if (element.hasType()) 2053 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 2054 if (element.hasRole()) 2055 composeCoding(t, "AuditEvent", "role", element.getRole(), -1); 2056 if (element.hasLifecycle()) 2057 composeCoding(t, "AuditEvent", "lifecycle", element.getLifecycle(), -1); 2058 for (int i = 0; i < element.getSecurityLabel().size(); i++) 2059 composeCoding(t, "AuditEvent", "securityLabel", element.getSecurityLabel().get(i), i); 2060 if (element.hasNameElement()) 2061 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 2062 if (element.hasDescriptionElement()) 2063 composeString(t, "AuditEvent", "description", element.getDescriptionElement(), -1); 2064 if (element.hasQueryElement()) 2065 composeBase64Binary(t, "AuditEvent", "query", element.getQueryElement(), -1); 2066 for (int i = 0; i < element.getDetail().size(); i++) 2067 composeAuditEventAuditEventEntityDetailComponent(t, "AuditEvent", "detail", element.getDetail().get(i), i); 2068 } 2069 2070 protected void composeAuditEventAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) { 2071 if (element == null) 2072 return; 2073 Complex t; 2074 if (Utilities.noString(parentType)) 2075 t = parent; 2076 else { 2077 t = parent.predicate("fhir:"+parentType+'.'+name); 2078 } 2079 composeBackboneElement(t, "detail", name, element, index); 2080 if (element.hasTypeElement()) 2081 composeString(t, "AuditEvent", "type", element.getTypeElement(), -1); 2082 if (element.hasValue()) 2083 composeType(t, "AuditEvent", "value", element.getValue(), -1); 2084 } 2085 2086 protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) { 2087 if (element == null) 2088 return; 2089 Complex t; 2090 if (Utilities.noString(parentType)) 2091 t = parent; 2092 else { 2093 t = parent.predicate("fhir:"+parentType+'.'+name); 2094 } 2095 composeDomainResource(t, "Basic", name, element, index); 2096 for (int i = 0; i < element.getIdentifier().size(); i++) 2097 composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i); 2098 if (element.hasCode()) 2099 composeCodeableConcept(t, "Basic", "code", element.getCode(), -1); 2100 if (element.hasSubject()) 2101 composeReference(t, "Basic", "subject", element.getSubject(), -1); 2102 if (element.hasCreatedElement()) 2103 composeDate(t, "Basic", "created", element.getCreatedElement(), -1); 2104 if (element.hasAuthor()) 2105 composeReference(t, "Basic", "author", element.getAuthor(), -1); 2106 } 2107 2108 protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) { 2109 if (element == null) 2110 return; 2111 Complex t; 2112 if (Utilities.noString(parentType)) 2113 t = parent; 2114 else { 2115 t = parent.predicate("fhir:"+parentType+'.'+name); 2116 } 2117 composeResource(t, "Binary", name, element, index); 2118 if (element.hasContentTypeElement()) 2119 composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1); 2120 if (element.hasSecurityContext()) 2121 composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1); 2122 if (element.hasDataElement()) 2123 composeBase64Binary(t, "Binary", "data", element.getDataElement(), -1); 2124 } 2125 2126 protected void composeBiologicallyDerivedProduct(Complex parent, String parentType, String name, BiologicallyDerivedProduct element, int index) { 2127 if (element == null) 2128 return; 2129 Complex t; 2130 if (Utilities.noString(parentType)) 2131 t = parent; 2132 else { 2133 t = parent.predicate("fhir:"+parentType+'.'+name); 2134 } 2135 composeDomainResource(t, "BiologicallyDerivedProduct", name, element, index); 2136 for (int i = 0; i < element.getIdentifier().size(); i++) 2137 composeIdentifier(t, "BiologicallyDerivedProduct", "identifier", element.getIdentifier().get(i), i); 2138 if (element.hasProductCategoryElement()) 2139 composeEnum(t, "BiologicallyDerivedProduct", "productCategory", element.getProductCategoryElement(), -1); 2140 if (element.hasProductCode()) 2141 composeCodeableConcept(t, "BiologicallyDerivedProduct", "productCode", element.getProductCode(), -1); 2142 if (element.hasStatusElement()) 2143 composeEnum(t, "BiologicallyDerivedProduct", "status", element.getStatusElement(), -1); 2144 for (int i = 0; i < element.getRequest().size(); i++) 2145 composeReference(t, "BiologicallyDerivedProduct", "request", element.getRequest().get(i), i); 2146 if (element.hasQuantityElement()) 2147 composeInteger(t, "BiologicallyDerivedProduct", "quantity", element.getQuantityElement(), -1); 2148 for (int i = 0; i < element.getParent().size(); i++) 2149 composeReference(t, "BiologicallyDerivedProduct", "parent", element.getParent().get(i), i); 2150 if (element.hasCollection()) 2151 composeBiologicallyDerivedProductBiologicallyDerivedProductCollectionComponent(t, "BiologicallyDerivedProduct", "collection", element.getCollection(), -1); 2152 for (int i = 0; i < element.getProcessing().size(); i++) 2153 composeBiologicallyDerivedProductBiologicallyDerivedProductProcessingComponent(t, "BiologicallyDerivedProduct", "processing", element.getProcessing().get(i), i); 2154 if (element.hasManipulation()) 2155 composeBiologicallyDerivedProductBiologicallyDerivedProductManipulationComponent(t, "BiologicallyDerivedProduct", "manipulation", element.getManipulation(), -1); 2156 for (int i = 0; i < element.getStorage().size(); i++) 2157 composeBiologicallyDerivedProductBiologicallyDerivedProductStorageComponent(t, "BiologicallyDerivedProduct", "storage", element.getStorage().get(i), i); 2158 } 2159 2160 protected void composeBiologicallyDerivedProductBiologicallyDerivedProductCollectionComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent element, int index) { 2161 if (element == null) 2162 return; 2163 Complex t; 2164 if (Utilities.noString(parentType)) 2165 t = parent; 2166 else { 2167 t = parent.predicate("fhir:"+parentType+'.'+name); 2168 } 2169 composeBackboneElement(t, "collection", name, element, index); 2170 if (element.hasCollector()) 2171 composeReference(t, "BiologicallyDerivedProduct", "collector", element.getCollector(), -1); 2172 if (element.hasSource()) 2173 composeReference(t, "BiologicallyDerivedProduct", "source", element.getSource(), -1); 2174 if (element.hasCollected()) 2175 composeType(t, "BiologicallyDerivedProduct", "collected", element.getCollected(), -1); 2176 } 2177 2178 protected void composeBiologicallyDerivedProductBiologicallyDerivedProductProcessingComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductProcessingComponent element, int index) { 2179 if (element == null) 2180 return; 2181 Complex t; 2182 if (Utilities.noString(parentType)) 2183 t = parent; 2184 else { 2185 t = parent.predicate("fhir:"+parentType+'.'+name); 2186 } 2187 composeBackboneElement(t, "processing", name, element, index); 2188 if (element.hasDescriptionElement()) 2189 composeString(t, "BiologicallyDerivedProduct", "description", element.getDescriptionElement(), -1); 2190 if (element.hasProcedure()) 2191 composeCodeableConcept(t, "BiologicallyDerivedProduct", "procedure", element.getProcedure(), -1); 2192 if (element.hasAdditive()) 2193 composeReference(t, "BiologicallyDerivedProduct", "additive", element.getAdditive(), -1); 2194 if (element.hasTime()) 2195 composeType(t, "BiologicallyDerivedProduct", "time", element.getTime(), -1); 2196 } 2197 2198 protected void composeBiologicallyDerivedProductBiologicallyDerivedProductManipulationComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductManipulationComponent element, int index) { 2199 if (element == null) 2200 return; 2201 Complex t; 2202 if (Utilities.noString(parentType)) 2203 t = parent; 2204 else { 2205 t = parent.predicate("fhir:"+parentType+'.'+name); 2206 } 2207 composeBackboneElement(t, "manipulation", name, element, index); 2208 if (element.hasDescriptionElement()) 2209 composeString(t, "BiologicallyDerivedProduct", "description", element.getDescriptionElement(), -1); 2210 if (element.hasTime()) 2211 composeType(t, "BiologicallyDerivedProduct", "time", element.getTime(), -1); 2212 } 2213 2214 protected void composeBiologicallyDerivedProductBiologicallyDerivedProductStorageComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductStorageComponent element, int index) { 2215 if (element == null) 2216 return; 2217 Complex t; 2218 if (Utilities.noString(parentType)) 2219 t = parent; 2220 else { 2221 t = parent.predicate("fhir:"+parentType+'.'+name); 2222 } 2223 composeBackboneElement(t, "storage", name, element, index); 2224 if (element.hasDescriptionElement()) 2225 composeString(t, "BiologicallyDerivedProduct", "description", element.getDescriptionElement(), -1); 2226 if (element.hasTemperatureElement()) 2227 composeDecimal(t, "BiologicallyDerivedProduct", "temperature", element.getTemperatureElement(), -1); 2228 if (element.hasScaleElement()) 2229 composeEnum(t, "BiologicallyDerivedProduct", "scale", element.getScaleElement(), -1); 2230 if (element.hasDuration()) 2231 composePeriod(t, "BiologicallyDerivedProduct", "duration", element.getDuration(), -1); 2232 } 2233 2234 protected void composeBodyStructure(Complex parent, String parentType, String name, BodyStructure element, int index) { 2235 if (element == null) 2236 return; 2237 Complex t; 2238 if (Utilities.noString(parentType)) 2239 t = parent; 2240 else { 2241 t = parent.predicate("fhir:"+parentType+'.'+name); 2242 } 2243 composeDomainResource(t, "BodyStructure", name, element, index); 2244 for (int i = 0; i < element.getIdentifier().size(); i++) 2245 composeIdentifier(t, "BodyStructure", "identifier", element.getIdentifier().get(i), i); 2246 if (element.hasActiveElement()) 2247 composeBoolean(t, "BodyStructure", "active", element.getActiveElement(), -1); 2248 if (element.hasMorphology()) 2249 composeCodeableConcept(t, "BodyStructure", "morphology", element.getMorphology(), -1); 2250 if (element.hasLocation()) 2251 composeCodeableConcept(t, "BodyStructure", "location", element.getLocation(), -1); 2252 for (int i = 0; i < element.getLocationQualifier().size(); i++) 2253 composeCodeableConcept(t, "BodyStructure", "locationQualifier", element.getLocationQualifier().get(i), i); 2254 if (element.hasDescriptionElement()) 2255 composeString(t, "BodyStructure", "description", element.getDescriptionElement(), -1); 2256 for (int i = 0; i < element.getImage().size(); i++) 2257 composeAttachment(t, "BodyStructure", "image", element.getImage().get(i), i); 2258 if (element.hasPatient()) 2259 composeReference(t, "BodyStructure", "patient", element.getPatient(), -1); 2260 } 2261 2262 protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) { 2263 if (element == null) 2264 return; 2265 Complex t; 2266 if (Utilities.noString(parentType)) 2267 t = parent; 2268 else { 2269 t = parent.predicate("fhir:"+parentType+'.'+name); 2270 } 2271 composeResource(t, "Bundle", name, element, index); 2272 if (element.hasIdentifier()) 2273 composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1); 2274 if (element.hasTypeElement()) 2275 composeEnum(t, "Bundle", "type", element.getTypeElement(), -1); 2276 if (element.hasTimestampElement()) 2277 composeInstant(t, "Bundle", "timestamp", element.getTimestampElement(), -1); 2278 if (element.hasTotalElement()) 2279 composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1); 2280 for (int i = 0; i < element.getLink().size(); i++) 2281 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 2282 for (int i = 0; i < element.getEntry().size(); i++) 2283 composeBundleBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i); 2284 if (element.hasSignature()) 2285 composeSignature(t, "Bundle", "signature", element.getSignature(), -1); 2286 } 2287 2288 protected void composeBundleBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) { 2289 if (element == null) 2290 return; 2291 Complex t; 2292 if (Utilities.noString(parentType)) 2293 t = parent; 2294 else { 2295 t = parent.predicate("fhir:"+parentType+'.'+name); 2296 } 2297 composeBackboneElement(t, "link", name, element, index); 2298 if (element.hasRelationElement()) 2299 composeString(t, "Bundle", "relation", element.getRelationElement(), -1); 2300 if (element.hasUrlElement()) 2301 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 2302 } 2303 2304 protected void composeBundleBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) { 2305 if (element == null) 2306 return; 2307 Complex t; 2308 if (Utilities.noString(parentType)) 2309 t = parent; 2310 else { 2311 t = parent.predicate("fhir:"+parentType+'.'+name); 2312 } 2313 composeBackboneElement(t, "entry", name, element, index); 2314 for (int i = 0; i < element.getLink().size(); i++) 2315 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 2316 if (element.hasFullUrlElement()) 2317 composeUri(t, "Bundle", "fullUrl", element.getFullUrlElement(), -1); 2318 if (element.hasResource()) 2319 composeResource(t, "Bundle", "resource", element.getResource(), -1); 2320 if (element.hasSearch()) 2321 composeBundleBundleEntrySearchComponent(t, "Bundle", "search", element.getSearch(), -1); 2322 if (element.hasRequest()) 2323 composeBundleBundleEntryRequestComponent(t, "Bundle", "request", element.getRequest(), -1); 2324 if (element.hasResponse()) 2325 composeBundleBundleEntryResponseComponent(t, "Bundle", "response", element.getResponse(), -1); 2326 } 2327 2328 protected void composeBundleBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) { 2329 if (element == null) 2330 return; 2331 Complex t; 2332 if (Utilities.noString(parentType)) 2333 t = parent; 2334 else { 2335 t = parent.predicate("fhir:"+parentType+'.'+name); 2336 } 2337 composeBackboneElement(t, "search", name, element, index); 2338 if (element.hasModeElement()) 2339 composeEnum(t, "Bundle", "mode", element.getModeElement(), -1); 2340 if (element.hasScoreElement()) 2341 composeDecimal(t, "Bundle", "score", element.getScoreElement(), -1); 2342 } 2343 2344 protected void composeBundleBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) { 2345 if (element == null) 2346 return; 2347 Complex t; 2348 if (Utilities.noString(parentType)) 2349 t = parent; 2350 else { 2351 t = parent.predicate("fhir:"+parentType+'.'+name); 2352 } 2353 composeBackboneElement(t, "request", name, element, index); 2354 if (element.hasMethodElement()) 2355 composeEnum(t, "Bundle", "method", element.getMethodElement(), -1); 2356 if (element.hasUrlElement()) 2357 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 2358 if (element.hasIfNoneMatchElement()) 2359 composeString(t, "Bundle", "ifNoneMatch", element.getIfNoneMatchElement(), -1); 2360 if (element.hasIfModifiedSinceElement()) 2361 composeInstant(t, "Bundle", "ifModifiedSince", element.getIfModifiedSinceElement(), -1); 2362 if (element.hasIfMatchElement()) 2363 composeString(t, "Bundle", "ifMatch", element.getIfMatchElement(), -1); 2364 if (element.hasIfNoneExistElement()) 2365 composeString(t, "Bundle", "ifNoneExist", element.getIfNoneExistElement(), -1); 2366 } 2367 2368 protected void composeBundleBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) { 2369 if (element == null) 2370 return; 2371 Complex t; 2372 if (Utilities.noString(parentType)) 2373 t = parent; 2374 else { 2375 t = parent.predicate("fhir:"+parentType+'.'+name); 2376 } 2377 composeBackboneElement(t, "response", name, element, index); 2378 if (element.hasStatusElement()) 2379 composeString(t, "Bundle", "status", element.getStatusElement(), -1); 2380 if (element.hasLocationElement()) 2381 composeUri(t, "Bundle", "location", element.getLocationElement(), -1); 2382 if (element.hasEtagElement()) 2383 composeString(t, "Bundle", "etag", element.getEtagElement(), -1); 2384 if (element.hasLastModifiedElement()) 2385 composeInstant(t, "Bundle", "lastModified", element.getLastModifiedElement(), -1); 2386 if (element.hasOutcome()) 2387 composeResource(t, "Bundle", "outcome", element.getOutcome(), -1); 2388 } 2389 2390 protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) { 2391 if (element == null) 2392 return; 2393 Complex t; 2394 if (Utilities.noString(parentType)) 2395 t = parent; 2396 else { 2397 t = parent.predicate("fhir:"+parentType+'.'+name); 2398 } 2399 composeDomainResource(t, "CapabilityStatement", name, element, index); 2400 if (element.hasUrlElement()) 2401 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 2402 if (element.hasVersionElement()) 2403 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 2404 if (element.hasNameElement()) 2405 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2406 if (element.hasTitleElement()) 2407 composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1); 2408 if (element.hasStatusElement()) 2409 composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1); 2410 if (element.hasExperimentalElement()) 2411 composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1); 2412 if (element.hasDateElement()) 2413 composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1); 2414 if (element.hasPublisherElement()) 2415 composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1); 2416 for (int i = 0; i < element.getContact().size(); i++) 2417 composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i); 2418 if (element.hasDescriptionElement()) 2419 composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2420 for (int i = 0; i < element.getUseContext().size(); i++) 2421 composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i); 2422 for (int i = 0; i < element.getJurisdiction().size(); i++) 2423 composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i); 2424 if (element.hasPurposeElement()) 2425 composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1); 2426 if (element.hasCopyrightElement()) 2427 composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1); 2428 if (element.hasKindElement()) 2429 composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1); 2430 for (int i = 0; i < element.getInstantiates().size(); i++) 2431 composeCanonical(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i); 2432 for (int i = 0; i < element.getImports().size(); i++) 2433 composeCanonical(t, "CapabilityStatement", "imports", element.getImports().get(i), i); 2434 if (element.hasSoftware()) 2435 composeCapabilityStatementCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1); 2436 if (element.hasImplementation()) 2437 composeCapabilityStatementCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1); 2438 if (element.hasFhirVersionElement()) 2439 composeEnum(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1); 2440 for (int i = 0; i < element.getFormat().size(); i++) 2441 composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i); 2442 for (int i = 0; i < element.getPatchFormat().size(); i++) 2443 composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i); 2444 for (int i = 0; i < element.getImplementationGuide().size(); i++) 2445 composeCanonical(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i); 2446 for (int i = 0; i < element.getRest().size(); i++) 2447 composeCapabilityStatementCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i); 2448 for (int i = 0; i < element.getMessaging().size(); i++) 2449 composeCapabilityStatementCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i); 2450 for (int i = 0; i < element.getDocument().size(); i++) 2451 composeCapabilityStatementCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i); 2452 } 2453 2454 protected void composeCapabilityStatementCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) { 2455 if (element == null) 2456 return; 2457 Complex t; 2458 if (Utilities.noString(parentType)) 2459 t = parent; 2460 else { 2461 t = parent.predicate("fhir:"+parentType+'.'+name); 2462 } 2463 composeBackboneElement(t, "software", name, element, index); 2464 if (element.hasNameElement()) 2465 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2466 if (element.hasVersionElement()) 2467 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 2468 if (element.hasReleaseDateElement()) 2469 composeDateTime(t, "CapabilityStatement", "releaseDate", element.getReleaseDateElement(), -1); 2470 } 2471 2472 protected void composeCapabilityStatementCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) { 2473 if (element == null) 2474 return; 2475 Complex t; 2476 if (Utilities.noString(parentType)) 2477 t = parent; 2478 else { 2479 t = parent.predicate("fhir:"+parentType+'.'+name); 2480 } 2481 composeBackboneElement(t, "implementation", name, element, index); 2482 if (element.hasDescriptionElement()) 2483 composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2484 if (element.hasUrlElement()) 2485 composeUrl(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 2486 if (element.hasCustodian()) 2487 composeReference(t, "CapabilityStatement", "custodian", element.getCustodian(), -1); 2488 } 2489 2490 protected void composeCapabilityStatementCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) { 2491 if (element == null) 2492 return; 2493 Complex t; 2494 if (Utilities.noString(parentType)) 2495 t = parent; 2496 else { 2497 t = parent.predicate("fhir:"+parentType+'.'+name); 2498 } 2499 composeBackboneElement(t, "rest", name, element, index); 2500 if (element.hasModeElement()) 2501 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2502 if (element.hasDocumentationElement()) 2503 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2504 if (element.hasSecurity()) 2505 composeCapabilityStatementCapabilityStatementRestSecurityComponent(t, "CapabilityStatement", "security", element.getSecurity(), -1); 2506 for (int i = 0; i < element.getResource().size(); i++) 2507 composeCapabilityStatementCapabilityStatementRestResourceComponent(t, "CapabilityStatement", "resource", element.getResource().get(i), i); 2508 for (int i = 0; i < element.getInteraction().size(); i++) 2509 composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i); 2510 for (int i = 0; i < element.getSearchParam().size(); i++) 2511 composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i); 2512 for (int i = 0; i < element.getOperation().size(); i++) 2513 composeCapabilityStatementCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatement", "operation", element.getOperation().get(i), i); 2514 for (int i = 0; i < element.getCompartment().size(); i++) 2515 composeCanonical(t, "CapabilityStatement", "compartment", element.getCompartment().get(i), i); 2516 } 2517 2518 protected void composeCapabilityStatementCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) { 2519 if (element == null) 2520 return; 2521 Complex t; 2522 if (Utilities.noString(parentType)) 2523 t = parent; 2524 else { 2525 t = parent.predicate("fhir:"+parentType+'.'+name); 2526 } 2527 composeBackboneElement(t, "security", name, element, index); 2528 if (element.hasCorsElement()) 2529 composeBoolean(t, "CapabilityStatement", "cors", element.getCorsElement(), -1); 2530 for (int i = 0; i < element.getService().size(); i++) 2531 composeCodeableConcept(t, "CapabilityStatement", "service", element.getService().get(i), i); 2532 if (element.hasDescriptionElement()) 2533 composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2534 } 2535 2536 protected void composeCapabilityStatementCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) { 2537 if (element == null) 2538 return; 2539 Complex t; 2540 if (Utilities.noString(parentType)) 2541 t = parent; 2542 else { 2543 t = parent.predicate("fhir:"+parentType+'.'+name); 2544 } 2545 composeBackboneElement(t, "resource", name, element, index); 2546 if (element.hasTypeElement()) 2547 composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2548 if (element.hasProfileElement()) 2549 composeCanonical(t, "CapabilityStatement", "profile", element.getProfileElement(), -1); 2550 for (int i = 0; i < element.getSupportedProfile().size(); i++) 2551 composeCanonical(t, "CapabilityStatement", "supportedProfile", element.getSupportedProfile().get(i), i); 2552 if (element.hasDocumentationElement()) 2553 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2554 for (int i = 0; i < element.getInteraction().size(); i++) 2555 composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i); 2556 if (element.hasVersioningElement()) 2557 composeEnum(t, "CapabilityStatement", "versioning", element.getVersioningElement(), -1); 2558 if (element.hasReadHistoryElement()) 2559 composeBoolean(t, "CapabilityStatement", "readHistory", element.getReadHistoryElement(), -1); 2560 if (element.hasUpdateCreateElement()) 2561 composeBoolean(t, "CapabilityStatement", "updateCreate", element.getUpdateCreateElement(), -1); 2562 if (element.hasConditionalCreateElement()) 2563 composeBoolean(t, "CapabilityStatement", "conditionalCreate", element.getConditionalCreateElement(), -1); 2564 if (element.hasConditionalReadElement()) 2565 composeEnum(t, "CapabilityStatement", "conditionalRead", element.getConditionalReadElement(), -1); 2566 if (element.hasConditionalUpdateElement()) 2567 composeBoolean(t, "CapabilityStatement", "conditionalUpdate", element.getConditionalUpdateElement(), -1); 2568 if (element.hasConditionalDeleteElement()) 2569 composeEnum(t, "CapabilityStatement", "conditionalDelete", element.getConditionalDeleteElement(), -1); 2570 for (int i = 0; i < element.getReferencePolicy().size(); i++) 2571 composeEnum(t, "CapabilityStatement", "referencePolicy", element.getReferencePolicy().get(i), i); 2572 for (int i = 0; i < element.getSearchInclude().size(); i++) 2573 composeString(t, "CapabilityStatement", "searchInclude", element.getSearchInclude().get(i), i); 2574 for (int i = 0; i < element.getSearchRevInclude().size(); i++) 2575 composeString(t, "CapabilityStatement", "searchRevInclude", element.getSearchRevInclude().get(i), i); 2576 for (int i = 0; i < element.getSearchParam().size(); i++) 2577 composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i); 2578 for (int i = 0; i < element.getOperation().size(); i++) 2579 composeCapabilityStatementCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatement", "operation", element.getOperation().get(i), i); 2580 } 2581 2582 protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) { 2583 if (element == null) 2584 return; 2585 Complex t; 2586 if (Utilities.noString(parentType)) 2587 t = parent; 2588 else { 2589 t = parent.predicate("fhir:"+parentType+'.'+name); 2590 } 2591 composeBackboneElement(t, "interaction", name, element, index); 2592 if (element.hasCodeElement()) 2593 composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1); 2594 if (element.hasDocumentationElement()) 2595 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2596 } 2597 2598 protected void composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) { 2599 if (element == null) 2600 return; 2601 Complex t; 2602 if (Utilities.noString(parentType)) 2603 t = parent; 2604 else { 2605 t = parent.predicate("fhir:"+parentType+'.'+name); 2606 } 2607 composeBackboneElement(t, "searchParam", name, element, index); 2608 if (element.hasNameElement()) 2609 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2610 if (element.hasDefinitionElement()) 2611 composeCanonical(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1); 2612 if (element.hasTypeElement()) 2613 composeEnum(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2614 if (element.hasDocumentationElement()) 2615 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2616 } 2617 2618 protected void composeCapabilityStatementCapabilityStatementRestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceOperationComponent element, int index) { 2619 if (element == null) 2620 return; 2621 Complex t; 2622 if (Utilities.noString(parentType)) 2623 t = parent; 2624 else { 2625 t = parent.predicate("fhir:"+parentType+'.'+name); 2626 } 2627 composeBackboneElement(t, "operation", name, element, index); 2628 if (element.hasNameElement()) 2629 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2630 if (element.hasDefinitionElement()) 2631 composeCanonical(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1); 2632 if (element.hasDocumentationElement()) 2633 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2634 } 2635 2636 protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) { 2637 if (element == null) 2638 return; 2639 Complex t; 2640 if (Utilities.noString(parentType)) 2641 t = parent; 2642 else { 2643 t = parent.predicate("fhir:"+parentType+'.'+name); 2644 } 2645 composeBackboneElement(t, "interaction", name, element, index); 2646 if (element.hasCodeElement()) 2647 composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1); 2648 if (element.hasDocumentationElement()) 2649 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2650 } 2651 2652 protected void composeCapabilityStatementCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) { 2653 if (element == null) 2654 return; 2655 Complex t; 2656 if (Utilities.noString(parentType)) 2657 t = parent; 2658 else { 2659 t = parent.predicate("fhir:"+parentType+'.'+name); 2660 } 2661 composeBackboneElement(t, "messaging", name, element, index); 2662 for (int i = 0; i < element.getEndpoint().size(); i++) 2663 composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatement", "endpoint", element.getEndpoint().get(i), i); 2664 if (element.hasReliableCacheElement()) 2665 composeUnsignedInt(t, "CapabilityStatement", "reliableCache", element.getReliableCacheElement(), -1); 2666 if (element.hasDocumentationElement()) 2667 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2668 for (int i = 0; i < element.getSupportedMessage().size(); i++) 2669 composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatement", "supportedMessage", element.getSupportedMessage().get(i), i); 2670 } 2671 2672 protected void composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) { 2673 if (element == null) 2674 return; 2675 Complex t; 2676 if (Utilities.noString(parentType)) 2677 t = parent; 2678 else { 2679 t = parent.predicate("fhir:"+parentType+'.'+name); 2680 } 2681 composeBackboneElement(t, "endpoint", name, element, index); 2682 if (element.hasProtocol()) 2683 composeCoding(t, "CapabilityStatement", "protocol", element.getProtocol(), -1); 2684 if (element.hasAddressElement()) 2685 composeUrl(t, "CapabilityStatement", "address", element.getAddressElement(), -1); 2686 } 2687 2688 protected void composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) { 2689 if (element == null) 2690 return; 2691 Complex t; 2692 if (Utilities.noString(parentType)) 2693 t = parent; 2694 else { 2695 t = parent.predicate("fhir:"+parentType+'.'+name); 2696 } 2697 composeBackboneElement(t, "supportedMessage", name, element, index); 2698 if (element.hasModeElement()) 2699 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2700 if (element.hasDefinitionElement()) 2701 composeCanonical(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1); 2702 } 2703 2704 protected void composeCapabilityStatementCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) { 2705 if (element == null) 2706 return; 2707 Complex t; 2708 if (Utilities.noString(parentType)) 2709 t = parent; 2710 else { 2711 t = parent.predicate("fhir:"+parentType+'.'+name); 2712 } 2713 composeBackboneElement(t, "document", name, element, index); 2714 if (element.hasModeElement()) 2715 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2716 if (element.hasDocumentationElement()) 2717 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2718 if (element.hasProfileElement()) 2719 composeCanonical(t, "CapabilityStatement", "profile", element.getProfileElement(), -1); 2720 } 2721 2722 protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) { 2723 if (element == null) 2724 return; 2725 Complex t; 2726 if (Utilities.noString(parentType)) 2727 t = parent; 2728 else { 2729 t = parent.predicate("fhir:"+parentType+'.'+name); 2730 } 2731 composeDomainResource(t, "CarePlan", name, element, index); 2732 for (int i = 0; i < element.getIdentifier().size(); i++) 2733 composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i); 2734 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 2735 composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 2736 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 2737 composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i); 2738 for (int i = 0; i < element.getBasedOn().size(); i++) 2739 composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i); 2740 for (int i = 0; i < element.getReplaces().size(); i++) 2741 composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i); 2742 for (int i = 0; i < element.getPartOf().size(); i++) 2743 composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i); 2744 if (element.hasStatusElement()) 2745 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 2746 if (element.hasIntentElement()) 2747 composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1); 2748 for (int i = 0; i < element.getCategory().size(); i++) 2749 composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i); 2750 if (element.hasTitleElement()) 2751 composeString(t, "CarePlan", "title", element.getTitleElement(), -1); 2752 if (element.hasDescriptionElement()) 2753 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 2754 if (element.hasSubject()) 2755 composeReference(t, "CarePlan", "subject", element.getSubject(), -1); 2756 if (element.hasEncounter()) 2757 composeReference(t, "CarePlan", "encounter", element.getEncounter(), -1); 2758 if (element.hasPeriod()) 2759 composePeriod(t, "CarePlan", "period", element.getPeriod(), -1); 2760 if (element.hasCreatedElement()) 2761 composeDateTime(t, "CarePlan", "created", element.getCreatedElement(), -1); 2762 if (element.hasAuthor()) 2763 composeReference(t, "CarePlan", "author", element.getAuthor(), -1); 2764 for (int i = 0; i < element.getContributor().size(); i++) 2765 composeReference(t, "CarePlan", "contributor", element.getContributor().get(i), i); 2766 for (int i = 0; i < element.getCareTeam().size(); i++) 2767 composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i); 2768 for (int i = 0; i < element.getAddresses().size(); i++) 2769 composeReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i); 2770 for (int i = 0; i < element.getSupportingInfo().size(); i++) 2771 composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i); 2772 for (int i = 0; i < element.getGoal().size(); i++) 2773 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 2774 for (int i = 0; i < element.getActivity().size(); i++) 2775 composeCarePlanCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i); 2776 for (int i = 0; i < element.getNote().size(); i++) 2777 composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i); 2778 } 2779 2780 protected void composeCarePlanCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) { 2781 if (element == null) 2782 return; 2783 Complex t; 2784 if (Utilities.noString(parentType)) 2785 t = parent; 2786 else { 2787 t = parent.predicate("fhir:"+parentType+'.'+name); 2788 } 2789 composeBackboneElement(t, "activity", name, element, index); 2790 for (int i = 0; i < element.getOutcomeCodeableConcept().size(); i++) 2791 composeCodeableConcept(t, "CarePlan", "outcomeCodeableConcept", element.getOutcomeCodeableConcept().get(i), i); 2792 for (int i = 0; i < element.getOutcomeReference().size(); i++) 2793 composeReference(t, "CarePlan", "outcomeReference", element.getOutcomeReference().get(i), i); 2794 for (int i = 0; i < element.getProgress().size(); i++) 2795 composeAnnotation(t, "CarePlan", "progress", element.getProgress().get(i), i); 2796 if (element.hasReference()) 2797 composeReference(t, "CarePlan", "reference", element.getReference(), -1); 2798 if (element.hasDetail()) 2799 composeCarePlanCarePlanActivityDetailComponent(t, "CarePlan", "detail", element.getDetail(), -1); 2800 } 2801 2802 protected void composeCarePlanCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) { 2803 if (element == null) 2804 return; 2805 Complex t; 2806 if (Utilities.noString(parentType)) 2807 t = parent; 2808 else { 2809 t = parent.predicate("fhir:"+parentType+'.'+name); 2810 } 2811 composeBackboneElement(t, "detail", name, element, index); 2812 if (element.hasKindElement()) 2813 composeEnum(t, "CarePlan", "kind", element.getKindElement(), -1); 2814 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 2815 composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 2816 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 2817 composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i); 2818 if (element.hasCode()) 2819 composeCodeableConcept(t, "CarePlan", "code", element.getCode(), -1); 2820 for (int i = 0; i < element.getReasonCode().size(); i++) 2821 composeCodeableConcept(t, "CarePlan", "reasonCode", element.getReasonCode().get(i), i); 2822 for (int i = 0; i < element.getReasonReference().size(); i++) 2823 composeReference(t, "CarePlan", "reasonReference", element.getReasonReference().get(i), i); 2824 for (int i = 0; i < element.getGoal().size(); i++) 2825 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 2826 if (element.hasStatusElement()) 2827 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 2828 if (element.hasStatusReason()) 2829 composeCodeableConcept(t, "CarePlan", "statusReason", element.getStatusReason(), -1); 2830 if (element.hasDoNotPerformElement()) 2831 composeBoolean(t, "CarePlan", "doNotPerform", element.getDoNotPerformElement(), -1); 2832 if (element.hasScheduled()) 2833 composeType(t, "CarePlan", "scheduled", element.getScheduled(), -1); 2834 if (element.hasLocation()) 2835 composeReference(t, "CarePlan", "location", element.getLocation(), -1); 2836 for (int i = 0; i < element.getPerformer().size(); i++) 2837 composeReference(t, "CarePlan", "performer", element.getPerformer().get(i), i); 2838 if (element.hasProduct()) 2839 composeType(t, "CarePlan", "product", element.getProduct(), -1); 2840 if (element.hasDailyAmount()) 2841 composeQuantity(t, "CarePlan", "dailyAmount", element.getDailyAmount(), -1); 2842 if (element.hasQuantity()) 2843 composeQuantity(t, "CarePlan", "quantity", element.getQuantity(), -1); 2844 if (element.hasDescriptionElement()) 2845 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 2846 } 2847 2848 protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) { 2849 if (element == null) 2850 return; 2851 Complex t; 2852 if (Utilities.noString(parentType)) 2853 t = parent; 2854 else { 2855 t = parent.predicate("fhir:"+parentType+'.'+name); 2856 } 2857 composeDomainResource(t, "CareTeam", name, element, index); 2858 for (int i = 0; i < element.getIdentifier().size(); i++) 2859 composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i); 2860 if (element.hasStatusElement()) 2861 composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1); 2862 for (int i = 0; i < element.getCategory().size(); i++) 2863 composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i); 2864 if (element.hasNameElement()) 2865 composeString(t, "CareTeam", "name", element.getNameElement(), -1); 2866 if (element.hasSubject()) 2867 composeReference(t, "CareTeam", "subject", element.getSubject(), -1); 2868 if (element.hasEncounter()) 2869 composeReference(t, "CareTeam", "encounter", element.getEncounter(), -1); 2870 if (element.hasPeriod()) 2871 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 2872 for (int i = 0; i < element.getParticipant().size(); i++) 2873 composeCareTeamCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i); 2874 for (int i = 0; i < element.getReasonCode().size(); i++) 2875 composeCodeableConcept(t, "CareTeam", "reasonCode", element.getReasonCode().get(i), i); 2876 for (int i = 0; i < element.getReasonReference().size(); i++) 2877 composeReference(t, "CareTeam", "reasonReference", element.getReasonReference().get(i), i); 2878 for (int i = 0; i < element.getManagingOrganization().size(); i++) 2879 composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i); 2880 for (int i = 0; i < element.getTelecom().size(); i++) 2881 composeContactPoint(t, "CareTeam", "telecom", element.getTelecom().get(i), i); 2882 for (int i = 0; i < element.getNote().size(); i++) 2883 composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i); 2884 } 2885 2886 protected void composeCareTeamCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) { 2887 if (element == null) 2888 return; 2889 Complex t; 2890 if (Utilities.noString(parentType)) 2891 t = parent; 2892 else { 2893 t = parent.predicate("fhir:"+parentType+'.'+name); 2894 } 2895 composeBackboneElement(t, "participant", name, element, index); 2896 for (int i = 0; i < element.getRole().size(); i++) 2897 composeCodeableConcept(t, "CareTeam", "role", element.getRole().get(i), i); 2898 if (element.hasMember()) 2899 composeReference(t, "CareTeam", "member", element.getMember(), -1); 2900 if (element.hasOnBehalfOf()) 2901 composeReference(t, "CareTeam", "onBehalfOf", element.getOnBehalfOf(), -1); 2902 if (element.hasPeriod()) 2903 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 2904 } 2905 2906 protected void composeCatalogEntry(Complex parent, String parentType, String name, CatalogEntry element, int index) { 2907 if (element == null) 2908 return; 2909 Complex t; 2910 if (Utilities.noString(parentType)) 2911 t = parent; 2912 else { 2913 t = parent.predicate("fhir:"+parentType+'.'+name); 2914 } 2915 composeDomainResource(t, "CatalogEntry", name, element, index); 2916 for (int i = 0; i < element.getIdentifier().size(); i++) 2917 composeIdentifier(t, "CatalogEntry", "identifier", element.getIdentifier().get(i), i); 2918 if (element.hasType()) 2919 composeCodeableConcept(t, "CatalogEntry", "type", element.getType(), -1); 2920 if (element.hasOrderableElement()) 2921 composeBoolean(t, "CatalogEntry", "orderable", element.getOrderableElement(), -1); 2922 if (element.hasReferencedItem()) 2923 composeReference(t, "CatalogEntry", "referencedItem", element.getReferencedItem(), -1); 2924 for (int i = 0; i < element.getAdditionalIdentifier().size(); i++) 2925 composeIdentifier(t, "CatalogEntry", "additionalIdentifier", element.getAdditionalIdentifier().get(i), i); 2926 for (int i = 0; i < element.getClassification().size(); i++) 2927 composeCodeableConcept(t, "CatalogEntry", "classification", element.getClassification().get(i), i); 2928 if (element.hasStatusElement()) 2929 composeEnum(t, "CatalogEntry", "status", element.getStatusElement(), -1); 2930 if (element.hasValidityPeriod()) 2931 composePeriod(t, "CatalogEntry", "validityPeriod", element.getValidityPeriod(), -1); 2932 if (element.hasValidToElement()) 2933 composeDateTime(t, "CatalogEntry", "validTo", element.getValidToElement(), -1); 2934 if (element.hasLastUpdatedElement()) 2935 composeDateTime(t, "CatalogEntry", "lastUpdated", element.getLastUpdatedElement(), -1); 2936 for (int i = 0; i < element.getAdditionalCharacteristic().size(); i++) 2937 composeCodeableConcept(t, "CatalogEntry", "additionalCharacteristic", element.getAdditionalCharacteristic().get(i), i); 2938 for (int i = 0; i < element.getAdditionalClassification().size(); i++) 2939 composeCodeableConcept(t, "CatalogEntry", "additionalClassification", element.getAdditionalClassification().get(i), i); 2940 for (int i = 0; i < element.getRelatedEntry().size(); i++) 2941 composeCatalogEntryCatalogEntryRelatedEntryComponent(t, "CatalogEntry", "relatedEntry", element.getRelatedEntry().get(i), i); 2942 } 2943 2944 protected void composeCatalogEntryCatalogEntryRelatedEntryComponent(Complex parent, String parentType, String name, CatalogEntry.CatalogEntryRelatedEntryComponent element, int index) { 2945 if (element == null) 2946 return; 2947 Complex t; 2948 if (Utilities.noString(parentType)) 2949 t = parent; 2950 else { 2951 t = parent.predicate("fhir:"+parentType+'.'+name); 2952 } 2953 composeBackboneElement(t, "relatedEntry", name, element, index); 2954 if (element.hasRelationtypeElement()) 2955 composeEnum(t, "CatalogEntry", "relationtype", element.getRelationtypeElement(), -1); 2956 if (element.hasItem()) 2957 composeReference(t, "CatalogEntry", "item", element.getItem(), -1); 2958 } 2959 2960 protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) { 2961 if (element == null) 2962 return; 2963 Complex t; 2964 if (Utilities.noString(parentType)) 2965 t = parent; 2966 else { 2967 t = parent.predicate("fhir:"+parentType+'.'+name); 2968 } 2969 composeDomainResource(t, "ChargeItem", name, element, index); 2970 for (int i = 0; i < element.getIdentifier().size(); i++) 2971 composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier().get(i), i); 2972 for (int i = 0; i < element.getDefinitionUri().size(); i++) 2973 composeUri(t, "ChargeItem", "definitionUri", element.getDefinitionUri().get(i), i); 2974 for (int i = 0; i < element.getDefinitionCanonical().size(); i++) 2975 composeCanonical(t, "ChargeItem", "definitionCanonical", element.getDefinitionCanonical().get(i), i); 2976 if (element.hasStatusElement()) 2977 composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1); 2978 for (int i = 0; i < element.getPartOf().size(); i++) 2979 composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i); 2980 if (element.hasCode()) 2981 composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1); 2982 if (element.hasSubject()) 2983 composeReference(t, "ChargeItem", "subject", element.getSubject(), -1); 2984 if (element.hasContext()) 2985 composeReference(t, "ChargeItem", "context", element.getContext(), -1); 2986 if (element.hasOccurrence()) 2987 composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1); 2988 for (int i = 0; i < element.getPerformer().size(); i++) 2989 composeChargeItemChargeItemPerformerComponent(t, "ChargeItem", "performer", element.getPerformer().get(i), i); 2990 if (element.hasPerformingOrganization()) 2991 composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1); 2992 if (element.hasRequestingOrganization()) 2993 composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1); 2994 if (element.hasCostCenter()) 2995 composeReference(t, "ChargeItem", "costCenter", element.getCostCenter(), -1); 2996 if (element.hasQuantity()) 2997 composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1); 2998 for (int i = 0; i < element.getBodysite().size(); i++) 2999 composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i); 3000 if (element.hasFactorOverrideElement()) 3001 composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1); 3002 if (element.hasPriceOverride()) 3003 composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1); 3004 if (element.hasOverrideReasonElement()) 3005 composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1); 3006 if (element.hasEnterer()) 3007 composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1); 3008 if (element.hasEnteredDateElement()) 3009 composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1); 3010 for (int i = 0; i < element.getReason().size(); i++) 3011 composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i); 3012 for (int i = 0; i < element.getService().size(); i++) 3013 composeReference(t, "ChargeItem", "service", element.getService().get(i), i); 3014 if (element.hasProduct()) 3015 composeType(t, "ChargeItem", "product", element.getProduct(), -1); 3016 for (int i = 0; i < element.getAccount().size(); i++) 3017 composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i); 3018 for (int i = 0; i < element.getNote().size(); i++) 3019 composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i); 3020 for (int i = 0; i < element.getSupportingInformation().size(); i++) 3021 composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i); 3022 } 3023 3024 protected void composeChargeItemChargeItemPerformerComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemPerformerComponent element, int index) { 3025 if (element == null) 3026 return; 3027 Complex t; 3028 if (Utilities.noString(parentType)) 3029 t = parent; 3030 else { 3031 t = parent.predicate("fhir:"+parentType+'.'+name); 3032 } 3033 composeBackboneElement(t, "performer", name, element, index); 3034 if (element.hasFunction()) 3035 composeCodeableConcept(t, "ChargeItem", "function", element.getFunction(), -1); 3036 if (element.hasActor()) 3037 composeReference(t, "ChargeItem", "actor", element.getActor(), -1); 3038 } 3039 3040 protected void composeChargeItemDefinition(Complex parent, String parentType, String name, ChargeItemDefinition element, int index) { 3041 if (element == null) 3042 return; 3043 Complex t; 3044 if (Utilities.noString(parentType)) 3045 t = parent; 3046 else { 3047 t = parent.predicate("fhir:"+parentType+'.'+name); 3048 } 3049 composeDomainResource(t, "ChargeItemDefinition", name, element, index); 3050 if (element.hasUrlElement()) 3051 composeUri(t, "ChargeItemDefinition", "url", element.getUrlElement(), -1); 3052 for (int i = 0; i < element.getIdentifier().size(); i++) 3053 composeIdentifier(t, "ChargeItemDefinition", "identifier", element.getIdentifier().get(i), i); 3054 if (element.hasVersionElement()) 3055 composeString(t, "ChargeItemDefinition", "version", element.getVersionElement(), -1); 3056 if (element.hasTitleElement()) 3057 composeString(t, "ChargeItemDefinition", "title", element.getTitleElement(), -1); 3058 for (int i = 0; i < element.getDerivedFromUri().size(); i++) 3059 composeUri(t, "ChargeItemDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i); 3060 for (int i = 0; i < element.getPartOf().size(); i++) 3061 composeCanonical(t, "ChargeItemDefinition", "partOf", element.getPartOf().get(i), i); 3062 for (int i = 0; i < element.getReplaces().size(); i++) 3063 composeCanonical(t, "ChargeItemDefinition", "replaces", element.getReplaces().get(i), i); 3064 if (element.hasStatusElement()) 3065 composeEnum(t, "ChargeItemDefinition", "status", element.getStatusElement(), -1); 3066 if (element.hasExperimentalElement()) 3067 composeBoolean(t, "ChargeItemDefinition", "experimental", element.getExperimentalElement(), -1); 3068 if (element.hasDateElement()) 3069 composeDateTime(t, "ChargeItemDefinition", "date", element.getDateElement(), -1); 3070 if (element.hasPublisherElement()) 3071 composeString(t, "ChargeItemDefinition", "publisher", element.getPublisherElement(), -1); 3072 for (int i = 0; i < element.getContact().size(); i++) 3073 composeContactDetail(t, "ChargeItemDefinition", "contact", element.getContact().get(i), i); 3074 if (element.hasDescriptionElement()) 3075 composeMarkdown(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1); 3076 for (int i = 0; i < element.getUseContext().size(); i++) 3077 composeUsageContext(t, "ChargeItemDefinition", "useContext", element.getUseContext().get(i), i); 3078 for (int i = 0; i < element.getJurisdiction().size(); i++) 3079 composeCodeableConcept(t, "ChargeItemDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 3080 if (element.hasCopyrightElement()) 3081 composeMarkdown(t, "ChargeItemDefinition", "copyright", element.getCopyrightElement(), -1); 3082 if (element.hasApprovalDateElement()) 3083 composeDate(t, "ChargeItemDefinition", "approvalDate", element.getApprovalDateElement(), -1); 3084 if (element.hasLastReviewDateElement()) 3085 composeDate(t, "ChargeItemDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 3086 if (element.hasEffectivePeriod()) 3087 composePeriod(t, "ChargeItemDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 3088 if (element.hasCode()) 3089 composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1); 3090 for (int i = 0; i < element.getInstance().size(); i++) 3091 composeReference(t, "ChargeItemDefinition", "instance", element.getInstance().get(i), i); 3092 for (int i = 0; i < element.getApplicability().size(); i++) 3093 composeChargeItemDefinitionChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i); 3094 for (int i = 0; i < element.getPropertyGroup().size(); i++) 3095 composeChargeItemDefinitionChargeItemDefinitionPropertyGroupComponent(t, "ChargeItemDefinition", "propertyGroup", element.getPropertyGroup().get(i), i); 3096 } 3097 3098 protected void composeChargeItemDefinitionChargeItemDefinitionApplicabilityComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent element, int index) { 3099 if (element == null) 3100 return; 3101 Complex t; 3102 if (Utilities.noString(parentType)) 3103 t = parent; 3104 else { 3105 t = parent.predicate("fhir:"+parentType+'.'+name); 3106 } 3107 composeBackboneElement(t, "applicability", name, element, index); 3108 if (element.hasDescriptionElement()) 3109 composeString(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1); 3110 if (element.hasLanguageElement()) 3111 composeString(t, "ChargeItemDefinition", "language", element.getLanguageElement(), -1); 3112 if (element.hasExpressionElement()) 3113 composeString(t, "ChargeItemDefinition", "expression", element.getExpressionElement(), -1); 3114 } 3115 3116 protected void composeChargeItemDefinitionChargeItemDefinitionPropertyGroupComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent element, int index) { 3117 if (element == null) 3118 return; 3119 Complex t; 3120 if (Utilities.noString(parentType)) 3121 t = parent; 3122 else { 3123 t = parent.predicate("fhir:"+parentType+'.'+name); 3124 } 3125 composeBackboneElement(t, "propertyGroup", name, element, index); 3126 for (int i = 0; i < element.getApplicability().size(); i++) 3127 composeChargeItemDefinitionChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i); 3128 for (int i = 0; i < element.getPriceComponent().size(); i++) 3129 composeChargeItemDefinitionChargeItemDefinitionPropertyGroupPriceComponentComponent(t, "ChargeItemDefinition", "priceComponent", element.getPriceComponent().get(i), i); 3130 } 3131 3132 protected void composeChargeItemDefinitionChargeItemDefinitionPropertyGroupPriceComponentComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupPriceComponentComponent element, int index) { 3133 if (element == null) 3134 return; 3135 Complex t; 3136 if (Utilities.noString(parentType)) 3137 t = parent; 3138 else { 3139 t = parent.predicate("fhir:"+parentType+'.'+name); 3140 } 3141 composeBackboneElement(t, "priceComponent", name, element, index); 3142 if (element.hasTypeElement()) 3143 composeEnum(t, "ChargeItemDefinition", "type", element.getTypeElement(), -1); 3144 if (element.hasCode()) 3145 composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1); 3146 if (element.hasFactorElement()) 3147 composeDecimal(t, "ChargeItemDefinition", "factor", element.getFactorElement(), -1); 3148 if (element.hasAmount()) 3149 composeMoney(t, "ChargeItemDefinition", "amount", element.getAmount(), -1); 3150 } 3151 3152 protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) { 3153 if (element == null) 3154 return; 3155 Complex t; 3156 if (Utilities.noString(parentType)) 3157 t = parent; 3158 else { 3159 t = parent.predicate("fhir:"+parentType+'.'+name); 3160 } 3161 composeDomainResource(t, "Claim", name, element, index); 3162 for (int i = 0; i < element.getIdentifier().size(); i++) 3163 composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i); 3164 if (element.hasStatusElement()) 3165 composeEnum(t, "Claim", "status", element.getStatusElement(), -1); 3166 if (element.hasType()) 3167 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 3168 if (element.hasSubType()) 3169 composeCodeableConcept(t, "Claim", "subType", element.getSubType(), -1); 3170 if (element.hasUseElement()) 3171 composeEnum(t, "Claim", "use", element.getUseElement(), -1); 3172 if (element.hasPatient()) 3173 composeReference(t, "Claim", "patient", element.getPatient(), -1); 3174 if (element.hasBillablePeriod()) 3175 composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1); 3176 if (element.hasCreatedElement()) 3177 composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1); 3178 if (element.hasEnterer()) 3179 composeReference(t, "Claim", "enterer", element.getEnterer(), -1); 3180 if (element.hasInsurer()) 3181 composeReference(t, "Claim", "insurer", element.getInsurer(), -1); 3182 if (element.hasProvider()) 3183 composeReference(t, "Claim", "provider", element.getProvider(), -1); 3184 if (element.hasPriority()) 3185 composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1); 3186 if (element.hasFundsReserve()) 3187 composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1); 3188 for (int i = 0; i < element.getRelated().size(); i++) 3189 composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i); 3190 if (element.hasPrescription()) 3191 composeReference(t, "Claim", "prescription", element.getPrescription(), -1); 3192 if (element.hasOriginalPrescription()) 3193 composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1); 3194 if (element.hasPayee()) 3195 composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1); 3196 if (element.hasReferral()) 3197 composeReference(t, "Claim", "referral", element.getReferral(), -1); 3198 if (element.hasFacility()) 3199 composeReference(t, "Claim", "facility", element.getFacility(), -1); 3200 for (int i = 0; i < element.getCareTeam().size(); i++) 3201 composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i); 3202 for (int i = 0; i < element.getSupportingInfo().size(); i++) 3203 composeClaimSupportingInformationComponent(t, "Claim", "supportingInfo", element.getSupportingInfo().get(i), i); 3204 for (int i = 0; i < element.getDiagnosis().size(); i++) 3205 composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i); 3206 for (int i = 0; i < element.getProcedure().size(); i++) 3207 composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i); 3208 for (int i = 0; i < element.getInsurance().size(); i++) 3209 composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i); 3210 if (element.hasAccident()) 3211 composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1); 3212 for (int i = 0; i < element.getItem().size(); i++) 3213 composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i); 3214 if (element.hasTotal()) 3215 composeMoney(t, "Claim", "total", element.getTotal(), -1); 3216 } 3217 3218 protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) { 3219 if (element == null) 3220 return; 3221 Complex t; 3222 if (Utilities.noString(parentType)) 3223 t = parent; 3224 else { 3225 t = parent.predicate("fhir:"+parentType+'.'+name); 3226 } 3227 composeBackboneElement(t, "related", name, element, index); 3228 if (element.hasClaim()) 3229 composeReference(t, "Claim", "claim", element.getClaim(), -1); 3230 if (element.hasRelationship()) 3231 composeCodeableConcept(t, "Claim", "relationship", element.getRelationship(), -1); 3232 if (element.hasReference()) 3233 composeIdentifier(t, "Claim", "reference", element.getReference(), -1); 3234 } 3235 3236 protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) { 3237 if (element == null) 3238 return; 3239 Complex t; 3240 if (Utilities.noString(parentType)) 3241 t = parent; 3242 else { 3243 t = parent.predicate("fhir:"+parentType+'.'+name); 3244 } 3245 composeBackboneElement(t, "payee", name, element, index); 3246 if (element.hasType()) 3247 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 3248 if (element.hasParty()) 3249 composeReference(t, "Claim", "party", element.getParty(), -1); 3250 } 3251 3252 protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) { 3253 if (element == null) 3254 return; 3255 Complex t; 3256 if (Utilities.noString(parentType)) 3257 t = parent; 3258 else { 3259 t = parent.predicate("fhir:"+parentType+'.'+name); 3260 } 3261 composeBackboneElement(t, "careTeam", name, element, index); 3262 if (element.hasSequenceElement()) 3263 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 3264 if (element.hasProvider()) 3265 composeReference(t, "Claim", "provider", element.getProvider(), -1); 3266 if (element.hasResponsibleElement()) 3267 composeBoolean(t, "Claim", "responsible", element.getResponsibleElement(), -1); 3268 if (element.hasRole()) 3269 composeCodeableConcept(t, "Claim", "role", element.getRole(), -1); 3270 if (element.hasQualification()) 3271 composeCodeableConcept(t, "Claim", "qualification", element.getQualification(), -1); 3272 } 3273 3274 protected void composeClaimSupportingInformationComponent(Complex parent, String parentType, String name, Claim.SupportingInformationComponent element, int index) { 3275 if (element == null) 3276 return; 3277 Complex t; 3278 if (Utilities.noString(parentType)) 3279 t = parent; 3280 else { 3281 t = parent.predicate("fhir:"+parentType+'.'+name); 3282 } 3283 composeBackboneElement(t, "supportingInfo", name, element, index); 3284 if (element.hasSequenceElement()) 3285 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 3286 if (element.hasCategory()) 3287 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 3288 if (element.hasCode()) 3289 composeCodeableConcept(t, "Claim", "code", element.getCode(), -1); 3290 if (element.hasTiming()) 3291 composeType(t, "Claim", "timing", element.getTiming(), -1); 3292 if (element.hasValue()) 3293 composeType(t, "Claim", "value", element.getValue(), -1); 3294 if (element.hasReason()) 3295 composeCodeableConcept(t, "Claim", "reason", element.getReason(), -1); 3296 } 3297 3298 protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) { 3299 if (element == null) 3300 return; 3301 Complex t; 3302 if (Utilities.noString(parentType)) 3303 t = parent; 3304 else { 3305 t = parent.predicate("fhir:"+parentType+'.'+name); 3306 } 3307 composeBackboneElement(t, "diagnosis", name, element, index); 3308 if (element.hasSequenceElement()) 3309 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 3310 if (element.hasDiagnosis()) 3311 composeType(t, "Claim", "diagnosis", element.getDiagnosis(), -1); 3312 for (int i = 0; i < element.getType().size(); i++) 3313 composeCodeableConcept(t, "Claim", "type", element.getType().get(i), i); 3314 if (element.hasOnAdmission()) 3315 composeCodeableConcept(t, "Claim", "onAdmission", element.getOnAdmission(), -1); 3316 if (element.hasPackageCode()) 3317 composeCodeableConcept(t, "Claim", "packageCode", element.getPackageCode(), -1); 3318 } 3319 3320 protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) { 3321 if (element == null) 3322 return; 3323 Complex t; 3324 if (Utilities.noString(parentType)) 3325 t = parent; 3326 else { 3327 t = parent.predicate("fhir:"+parentType+'.'+name); 3328 } 3329 composeBackboneElement(t, "procedure", name, element, index); 3330 if (element.hasSequenceElement()) 3331 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 3332 for (int i = 0; i < element.getType().size(); i++) 3333 composeCodeableConcept(t, "Claim", "type", element.getType().get(i), i); 3334 if (element.hasDateElement()) 3335 composeDateTime(t, "Claim", "date", element.getDateElement(), -1); 3336 if (element.hasProcedure()) 3337 composeType(t, "Claim", "procedure", element.getProcedure(), -1); 3338 for (int i = 0; i < element.getUdi().size(); i++) 3339 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 3340 } 3341 3342 protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) { 3343 if (element == null) 3344 return; 3345 Complex t; 3346 if (Utilities.noString(parentType)) 3347 t = parent; 3348 else { 3349 t = parent.predicate("fhir:"+parentType+'.'+name); 3350 } 3351 composeBackboneElement(t, "insurance", name, element, index); 3352 if (element.hasSequenceElement()) 3353 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 3354 if (element.hasFocalElement()) 3355 composeBoolean(t, "Claim", "focal", element.getFocalElement(), -1); 3356 if (element.hasIdentifier()) 3357 composeIdentifier(t, "Claim", "identifier", element.getIdentifier(), -1); 3358 if (element.hasCoverage()) 3359 composeReference(t, "Claim", "coverage", element.getCoverage(), -1); 3360 if (element.hasBusinessArrangementElement()) 3361 composeString(t, "Claim", "businessArrangement", element.getBusinessArrangementElement(), -1); 3362 for (int i = 0; i < element.getPreAuthRef().size(); i++) 3363 composeString(t, "Claim", "preAuthRef", element.getPreAuthRef().get(i), i); 3364 if (element.hasClaimResponse()) 3365 composeReference(t, "Claim", "claimResponse", element.getClaimResponse(), -1); 3366 } 3367 3368 protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) { 3369 if (element == null) 3370 return; 3371 Complex t; 3372 if (Utilities.noString(parentType)) 3373 t = parent; 3374 else { 3375 t = parent.predicate("fhir:"+parentType+'.'+name); 3376 } 3377 composeBackboneElement(t, "accident", name, element, index); 3378 if (element.hasDateElement()) 3379 composeDate(t, "Claim", "date", element.getDateElement(), -1); 3380 if (element.hasType()) 3381 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 3382 if (element.hasLocation()) 3383 composeType(t, "Claim", "location", element.getLocation(), -1); 3384 } 3385 3386 protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) { 3387 if (element == null) 3388 return; 3389 Complex t; 3390 if (Utilities.noString(parentType)) 3391 t = parent; 3392 else { 3393 t = parent.predicate("fhir:"+parentType+'.'+name); 3394 } 3395 composeBackboneElement(t, "item", name, element, index); 3396 if (element.hasSequenceElement()) 3397 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 3398 for (int i = 0; i < element.getCareTeamSequence().size(); i++) 3399 composePositiveInt(t, "Claim", "careTeamSequence", element.getCareTeamSequence().get(i), i); 3400 for (int i = 0; i < element.getDiagnosisSequence().size(); i++) 3401 composePositiveInt(t, "Claim", "diagnosisSequence", element.getDiagnosisSequence().get(i), i); 3402 for (int i = 0; i < element.getProcedureSequence().size(); i++) 3403 composePositiveInt(t, "Claim", "procedureSequence", element.getProcedureSequence().get(i), i); 3404 for (int i = 0; i < element.getInformationSequence().size(); i++) 3405 composePositiveInt(t, "Claim", "informationSequence", element.getInformationSequence().get(i), i); 3406 if (element.hasRevenue()) 3407 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 3408 if (element.hasCategory()) 3409 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 3410 if (element.hasProductOrService()) 3411 composeCodeableConcept(t, "Claim", "productOrService", element.getProductOrService(), -1); 3412 for (int i = 0; i < element.getModifier().size(); i++) 3413 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 3414 for (int i = 0; i < element.getProgramCode().size(); i++) 3415 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 3416 if (element.hasServiced()) 3417 composeType(t, "Claim", "serviced", element.getServiced(), -1); 3418 if (element.hasLocation()) 3419 composeType(t, "Claim", "location", element.getLocation(), -1); 3420 if (element.hasQuantity()) 3421 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 3422 if (element.hasUnitPrice()) 3423 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 3424 if (element.hasFactorElement()) 3425 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 3426 if (element.hasNet()) 3427 composeMoney(t, "Claim", "net", element.getNet(), -1); 3428 for (int i = 0; i < element.getUdi().size(); i++) 3429 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 3430 if (element.hasBodySite()) 3431 composeCodeableConcept(t, "Claim", "bodySite", element.getBodySite(), -1); 3432 for (int i = 0; i < element.getSubSite().size(); i++) 3433 composeCodeableConcept(t, "Claim", "subSite", element.getSubSite().get(i), i); 3434 for (int i = 0; i < element.getEncounter().size(); i++) 3435 composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i); 3436 for (int i = 0; i < element.getDetail().size(); i++) 3437 composeClaimDetailComponent(t, "Claim", "detail", element.getDetail().get(i), i); 3438 } 3439 3440 protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) { 3441 if (element == null) 3442 return; 3443 Complex t; 3444 if (Utilities.noString(parentType)) 3445 t = parent; 3446 else { 3447 t = parent.predicate("fhir:"+parentType+'.'+name); 3448 } 3449 composeBackboneElement(t, "detail", name, element, index); 3450 if (element.hasSequenceElement()) 3451 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 3452 if (element.hasRevenue()) 3453 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 3454 if (element.hasCategory()) 3455 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 3456 if (element.hasProductOrService()) 3457 composeCodeableConcept(t, "Claim", "productOrService", element.getProductOrService(), -1); 3458 for (int i = 0; i < element.getModifier().size(); i++) 3459 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 3460 for (int i = 0; i < element.getProgramCode().size(); i++) 3461 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 3462 if (element.hasQuantity()) 3463 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 3464 if (element.hasUnitPrice()) 3465 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 3466 if (element.hasFactorElement()) 3467 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 3468 if (element.hasNet()) 3469 composeMoney(t, "Claim", "net", element.getNet(), -1); 3470 for (int i = 0; i < element.getUdi().size(); i++) 3471 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 3472 for (int i = 0; i < element.getSubDetail().size(); i++) 3473 composeClaimSubDetailComponent(t, "Claim", "subDetail", element.getSubDetail().get(i), i); 3474 } 3475 3476 protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) { 3477 if (element == null) 3478 return; 3479 Complex t; 3480 if (Utilities.noString(parentType)) 3481 t = parent; 3482 else { 3483 t = parent.predicate("fhir:"+parentType+'.'+name); 3484 } 3485 composeBackboneElement(t, "subDetail", name, element, index); 3486 if (element.hasSequenceElement()) 3487 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 3488 if (element.hasRevenue()) 3489 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 3490 if (element.hasCategory()) 3491 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 3492 if (element.hasProductOrService()) 3493 composeCodeableConcept(t, "Claim", "productOrService", element.getProductOrService(), -1); 3494 for (int i = 0; i < element.getModifier().size(); i++) 3495 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 3496 for (int i = 0; i < element.getProgramCode().size(); i++) 3497 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 3498 if (element.hasQuantity()) 3499 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 3500 if (element.hasUnitPrice()) 3501 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 3502 if (element.hasFactorElement()) 3503 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 3504 if (element.hasNet()) 3505 composeMoney(t, "Claim", "net", element.getNet(), -1); 3506 for (int i = 0; i < element.getUdi().size(); i++) 3507 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 3508 } 3509 3510 protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) { 3511 if (element == null) 3512 return; 3513 Complex t; 3514 if (Utilities.noString(parentType)) 3515 t = parent; 3516 else { 3517 t = parent.predicate("fhir:"+parentType+'.'+name); 3518 } 3519 composeDomainResource(t, "ClaimResponse", name, element, index); 3520 for (int i = 0; i < element.getIdentifier().size(); i++) 3521 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i); 3522 if (element.hasStatusElement()) 3523 composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1); 3524 if (element.hasType()) 3525 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 3526 if (element.hasSubType()) 3527 composeCodeableConcept(t, "ClaimResponse", "subType", element.getSubType(), -1); 3528 if (element.hasUseElement()) 3529 composeEnum(t, "ClaimResponse", "use", element.getUseElement(), -1); 3530 if (element.hasPatient()) 3531 composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1); 3532 if (element.hasCreatedElement()) 3533 composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1); 3534 if (element.hasInsurer()) 3535 composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1); 3536 if (element.hasRequestor()) 3537 composeReference(t, "ClaimResponse", "requestor", element.getRequestor(), -1); 3538 if (element.hasRequest()) 3539 composeReference(t, "ClaimResponse", "request", element.getRequest(), -1); 3540 if (element.hasOutcomeElement()) 3541 composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1); 3542 if (element.hasDispositionElement()) 3543 composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1); 3544 if (element.hasPreAuthRefElement()) 3545 composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRefElement(), -1); 3546 if (element.hasPreAuthPeriod()) 3547 composePeriod(t, "ClaimResponse", "preAuthPeriod", element.getPreAuthPeriod(), -1); 3548 if (element.hasPayeeType()) 3549 composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1); 3550 for (int i = 0; i < element.getItem().size(); i++) 3551 composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i); 3552 for (int i = 0; i < element.getAddItem().size(); i++) 3553 composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i); 3554 for (int i = 0; i < element.getAdjudication().size(); i++) 3555 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3556 for (int i = 0; i < element.getTotal().size(); i++) 3557 composeClaimResponseTotalComponent(t, "ClaimResponse", "total", element.getTotal().get(i), i); 3558 if (element.hasPayment()) 3559 composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1); 3560 if (element.hasFundsReserve()) 3561 composeCodeableConcept(t, "ClaimResponse", "fundsReserve", element.getFundsReserve(), -1); 3562 if (element.hasFormCode()) 3563 composeCodeableConcept(t, "ClaimResponse", "formCode", element.getFormCode(), -1); 3564 if (element.hasForm()) 3565 composeAttachment(t, "ClaimResponse", "form", element.getForm(), -1); 3566 for (int i = 0; i < element.getProcessNote().size(); i++) 3567 composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i); 3568 for (int i = 0; i < element.getCommunicationRequest().size(); i++) 3569 composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i); 3570 for (int i = 0; i < element.getInsurance().size(); i++) 3571 composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i); 3572 for (int i = 0; i < element.getError().size(); i++) 3573 composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i); 3574 } 3575 3576 protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) { 3577 if (element == null) 3578 return; 3579 Complex t; 3580 if (Utilities.noString(parentType)) 3581 t = parent; 3582 else { 3583 t = parent.predicate("fhir:"+parentType+'.'+name); 3584 } 3585 composeBackboneElement(t, "item", name, element, index); 3586 if (element.hasItemSequenceElement()) 3587 composePositiveInt(t, "ClaimResponse", "itemSequence", element.getItemSequenceElement(), -1); 3588 for (int i = 0; i < element.getNoteNumber().size(); i++) 3589 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3590 for (int i = 0; i < element.getAdjudication().size(); i++) 3591 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3592 for (int i = 0; i < element.getDetail().size(); i++) 3593 composeClaimResponseItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 3594 } 3595 3596 protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) { 3597 if (element == null) 3598 return; 3599 Complex t; 3600 if (Utilities.noString(parentType)) 3601 t = parent; 3602 else { 3603 t = parent.predicate("fhir:"+parentType+'.'+name); 3604 } 3605 composeBackboneElement(t, "adjudication", name, element, index); 3606 if (element.hasCategory()) 3607 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3608 if (element.hasReason()) 3609 composeCodeableConcept(t, "ClaimResponse", "reason", element.getReason(), -1); 3610 if (element.hasAmount()) 3611 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3612 if (element.hasValueElement()) 3613 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 3614 } 3615 3616 protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) { 3617 if (element == null) 3618 return; 3619 Complex t; 3620 if (Utilities.noString(parentType)) 3621 t = parent; 3622 else { 3623 t = parent.predicate("fhir:"+parentType+'.'+name); 3624 } 3625 composeBackboneElement(t, "detail", name, element, index); 3626 if (element.hasDetailSequenceElement()) 3627 composePositiveInt(t, "ClaimResponse", "detailSequence", element.getDetailSequenceElement(), -1); 3628 for (int i = 0; i < element.getNoteNumber().size(); i++) 3629 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3630 for (int i = 0; i < element.getAdjudication().size(); i++) 3631 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3632 for (int i = 0; i < element.getSubDetail().size(); i++) 3633 composeClaimResponseSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i); 3634 } 3635 3636 protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) { 3637 if (element == null) 3638 return; 3639 Complex t; 3640 if (Utilities.noString(parentType)) 3641 t = parent; 3642 else { 3643 t = parent.predicate("fhir:"+parentType+'.'+name); 3644 } 3645 composeBackboneElement(t, "subDetail", name, element, index); 3646 if (element.hasSubDetailSequenceElement()) 3647 composePositiveInt(t, "ClaimResponse", "subDetailSequence", element.getSubDetailSequenceElement(), -1); 3648 for (int i = 0; i < element.getNoteNumber().size(); i++) 3649 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3650 for (int i = 0; i < element.getAdjudication().size(); i++) 3651 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3652 } 3653 3654 protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) { 3655 if (element == null) 3656 return; 3657 Complex t; 3658 if (Utilities.noString(parentType)) 3659 t = parent; 3660 else { 3661 t = parent.predicate("fhir:"+parentType+'.'+name); 3662 } 3663 composeBackboneElement(t, "addItem", name, element, index); 3664 for (int i = 0; i < element.getItemSequence().size(); i++) 3665 composePositiveInt(t, "ClaimResponse", "itemSequence", element.getItemSequence().get(i), i); 3666 for (int i = 0; i < element.getDetailSequence().size(); i++) 3667 composePositiveInt(t, "ClaimResponse", "detailSequence", element.getDetailSequence().get(i), i); 3668 for (int i = 0; i < element.getSubdetailSequence().size(); i++) 3669 composePositiveInt(t, "ClaimResponse", "subdetailSequence", element.getSubdetailSequence().get(i), i); 3670 for (int i = 0; i < element.getProvider().size(); i++) 3671 composeReference(t, "ClaimResponse", "provider", element.getProvider().get(i), i); 3672 if (element.hasProductOrService()) 3673 composeCodeableConcept(t, "ClaimResponse", "productOrService", element.getProductOrService(), -1); 3674 for (int i = 0; i < element.getModifier().size(); i++) 3675 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3676 for (int i = 0; i < element.getProgramCode().size(); i++) 3677 composeCodeableConcept(t, "ClaimResponse", "programCode", element.getProgramCode().get(i), i); 3678 if (element.hasServiced()) 3679 composeType(t, "ClaimResponse", "serviced", element.getServiced(), -1); 3680 if (element.hasLocation()) 3681 composeType(t, "ClaimResponse", "location", element.getLocation(), -1); 3682 if (element.hasQuantity()) 3683 composeQuantity(t, "ClaimResponse", "quantity", element.getQuantity(), -1); 3684 if (element.hasUnitPrice()) 3685 composeMoney(t, "ClaimResponse", "unitPrice", element.getUnitPrice(), -1); 3686 if (element.hasFactorElement()) 3687 composeDecimal(t, "ClaimResponse", "factor", element.getFactorElement(), -1); 3688 if (element.hasNet()) 3689 composeMoney(t, "ClaimResponse", "net", element.getNet(), -1); 3690 if (element.hasBodySite()) 3691 composeCodeableConcept(t, "ClaimResponse", "bodySite", element.getBodySite(), -1); 3692 for (int i = 0; i < element.getSubSite().size(); i++) 3693 composeCodeableConcept(t, "ClaimResponse", "subSite", element.getSubSite().get(i), i); 3694 for (int i = 0; i < element.getNoteNumber().size(); i++) 3695 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3696 for (int i = 0; i < element.getAdjudication().size(); i++) 3697 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3698 for (int i = 0; i < element.getDetail().size(); i++) 3699 composeClaimResponseAddedItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 3700 } 3701 3702 protected void composeClaimResponseAddedItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailComponent element, int index) { 3703 if (element == null) 3704 return; 3705 Complex t; 3706 if (Utilities.noString(parentType)) 3707 t = parent; 3708 else { 3709 t = parent.predicate("fhir:"+parentType+'.'+name); 3710 } 3711 composeBackboneElement(t, "detail", name, element, index); 3712 if (element.hasProductOrService()) 3713 composeCodeableConcept(t, "ClaimResponse", "productOrService", element.getProductOrService(), -1); 3714 for (int i = 0; i < element.getModifier().size(); i++) 3715 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3716 if (element.hasQuantity()) 3717 composeQuantity(t, "ClaimResponse", "quantity", element.getQuantity(), -1); 3718 if (element.hasUnitPrice()) 3719 composeMoney(t, "ClaimResponse", "unitPrice", element.getUnitPrice(), -1); 3720 if (element.hasFactorElement()) 3721 composeDecimal(t, "ClaimResponse", "factor", element.getFactorElement(), -1); 3722 if (element.hasNet()) 3723 composeMoney(t, "ClaimResponse", "net", element.getNet(), -1); 3724 for (int i = 0; i < element.getNoteNumber().size(); i++) 3725 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3726 for (int i = 0; i < element.getAdjudication().size(); i++) 3727 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3728 for (int i = 0; i < element.getSubDetail().size(); i++) 3729 composeClaimResponseAddedItemSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i); 3730 } 3731 3732 protected void composeClaimResponseAddedItemSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemSubDetailComponent element, int index) { 3733 if (element == null) 3734 return; 3735 Complex t; 3736 if (Utilities.noString(parentType)) 3737 t = parent; 3738 else { 3739 t = parent.predicate("fhir:"+parentType+'.'+name); 3740 } 3741 composeBackboneElement(t, "subDetail", name, element, index); 3742 if (element.hasProductOrService()) 3743 composeCodeableConcept(t, "ClaimResponse", "productOrService", element.getProductOrService(), -1); 3744 for (int i = 0; i < element.getModifier().size(); i++) 3745 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3746 if (element.hasQuantity()) 3747 composeQuantity(t, "ClaimResponse", "quantity", element.getQuantity(), -1); 3748 if (element.hasUnitPrice()) 3749 composeMoney(t, "ClaimResponse", "unitPrice", element.getUnitPrice(), -1); 3750 if (element.hasFactorElement()) 3751 composeDecimal(t, "ClaimResponse", "factor", element.getFactorElement(), -1); 3752 if (element.hasNet()) 3753 composeMoney(t, "ClaimResponse", "net", element.getNet(), -1); 3754 for (int i = 0; i < element.getNoteNumber().size(); i++) 3755 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3756 for (int i = 0; i < element.getAdjudication().size(); i++) 3757 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3758 } 3759 3760 protected void composeClaimResponseTotalComponent(Complex parent, String parentType, String name, ClaimResponse.TotalComponent element, int index) { 3761 if (element == null) 3762 return; 3763 Complex t; 3764 if (Utilities.noString(parentType)) 3765 t = parent; 3766 else { 3767 t = parent.predicate("fhir:"+parentType+'.'+name); 3768 } 3769 composeBackboneElement(t, "total", name, element, index); 3770 if (element.hasCategory()) 3771 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3772 if (element.hasAmount()) 3773 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3774 } 3775 3776 protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) { 3777 if (element == null) 3778 return; 3779 Complex t; 3780 if (Utilities.noString(parentType)) 3781 t = parent; 3782 else { 3783 t = parent.predicate("fhir:"+parentType+'.'+name); 3784 } 3785 composeBackboneElement(t, "payment", name, element, index); 3786 if (element.hasType()) 3787 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 3788 if (element.hasAdjustment()) 3789 composeMoney(t, "ClaimResponse", "adjustment", element.getAdjustment(), -1); 3790 if (element.hasAdjustmentReason()) 3791 composeCodeableConcept(t, "ClaimResponse", "adjustmentReason", element.getAdjustmentReason(), -1); 3792 if (element.hasDateElement()) 3793 composeDate(t, "ClaimResponse", "date", element.getDateElement(), -1); 3794 if (element.hasAmount()) 3795 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3796 if (element.hasIdentifier()) 3797 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier(), -1); 3798 } 3799 3800 protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) { 3801 if (element == null) 3802 return; 3803 Complex t; 3804 if (Utilities.noString(parentType)) 3805 t = parent; 3806 else { 3807 t = parent.predicate("fhir:"+parentType+'.'+name); 3808 } 3809 composeBackboneElement(t, "processNote", name, element, index); 3810 if (element.hasNumberElement()) 3811 composePositiveInt(t, "ClaimResponse", "number", element.getNumberElement(), -1); 3812 if (element.hasTypeElement()) 3813 composeEnum(t, "ClaimResponse", "type", element.getTypeElement(), -1); 3814 if (element.hasTextElement()) 3815 composeString(t, "ClaimResponse", "text", element.getTextElement(), -1); 3816 if (element.hasLanguage()) 3817 composeCodeableConcept(t, "ClaimResponse", "language", element.getLanguage(), -1); 3818 } 3819 3820 protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) { 3821 if (element == null) 3822 return; 3823 Complex t; 3824 if (Utilities.noString(parentType)) 3825 t = parent; 3826 else { 3827 t = parent.predicate("fhir:"+parentType+'.'+name); 3828 } 3829 composeBackboneElement(t, "insurance", name, element, index); 3830 if (element.hasSequenceElement()) 3831 composePositiveInt(t, "ClaimResponse", "sequence", element.getSequenceElement(), -1); 3832 if (element.hasFocalElement()) 3833 composeBoolean(t, "ClaimResponse", "focal", element.getFocalElement(), -1); 3834 if (element.hasCoverage()) 3835 composeReference(t, "ClaimResponse", "coverage", element.getCoverage(), -1); 3836 if (element.hasBusinessArrangementElement()) 3837 composeString(t, "ClaimResponse", "businessArrangement", element.getBusinessArrangementElement(), -1); 3838 if (element.hasClaimResponse()) 3839 composeReference(t, "ClaimResponse", "claimResponse", element.getClaimResponse(), -1); 3840 } 3841 3842 protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) { 3843 if (element == null) 3844 return; 3845 Complex t; 3846 if (Utilities.noString(parentType)) 3847 t = parent; 3848 else { 3849 t = parent.predicate("fhir:"+parentType+'.'+name); 3850 } 3851 composeBackboneElement(t, "error", name, element, index); 3852 if (element.hasItemSequenceElement()) 3853 composePositiveInt(t, "ClaimResponse", "itemSequence", element.getItemSequenceElement(), -1); 3854 if (element.hasDetailSequenceElement()) 3855 composePositiveInt(t, "ClaimResponse", "detailSequence", element.getDetailSequenceElement(), -1); 3856 if (element.hasSubDetailSequenceElement()) 3857 composePositiveInt(t, "ClaimResponse", "subDetailSequence", element.getSubDetailSequenceElement(), -1); 3858 if (element.hasCode()) 3859 composeCodeableConcept(t, "ClaimResponse", "code", element.getCode(), -1); 3860 } 3861 3862 protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) { 3863 if (element == null) 3864 return; 3865 Complex t; 3866 if (Utilities.noString(parentType)) 3867 t = parent; 3868 else { 3869 t = parent.predicate("fhir:"+parentType+'.'+name); 3870 } 3871 composeDomainResource(t, "ClinicalImpression", name, element, index); 3872 for (int i = 0; i < element.getIdentifier().size(); i++) 3873 composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i); 3874 if (element.hasStatusElement()) 3875 composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1); 3876 if (element.hasStatusReason()) 3877 composeCodeableConcept(t, "ClinicalImpression", "statusReason", element.getStatusReason(), -1); 3878 if (element.hasCode()) 3879 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 3880 if (element.hasDescriptionElement()) 3881 composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1); 3882 if (element.hasSubject()) 3883 composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1); 3884 if (element.hasEncounter()) 3885 composeReference(t, "ClinicalImpression", "encounter", element.getEncounter(), -1); 3886 if (element.hasEffective()) 3887 composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1); 3888 if (element.hasDateElement()) 3889 composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1); 3890 if (element.hasAssessor()) 3891 composeReference(t, "ClinicalImpression", "assessor", element.getAssessor(), -1); 3892 if (element.hasPrevious()) 3893 composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1); 3894 for (int i = 0; i < element.getProblem().size(); i++) 3895 composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i); 3896 for (int i = 0; i < element.getInvestigation().size(); i++) 3897 composeClinicalImpressionClinicalImpressionInvestigationComponent(t, "ClinicalImpression", "investigation", element.getInvestigation().get(i), i); 3898 for (int i = 0; i < element.getProtocol().size(); i++) 3899 composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i); 3900 if (element.hasSummaryElement()) 3901 composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1); 3902 for (int i = 0; i < element.getFinding().size(); i++) 3903 composeClinicalImpressionClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i); 3904 for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) 3905 composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i); 3906 for (int i = 0; i < element.getPrognosisReference().size(); i++) 3907 composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i); 3908 for (int i = 0; i < element.getSupportingInfo().size(); i++) 3909 composeReference(t, "ClinicalImpression", "supportingInfo", element.getSupportingInfo().get(i), i); 3910 for (int i = 0; i < element.getNote().size(); i++) 3911 composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i); 3912 } 3913 3914 protected void composeClinicalImpressionClinicalImpressionInvestigationComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionInvestigationComponent element, int index) { 3915 if (element == null) 3916 return; 3917 Complex t; 3918 if (Utilities.noString(parentType)) 3919 t = parent; 3920 else { 3921 t = parent.predicate("fhir:"+parentType+'.'+name); 3922 } 3923 composeBackboneElement(t, "investigation", name, element, index); 3924 if (element.hasCode()) 3925 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 3926 for (int i = 0; i < element.getItem().size(); i++) 3927 composeReference(t, "ClinicalImpression", "item", element.getItem().get(i), i); 3928 } 3929 3930 protected void composeClinicalImpressionClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) { 3931 if (element == null) 3932 return; 3933 Complex t; 3934 if (Utilities.noString(parentType)) 3935 t = parent; 3936 else { 3937 t = parent.predicate("fhir:"+parentType+'.'+name); 3938 } 3939 composeBackboneElement(t, "finding", name, element, index); 3940 if (element.hasItemCodeableConcept()) 3941 composeCodeableConcept(t, "ClinicalImpression", "itemCodeableConcept", element.getItemCodeableConcept(), -1); 3942 if (element.hasItemReference()) 3943 composeReference(t, "ClinicalImpression", "itemReference", element.getItemReference(), -1); 3944 if (element.hasBasisElement()) 3945 composeString(t, "ClinicalImpression", "basis", element.getBasisElement(), -1); 3946 } 3947 3948 protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) { 3949 if (element == null) 3950 return; 3951 Complex t; 3952 if (Utilities.noString(parentType)) 3953 t = parent; 3954 else { 3955 t = parent.predicate("fhir:"+parentType+'.'+name); 3956 } 3957 composeDomainResource(t, "CodeSystem", name, element, index); 3958 if (element.hasUrlElement()) 3959 composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1); 3960 for (int i = 0; i < element.getIdentifier().size(); i++) 3961 composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier().get(i), i); 3962 if (element.hasVersionElement()) 3963 composeString(t, "CodeSystem", "version", element.getVersionElement(), -1); 3964 if (element.hasNameElement()) 3965 composeString(t, "CodeSystem", "name", element.getNameElement(), -1); 3966 if (element.hasTitleElement()) 3967 composeString(t, "CodeSystem", "title", element.getTitleElement(), -1); 3968 if (element.hasStatusElement()) 3969 composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1); 3970 if (element.hasExperimentalElement()) 3971 composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1); 3972 if (element.hasDateElement()) 3973 composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1); 3974 if (element.hasPublisherElement()) 3975 composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1); 3976 for (int i = 0; i < element.getContact().size(); i++) 3977 composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i); 3978 if (element.hasDescriptionElement()) 3979 composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3980 for (int i = 0; i < element.getUseContext().size(); i++) 3981 composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i); 3982 for (int i = 0; i < element.getJurisdiction().size(); i++) 3983 composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i); 3984 if (element.hasPurposeElement()) 3985 composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1); 3986 if (element.hasCopyrightElement()) 3987 composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1); 3988 if (element.hasCaseSensitiveElement()) 3989 composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1); 3990 if (element.hasValueSetElement()) 3991 composeCanonical(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1); 3992 if (element.hasHierarchyMeaningElement()) 3993 composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1); 3994 if (element.hasCompositionalElement()) 3995 composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1); 3996 if (element.hasVersionNeededElement()) 3997 composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1); 3998 if (element.hasContentElement()) 3999 composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1); 4000 if (element.hasSupplementsElement()) 4001 composeCanonical(t, "CodeSystem", "supplements", element.getSupplementsElement(), -1); 4002 if (element.hasCountElement()) 4003 composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1); 4004 for (int i = 0; i < element.getFilter().size(); i++) 4005 composeCodeSystemCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i); 4006 for (int i = 0; i < element.getProperty().size(); i++) 4007 composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 4008 for (int i = 0; i < element.getConcept().size(); i++) 4009 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 4010 } 4011 4012 protected void composeCodeSystemCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) { 4013 if (element == null) 4014 return; 4015 Complex t; 4016 if (Utilities.noString(parentType)) 4017 t = parent; 4018 else { 4019 t = parent.predicate("fhir:"+parentType+'.'+name); 4020 } 4021 composeBackboneElement(t, "filter", name, element, index); 4022 if (element.hasCodeElement()) 4023 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 4024 if (element.hasDescriptionElement()) 4025 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 4026 for (int i = 0; i < element.getOperator().size(); i++) 4027 composeEnum(t, "CodeSystem", "operator", element.getOperator().get(i), i); 4028 if (element.hasValueElement()) 4029 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 4030 } 4031 4032 protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) { 4033 if (element == null) 4034 return; 4035 Complex t; 4036 if (Utilities.noString(parentType)) 4037 t = parent; 4038 else { 4039 t = parent.predicate("fhir:"+parentType+'.'+name); 4040 } 4041 composeBackboneElement(t, "property", name, element, index); 4042 if (element.hasCodeElement()) 4043 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 4044 if (element.hasUriElement()) 4045 composeUri(t, "CodeSystem", "uri", element.getUriElement(), -1); 4046 if (element.hasDescriptionElement()) 4047 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 4048 if (element.hasTypeElement()) 4049 composeEnum(t, "CodeSystem", "type", element.getTypeElement(), -1); 4050 } 4051 4052 protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) { 4053 if (element == null) 4054 return; 4055 Complex t; 4056 if (Utilities.noString(parentType)) 4057 t = parent; 4058 else { 4059 t = parent.predicate("fhir:"+parentType+'.'+name); 4060 } 4061 composeBackboneElement(t, "concept", name, element, index); 4062 if (element.hasCodeElement()) 4063 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 4064 if (element.hasDisplayElement()) 4065 composeString(t, "CodeSystem", "display", element.getDisplayElement(), -1); 4066 if (element.hasDefinitionElement()) 4067 composeString(t, "CodeSystem", "definition", element.getDefinitionElement(), -1); 4068 for (int i = 0; i < element.getDesignation().size(); i++) 4069 composeCodeSystemConceptDefinitionDesignationComponent(t, "CodeSystem", "designation", element.getDesignation().get(i), i); 4070 for (int i = 0; i < element.getProperty().size(); i++) 4071 composeCodeSystemConceptPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 4072 for (int i = 0; i < element.getConcept().size(); i++) 4073 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 4074 } 4075 4076 protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) { 4077 if (element == null) 4078 return; 4079 Complex t; 4080 if (Utilities.noString(parentType)) 4081 t = parent; 4082 else { 4083 t = parent.predicate("fhir:"+parentType+'.'+name); 4084 } 4085 composeBackboneElement(t, "designation", name, element, index); 4086 if (element.hasLanguageElement()) 4087 composeCode(t, "CodeSystem", "language", element.getLanguageElement(), -1); 4088 if (element.hasUse()) 4089 composeCoding(t, "CodeSystem", "use", element.getUse(), -1); 4090 if (element.hasValueElement()) 4091 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 4092 } 4093 4094 protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) { 4095 if (element == null) 4096 return; 4097 Complex t; 4098 if (Utilities.noString(parentType)) 4099 t = parent; 4100 else { 4101 t = parent.predicate("fhir:"+parentType+'.'+name); 4102 } 4103 composeBackboneElement(t, "property", name, element, index); 4104 if (element.hasCodeElement()) 4105 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 4106 if (element.hasValue()) 4107 composeType(t, "CodeSystem", "value", element.getValue(), -1); 4108 } 4109 4110 protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) { 4111 if (element == null) 4112 return; 4113 Complex t; 4114 if (Utilities.noString(parentType)) 4115 t = parent; 4116 else { 4117 t = parent.predicate("fhir:"+parentType+'.'+name); 4118 } 4119 composeDomainResource(t, "Communication", name, element, index); 4120 for (int i = 0; i < element.getIdentifier().size(); i++) 4121 composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i); 4122 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 4123 composeCanonical(t, "Communication", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 4124 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 4125 composeUri(t, "Communication", "instantiatesUri", element.getInstantiatesUri().get(i), i); 4126 for (int i = 0; i < element.getBasedOn().size(); i++) 4127 composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i); 4128 for (int i = 0; i < element.getPartOf().size(); i++) 4129 composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i); 4130 for (int i = 0; i < element.getInResponseTo().size(); i++) 4131 composeReference(t, "Communication", "inResponseTo", element.getInResponseTo().get(i), i); 4132 if (element.hasStatusElement()) 4133 composeEnum(t, "Communication", "status", element.getStatusElement(), -1); 4134 if (element.hasStatusReason()) 4135 composeCodeableConcept(t, "Communication", "statusReason", element.getStatusReason(), -1); 4136 for (int i = 0; i < element.getCategory().size(); i++) 4137 composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i); 4138 if (element.hasPriorityElement()) 4139 composeEnum(t, "Communication", "priority", element.getPriorityElement(), -1); 4140 for (int i = 0; i < element.getMedium().size(); i++) 4141 composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i); 4142 if (element.hasSubject()) 4143 composeReference(t, "Communication", "subject", element.getSubject(), -1); 4144 if (element.hasTopic()) 4145 composeCodeableConcept(t, "Communication", "topic", element.getTopic(), -1); 4146 for (int i = 0; i < element.getAbout().size(); i++) 4147 composeReference(t, "Communication", "about", element.getAbout().get(i), i); 4148 if (element.hasEncounter()) 4149 composeReference(t, "Communication", "encounter", element.getEncounter(), -1); 4150 if (element.hasSentElement()) 4151 composeDateTime(t, "Communication", "sent", element.getSentElement(), -1); 4152 if (element.hasReceivedElement()) 4153 composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1); 4154 for (int i = 0; i < element.getRecipient().size(); i++) 4155 composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i); 4156 if (element.hasSender()) 4157 composeReference(t, "Communication", "sender", element.getSender(), -1); 4158 for (int i = 0; i < element.getReasonCode().size(); i++) 4159 composeCodeableConcept(t, "Communication", "reasonCode", element.getReasonCode().get(i), i); 4160 for (int i = 0; i < element.getReasonReference().size(); i++) 4161 composeReference(t, "Communication", "reasonReference", element.getReasonReference().get(i), i); 4162 for (int i = 0; i < element.getPayload().size(); i++) 4163 composeCommunicationCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i); 4164 for (int i = 0; i < element.getNote().size(); i++) 4165 composeAnnotation(t, "Communication", "note", element.getNote().get(i), i); 4166 } 4167 4168 protected void composeCommunicationCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) { 4169 if (element == null) 4170 return; 4171 Complex t; 4172 if (Utilities.noString(parentType)) 4173 t = parent; 4174 else { 4175 t = parent.predicate("fhir:"+parentType+'.'+name); 4176 } 4177 composeBackboneElement(t, "payload", name, element, index); 4178 if (element.hasContent()) 4179 composeType(t, "Communication", "content", element.getContent(), -1); 4180 } 4181 4182 protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) { 4183 if (element == null) 4184 return; 4185 Complex t; 4186 if (Utilities.noString(parentType)) 4187 t = parent; 4188 else { 4189 t = parent.predicate("fhir:"+parentType+'.'+name); 4190 } 4191 composeDomainResource(t, "CommunicationRequest", name, element, index); 4192 for (int i = 0; i < element.getIdentifier().size(); i++) 4193 composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i); 4194 for (int i = 0; i < element.getBasedOn().size(); i++) 4195 composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i); 4196 for (int i = 0; i < element.getReplaces().size(); i++) 4197 composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i); 4198 if (element.hasGroupIdentifier()) 4199 composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 4200 if (element.hasStatusElement()) 4201 composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1); 4202 if (element.hasStatusReason()) 4203 composeCodeableConcept(t, "CommunicationRequest", "statusReason", element.getStatusReason(), -1); 4204 for (int i = 0; i < element.getCategory().size(); i++) 4205 composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i); 4206 if (element.hasPriorityElement()) 4207 composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1); 4208 if (element.hasDoNotPerformElement()) 4209 composeBoolean(t, "CommunicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 4210 for (int i = 0; i < element.getMedium().size(); i++) 4211 composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i); 4212 if (element.hasSubject()) 4213 composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1); 4214 for (int i = 0; i < element.getAbout().size(); i++) 4215 composeReference(t, "CommunicationRequest", "about", element.getAbout().get(i), i); 4216 if (element.hasEncounter()) 4217 composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1); 4218 for (int i = 0; i < element.getPayload().size(); i++) 4219 composeCommunicationRequestCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i); 4220 if (element.hasOccurrence()) 4221 composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1); 4222 if (element.hasAuthoredOnElement()) 4223 composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 4224 if (element.hasRequester()) 4225 composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1); 4226 for (int i = 0; i < element.getRecipient().size(); i++) 4227 composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i); 4228 if (element.hasSender()) 4229 composeReference(t, "CommunicationRequest", "sender", element.getSender(), -1); 4230 for (int i = 0; i < element.getReasonCode().size(); i++) 4231 composeCodeableConcept(t, "CommunicationRequest", "reasonCode", element.getReasonCode().get(i), i); 4232 for (int i = 0; i < element.getReasonReference().size(); i++) 4233 composeReference(t, "CommunicationRequest", "reasonReference", element.getReasonReference().get(i), i); 4234 for (int i = 0; i < element.getNote().size(); i++) 4235 composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i); 4236 } 4237 4238 protected void composeCommunicationRequestCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) { 4239 if (element == null) 4240 return; 4241 Complex t; 4242 if (Utilities.noString(parentType)) 4243 t = parent; 4244 else { 4245 t = parent.predicate("fhir:"+parentType+'.'+name); 4246 } 4247 composeBackboneElement(t, "payload", name, element, index); 4248 if (element.hasContent()) 4249 composeType(t, "CommunicationRequest", "content", element.getContent(), -1); 4250 } 4251 4252 protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) { 4253 if (element == null) 4254 return; 4255 Complex t; 4256 if (Utilities.noString(parentType)) 4257 t = parent; 4258 else { 4259 t = parent.predicate("fhir:"+parentType+'.'+name); 4260 } 4261 composeDomainResource(t, "CompartmentDefinition", name, element, index); 4262 if (element.hasUrlElement()) 4263 composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1); 4264 if (element.hasVersionElement()) 4265 composeString(t, "CompartmentDefinition", "version", element.getVersionElement(), -1); 4266 if (element.hasNameElement()) 4267 composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1); 4268 if (element.hasStatusElement()) 4269 composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1); 4270 if (element.hasExperimentalElement()) 4271 composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1); 4272 if (element.hasDateElement()) 4273 composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1); 4274 if (element.hasPublisherElement()) 4275 composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1); 4276 for (int i = 0; i < element.getContact().size(); i++) 4277 composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i); 4278 if (element.hasDescriptionElement()) 4279 composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1); 4280 for (int i = 0; i < element.getUseContext().size(); i++) 4281 composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i); 4282 if (element.hasPurposeElement()) 4283 composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1); 4284 if (element.hasCodeElement()) 4285 composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 4286 if (element.hasSearchElement()) 4287 composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1); 4288 for (int i = 0; i < element.getResource().size(); i++) 4289 composeCompartmentDefinitionCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i); 4290 } 4291 4292 protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) { 4293 if (element == null) 4294 return; 4295 Complex t; 4296 if (Utilities.noString(parentType)) 4297 t = parent; 4298 else { 4299 t = parent.predicate("fhir:"+parentType+'.'+name); 4300 } 4301 composeBackboneElement(t, "resource", name, element, index); 4302 if (element.hasCodeElement()) 4303 composeCode(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 4304 for (int i = 0; i < element.getParam().size(); i++) 4305 composeString(t, "CompartmentDefinition", "param", element.getParam().get(i), i); 4306 if (element.hasDocumentationElement()) 4307 composeString(t, "CompartmentDefinition", "documentation", element.getDocumentationElement(), -1); 4308 } 4309 4310 protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) { 4311 if (element == null) 4312 return; 4313 Complex t; 4314 if (Utilities.noString(parentType)) 4315 t = parent; 4316 else { 4317 t = parent.predicate("fhir:"+parentType+'.'+name); 4318 } 4319 composeDomainResource(t, "Composition", name, element, index); 4320 if (element.hasIdentifier()) 4321 composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1); 4322 if (element.hasStatusElement()) 4323 composeEnum(t, "Composition", "status", element.getStatusElement(), -1); 4324 if (element.hasType()) 4325 composeCodeableConcept(t, "Composition", "type", element.getType(), -1); 4326 for (int i = 0; i < element.getCategory().size(); i++) 4327 composeCodeableConcept(t, "Composition", "category", element.getCategory().get(i), i); 4328 if (element.hasSubject()) 4329 composeReference(t, "Composition", "subject", element.getSubject(), -1); 4330 if (element.hasEncounter()) 4331 composeReference(t, "Composition", "encounter", element.getEncounter(), -1); 4332 if (element.hasDateElement()) 4333 composeDateTime(t, "Composition", "date", element.getDateElement(), -1); 4334 for (int i = 0; i < element.getAuthor().size(); i++) 4335 composeReference(t, "Composition", "author", element.getAuthor().get(i), i); 4336 if (element.hasTitleElement()) 4337 composeString(t, "Composition", "title", element.getTitleElement(), -1); 4338 if (element.hasConfidentialityElement()) 4339 composeEnum(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1); 4340 for (int i = 0; i < element.getAttester().size(); i++) 4341 composeCompositionCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i); 4342 if (element.hasCustodian()) 4343 composeReference(t, "Composition", "custodian", element.getCustodian(), -1); 4344 for (int i = 0; i < element.getRelatesTo().size(); i++) 4345 composeCompositionCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i); 4346 for (int i = 0; i < element.getEvent().size(); i++) 4347 composeCompositionCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i); 4348 for (int i = 0; i < element.getSection().size(); i++) 4349 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 4350 } 4351 4352 protected void composeCompositionCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) { 4353 if (element == null) 4354 return; 4355 Complex t; 4356 if (Utilities.noString(parentType)) 4357 t = parent; 4358 else { 4359 t = parent.predicate("fhir:"+parentType+'.'+name); 4360 } 4361 composeBackboneElement(t, "attester", name, element, index); 4362 if (element.hasModeElement()) 4363 composeEnum(t, "Composition", "mode", element.getModeElement(), -1); 4364 if (element.hasTimeElement()) 4365 composeDateTime(t, "Composition", "time", element.getTimeElement(), -1); 4366 if (element.hasParty()) 4367 composeReference(t, "Composition", "party", element.getParty(), -1); 4368 } 4369 4370 protected void composeCompositionCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) { 4371 if (element == null) 4372 return; 4373 Complex t; 4374 if (Utilities.noString(parentType)) 4375 t = parent; 4376 else { 4377 t = parent.predicate("fhir:"+parentType+'.'+name); 4378 } 4379 composeBackboneElement(t, "relatesTo", name, element, index); 4380 if (element.hasCodeElement()) 4381 composeEnum(t, "Composition", "code", element.getCodeElement(), -1); 4382 if (element.hasTarget()) 4383 composeType(t, "Composition", "target", element.getTarget(), -1); 4384 } 4385 4386 protected void composeCompositionCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) { 4387 if (element == null) 4388 return; 4389 Complex t; 4390 if (Utilities.noString(parentType)) 4391 t = parent; 4392 else { 4393 t = parent.predicate("fhir:"+parentType+'.'+name); 4394 } 4395 composeBackboneElement(t, "event", name, element, index); 4396 for (int i = 0; i < element.getCode().size(); i++) 4397 composeCodeableConcept(t, "Composition", "code", element.getCode().get(i), i); 4398 if (element.hasPeriod()) 4399 composePeriod(t, "Composition", "period", element.getPeriod(), -1); 4400 for (int i = 0; i < element.getDetail().size(); i++) 4401 composeReference(t, "Composition", "detail", element.getDetail().get(i), i); 4402 } 4403 4404 protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) { 4405 if (element == null) 4406 return; 4407 Complex t; 4408 if (Utilities.noString(parentType)) 4409 t = parent; 4410 else { 4411 t = parent.predicate("fhir:"+parentType+'.'+name); 4412 } 4413 composeBackboneElement(t, "section", name, element, index); 4414 if (element.hasTitleElement()) 4415 composeString(t, "Composition", "title", element.getTitleElement(), -1); 4416 if (element.hasCode()) 4417 composeCodeableConcept(t, "Composition", "code", element.getCode(), -1); 4418 for (int i = 0; i < element.getAuthor().size(); i++) 4419 composeReference(t, "Composition", "author", element.getAuthor().get(i), i); 4420 if (element.hasFocus()) 4421 composeReference(t, "Composition", "focus", element.getFocus(), -1); 4422 if (element.hasText()) 4423 composeNarrative(t, "Composition", "text", element.getText(), -1); 4424 if (element.hasModeElement()) 4425 composeEnum(t, "Composition", "mode", element.getModeElement(), -1); 4426 if (element.hasOrderedBy()) 4427 composeCodeableConcept(t, "Composition", "orderedBy", element.getOrderedBy(), -1); 4428 for (int i = 0; i < element.getEntry().size(); i++) 4429 composeReference(t, "Composition", "entry", element.getEntry().get(i), i); 4430 if (element.hasEmptyReason()) 4431 composeCodeableConcept(t, "Composition", "emptyReason", element.getEmptyReason(), -1); 4432 for (int i = 0; i < element.getSection().size(); i++) 4433 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 4434 } 4435 4436 protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) { 4437 if (element == null) 4438 return; 4439 Complex t; 4440 if (Utilities.noString(parentType)) 4441 t = parent; 4442 else { 4443 t = parent.predicate("fhir:"+parentType+'.'+name); 4444 } 4445 composeDomainResource(t, "ConceptMap", name, element, index); 4446 if (element.hasUrlElement()) 4447 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 4448 if (element.hasIdentifier()) 4449 composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier(), -1); 4450 if (element.hasVersionElement()) 4451 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 4452 if (element.hasNameElement()) 4453 composeString(t, "ConceptMap", "name", element.getNameElement(), -1); 4454 if (element.hasTitleElement()) 4455 composeString(t, "ConceptMap", "title", element.getTitleElement(), -1); 4456 if (element.hasStatusElement()) 4457 composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1); 4458 if (element.hasExperimentalElement()) 4459 composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1); 4460 if (element.hasDateElement()) 4461 composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1); 4462 if (element.hasPublisherElement()) 4463 composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1); 4464 for (int i = 0; i < element.getContact().size(); i++) 4465 composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i); 4466 if (element.hasDescriptionElement()) 4467 composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1); 4468 for (int i = 0; i < element.getUseContext().size(); i++) 4469 composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i); 4470 for (int i = 0; i < element.getJurisdiction().size(); i++) 4471 composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i); 4472 if (element.hasPurposeElement()) 4473 composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1); 4474 if (element.hasCopyrightElement()) 4475 composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1); 4476 if (element.hasSource()) 4477 composeType(t, "ConceptMap", "source", element.getSource(), -1); 4478 if (element.hasTarget()) 4479 composeType(t, "ConceptMap", "target", element.getTarget(), -1); 4480 for (int i = 0; i < element.getGroup().size(); i++) 4481 composeConceptMapConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i); 4482 } 4483 4484 protected void composeConceptMapConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) { 4485 if (element == null) 4486 return; 4487 Complex t; 4488 if (Utilities.noString(parentType)) 4489 t = parent; 4490 else { 4491 t = parent.predicate("fhir:"+parentType+'.'+name); 4492 } 4493 composeBackboneElement(t, "group", name, element, index); 4494 if (element.hasSourceElement()) 4495 composeUri(t, "ConceptMap", "source", element.getSourceElement(), -1); 4496 if (element.hasSourceVersionElement()) 4497 composeString(t, "ConceptMap", "sourceVersion", element.getSourceVersionElement(), -1); 4498 if (element.hasTargetElement()) 4499 composeUri(t, "ConceptMap", "target", element.getTargetElement(), -1); 4500 if (element.hasTargetVersionElement()) 4501 composeString(t, "ConceptMap", "targetVersion", element.getTargetVersionElement(), -1); 4502 for (int i = 0; i < element.getElement().size(); i++) 4503 composeConceptMapSourceElementComponent(t, "ConceptMap", "element", element.getElement().get(i), i); 4504 if (element.hasUnmapped()) 4505 composeConceptMapConceptMapGroupUnmappedComponent(t, "ConceptMap", "unmapped", element.getUnmapped(), -1); 4506 } 4507 4508 protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) { 4509 if (element == null) 4510 return; 4511 Complex t; 4512 if (Utilities.noString(parentType)) 4513 t = parent; 4514 else { 4515 t = parent.predicate("fhir:"+parentType+'.'+name); 4516 } 4517 composeBackboneElement(t, "element", name, element, index); 4518 if (element.hasCodeElement()) 4519 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 4520 if (element.hasDisplayElement()) 4521 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 4522 for (int i = 0; i < element.getTarget().size(); i++) 4523 composeConceptMapTargetElementComponent(t, "ConceptMap", "target", element.getTarget().get(i), i); 4524 } 4525 4526 protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) { 4527 if (element == null) 4528 return; 4529 Complex t; 4530 if (Utilities.noString(parentType)) 4531 t = parent; 4532 else { 4533 t = parent.predicate("fhir:"+parentType+'.'+name); 4534 } 4535 composeBackboneElement(t, "target", name, element, index); 4536 if (element.hasCodeElement()) 4537 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 4538 if (element.hasDisplayElement()) 4539 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 4540 if (element.hasEquivalenceElement()) 4541 composeEnum(t, "ConceptMap", "equivalence", element.getEquivalenceElement(), -1); 4542 if (element.hasCommentElement()) 4543 composeString(t, "ConceptMap", "comment", element.getCommentElement(), -1); 4544 for (int i = 0; i < element.getDependsOn().size(); i++) 4545 composeConceptMapOtherElementComponent(t, "ConceptMap", "dependsOn", element.getDependsOn().get(i), i); 4546 for (int i = 0; i < element.getProduct().size(); i++) 4547 composeConceptMapOtherElementComponent(t, "ConceptMap", "product", element.getProduct().get(i), i); 4548 } 4549 4550 protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) { 4551 if (element == null) 4552 return; 4553 Complex t; 4554 if (Utilities.noString(parentType)) 4555 t = parent; 4556 else { 4557 t = parent.predicate("fhir:"+parentType+'.'+name); 4558 } 4559 composeBackboneElement(t, "dependsOn", name, element, index); 4560 if (element.hasPropertyElement()) 4561 composeUri(t, "ConceptMap", "property", element.getPropertyElement(), -1); 4562 if (element.hasSystemElement()) 4563 composeCanonical(t, "ConceptMap", "system", element.getSystemElement(), -1); 4564 if (element.hasValueElement()) 4565 composeString(t, "ConceptMap", "value", element.getValueElement(), -1); 4566 if (element.hasDisplayElement()) 4567 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 4568 } 4569 4570 protected void composeConceptMapConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) { 4571 if (element == null) 4572 return; 4573 Complex t; 4574 if (Utilities.noString(parentType)) 4575 t = parent; 4576 else { 4577 t = parent.predicate("fhir:"+parentType+'.'+name); 4578 } 4579 composeBackboneElement(t, "unmapped", name, element, index); 4580 if (element.hasModeElement()) 4581 composeEnum(t, "ConceptMap", "mode", element.getModeElement(), -1); 4582 if (element.hasCodeElement()) 4583 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 4584 if (element.hasDisplayElement()) 4585 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 4586 if (element.hasUrlElement()) 4587 composeCanonical(t, "ConceptMap", "url", element.getUrlElement(), -1); 4588 } 4589 4590 protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) { 4591 if (element == null) 4592 return; 4593 Complex t; 4594 if (Utilities.noString(parentType)) 4595 t = parent; 4596 else { 4597 t = parent.predicate("fhir:"+parentType+'.'+name); 4598 } 4599 composeDomainResource(t, "Condition", name, element, index); 4600 for (int i = 0; i < element.getIdentifier().size(); i++) 4601 composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i); 4602 if (element.hasClinicalStatus()) 4603 composeCodeableConcept(t, "Condition", "clinicalStatus", element.getClinicalStatus(), -1); 4604 if (element.hasVerificationStatus()) 4605 composeCodeableConcept(t, "Condition", "verificationStatus", element.getVerificationStatus(), -1); 4606 for (int i = 0; i < element.getCategory().size(); i++) 4607 composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i); 4608 if (element.hasSeverity()) 4609 composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1); 4610 if (element.hasCode()) 4611 composeCodeableConcept(t, "Condition", "code", element.getCode(), -1); 4612 for (int i = 0; i < element.getBodySite().size(); i++) 4613 composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i); 4614 if (element.hasSubject()) 4615 composeReference(t, "Condition", "subject", element.getSubject(), -1); 4616 if (element.hasEncounter()) 4617 composeReference(t, "Condition", "encounter", element.getEncounter(), -1); 4618 if (element.hasOnset()) 4619 composeType(t, "Condition", "onset", element.getOnset(), -1); 4620 if (element.hasAbatement()) 4621 composeType(t, "Condition", "abatement", element.getAbatement(), -1); 4622 if (element.hasRecordedDateElement()) 4623 composeDateTime(t, "Condition", "recordedDate", element.getRecordedDateElement(), -1); 4624 if (element.hasRecorder()) 4625 composeReference(t, "Condition", "recorder", element.getRecorder(), -1); 4626 if (element.hasAsserter()) 4627 composeReference(t, "Condition", "asserter", element.getAsserter(), -1); 4628 for (int i = 0; i < element.getStage().size(); i++) 4629 composeConditionConditionStageComponent(t, "Condition", "stage", element.getStage().get(i), i); 4630 for (int i = 0; i < element.getEvidence().size(); i++) 4631 composeConditionConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i); 4632 for (int i = 0; i < element.getNote().size(); i++) 4633 composeAnnotation(t, "Condition", "note", element.getNote().get(i), i); 4634 } 4635 4636 protected void composeConditionConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) { 4637 if (element == null) 4638 return; 4639 Complex t; 4640 if (Utilities.noString(parentType)) 4641 t = parent; 4642 else { 4643 t = parent.predicate("fhir:"+parentType+'.'+name); 4644 } 4645 composeBackboneElement(t, "stage", name, element, index); 4646 if (element.hasSummary()) 4647 composeCodeableConcept(t, "Condition", "summary", element.getSummary(), -1); 4648 for (int i = 0; i < element.getAssessment().size(); i++) 4649 composeReference(t, "Condition", "assessment", element.getAssessment().get(i), i); 4650 if (element.hasType()) 4651 composeCodeableConcept(t, "Condition", "type", element.getType(), -1); 4652 } 4653 4654 protected void composeConditionConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) { 4655 if (element == null) 4656 return; 4657 Complex t; 4658 if (Utilities.noString(parentType)) 4659 t = parent; 4660 else { 4661 t = parent.predicate("fhir:"+parentType+'.'+name); 4662 } 4663 composeBackboneElement(t, "evidence", name, element, index); 4664 for (int i = 0; i < element.getCode().size(); i++) 4665 composeCodeableConcept(t, "Condition", "code", element.getCode().get(i), i); 4666 for (int i = 0; i < element.getDetail().size(); i++) 4667 composeReference(t, "Condition", "detail", element.getDetail().get(i), i); 4668 } 4669 4670 protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) { 4671 if (element == null) 4672 return; 4673 Complex t; 4674 if (Utilities.noString(parentType)) 4675 t = parent; 4676 else { 4677 t = parent.predicate("fhir:"+parentType+'.'+name); 4678 } 4679 composeDomainResource(t, "Consent", name, element, index); 4680 for (int i = 0; i < element.getIdentifier().size(); i++) 4681 composeIdentifier(t, "Consent", "identifier", element.getIdentifier().get(i), i); 4682 if (element.hasStatusElement()) 4683 composeEnum(t, "Consent", "status", element.getStatusElement(), -1); 4684 if (element.hasScope()) 4685 composeCodeableConcept(t, "Consent", "scope", element.getScope(), -1); 4686 for (int i = 0; i < element.getCategory().size(); i++) 4687 composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i); 4688 if (element.hasPatient()) 4689 composeReference(t, "Consent", "patient", element.getPatient(), -1); 4690 if (element.hasDateTimeElement()) 4691 composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1); 4692 for (int i = 0; i < element.getPerformer().size(); i++) 4693 composeReference(t, "Consent", "performer", element.getPerformer().get(i), i); 4694 for (int i = 0; i < element.getOrganization().size(); i++) 4695 composeReference(t, "Consent", "organization", element.getOrganization().get(i), i); 4696 if (element.hasSource()) 4697 composeType(t, "Consent", "source", element.getSource(), -1); 4698 for (int i = 0; i < element.getPolicy().size(); i++) 4699 composeConsentConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i); 4700 if (element.hasPolicyRule()) 4701 composeCodeableConcept(t, "Consent", "policyRule", element.getPolicyRule(), -1); 4702 for (int i = 0; i < element.getVerification().size(); i++) 4703 composeConsentConsentVerificationComponent(t, "Consent", "verification", element.getVerification().get(i), i); 4704 if (element.hasProvision()) 4705 composeConsentprovisionComponent(t, "Consent", "provision", element.getProvision(), -1); 4706 } 4707 4708 protected void composeConsentConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) { 4709 if (element == null) 4710 return; 4711 Complex t; 4712 if (Utilities.noString(parentType)) 4713 t = parent; 4714 else { 4715 t = parent.predicate("fhir:"+parentType+'.'+name); 4716 } 4717 composeBackboneElement(t, "policy", name, element, index); 4718 if (element.hasAuthorityElement()) 4719 composeUri(t, "Consent", "authority", element.getAuthorityElement(), -1); 4720 if (element.hasUriElement()) 4721 composeUri(t, "Consent", "uri", element.getUriElement(), -1); 4722 } 4723 4724 protected void composeConsentConsentVerificationComponent(Complex parent, String parentType, String name, Consent.ConsentVerificationComponent element, int index) { 4725 if (element == null) 4726 return; 4727 Complex t; 4728 if (Utilities.noString(parentType)) 4729 t = parent; 4730 else { 4731 t = parent.predicate("fhir:"+parentType+'.'+name); 4732 } 4733 composeBackboneElement(t, "verification", name, element, index); 4734 if (element.hasVerifiedElement()) 4735 composeBoolean(t, "Consent", "verified", element.getVerifiedElement(), -1); 4736 if (element.hasVerifiedWith()) 4737 composeReference(t, "Consent", "verifiedWith", element.getVerifiedWith(), -1); 4738 if (element.hasVerificationDateElement()) 4739 composeDateTime(t, "Consent", "verificationDate", element.getVerificationDateElement(), -1); 4740 } 4741 4742 protected void composeConsentprovisionComponent(Complex parent, String parentType, String name, Consent.provisionComponent element, int index) { 4743 if (element == null) 4744 return; 4745 Complex t; 4746 if (Utilities.noString(parentType)) 4747 t = parent; 4748 else { 4749 t = parent.predicate("fhir:"+parentType+'.'+name); 4750 } 4751 composeBackboneElement(t, "provision", name, element, index); 4752 if (element.hasTypeElement()) 4753 composeEnum(t, "Consent", "type", element.getTypeElement(), -1); 4754 if (element.hasPeriod()) 4755 composePeriod(t, "Consent", "period", element.getPeriod(), -1); 4756 for (int i = 0; i < element.getActor().size(); i++) 4757 composeConsentprovisionActorComponent(t, "Consent", "actor", element.getActor().get(i), i); 4758 for (int i = 0; i < element.getAction().size(); i++) 4759 composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i); 4760 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4761 composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i); 4762 for (int i = 0; i < element.getPurpose().size(); i++) 4763 composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i); 4764 for (int i = 0; i < element.getClass_().size(); i++) 4765 composeCoding(t, "Consent", "class", element.getClass_().get(i), i); 4766 for (int i = 0; i < element.getCode().size(); i++) 4767 composeCodeableConcept(t, "Consent", "code", element.getCode().get(i), i); 4768 if (element.hasDataPeriod()) 4769 composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1); 4770 for (int i = 0; i < element.getData().size(); i++) 4771 composeConsentprovisionDataComponent(t, "Consent", "data", element.getData().get(i), i); 4772 for (int i = 0; i < element.getProvision().size(); i++) 4773 composeConsentprovisionComponent(t, "Consent", "provision", element.getProvision().get(i), i); 4774 } 4775 4776 protected void composeConsentprovisionActorComponent(Complex parent, String parentType, String name, Consent.provisionActorComponent element, int index) { 4777 if (element == null) 4778 return; 4779 Complex t; 4780 if (Utilities.noString(parentType)) 4781 t = parent; 4782 else { 4783 t = parent.predicate("fhir:"+parentType+'.'+name); 4784 } 4785 composeBackboneElement(t, "actor", name, element, index); 4786 if (element.hasRole()) 4787 composeCodeableConcept(t, "Consent", "role", element.getRole(), -1); 4788 if (element.hasReference()) 4789 composeReference(t, "Consent", "reference", element.getReference(), -1); 4790 } 4791 4792 protected void composeConsentprovisionDataComponent(Complex parent, String parentType, String name, Consent.provisionDataComponent element, int index) { 4793 if (element == null) 4794 return; 4795 Complex t; 4796 if (Utilities.noString(parentType)) 4797 t = parent; 4798 else { 4799 t = parent.predicate("fhir:"+parentType+'.'+name); 4800 } 4801 composeBackboneElement(t, "data", name, element, index); 4802 if (element.hasMeaningElement()) 4803 composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1); 4804 if (element.hasReference()) 4805 composeReference(t, "Consent", "reference", element.getReference(), -1); 4806 } 4807 4808 protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) { 4809 if (element == null) 4810 return; 4811 Complex t; 4812 if (Utilities.noString(parentType)) 4813 t = parent; 4814 else { 4815 t = parent.predicate("fhir:"+parentType+'.'+name); 4816 } 4817 composeDomainResource(t, "Contract", name, element, index); 4818 for (int i = 0; i < element.getIdentifier().size(); i++) 4819 composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i); 4820 if (element.hasUrlElement()) 4821 composeUri(t, "Contract", "url", element.getUrlElement(), -1); 4822 if (element.hasVersionElement()) 4823 composeString(t, "Contract", "version", element.getVersionElement(), -1); 4824 if (element.hasStatusElement()) 4825 composeEnum(t, "Contract", "status", element.getStatusElement(), -1); 4826 if (element.hasLegalState()) 4827 composeCodeableConcept(t, "Contract", "legalState", element.getLegalState(), -1); 4828 if (element.hasInstantiatesCanonical()) 4829 composeReference(t, "Contract", "instantiatesCanonical", element.getInstantiatesCanonical(), -1); 4830 if (element.hasInstantiatesUriElement()) 4831 composeUri(t, "Contract", "instantiatesUri", element.getInstantiatesUriElement(), -1); 4832 if (element.hasContentDerivative()) 4833 composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1); 4834 if (element.hasIssuedElement()) 4835 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 4836 if (element.hasApplies()) 4837 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 4838 if (element.hasExpirationType()) 4839 composeCodeableConcept(t, "Contract", "expirationType", element.getExpirationType(), -1); 4840 for (int i = 0; i < element.getSubject().size(); i++) 4841 composeReference(t, "Contract", "subject", element.getSubject().get(i), i); 4842 for (int i = 0; i < element.getAuthority().size(); i++) 4843 composeReference(t, "Contract", "authority", element.getAuthority().get(i), i); 4844 for (int i = 0; i < element.getDomain().size(); i++) 4845 composeReference(t, "Contract", "domain", element.getDomain().get(i), i); 4846 for (int i = 0; i < element.getSite().size(); i++) 4847 composeReference(t, "Contract", "site", element.getSite().get(i), i); 4848 if (element.hasNameElement()) 4849 composeString(t, "Contract", "name", element.getNameElement(), -1); 4850 if (element.hasTitleElement()) 4851 composeString(t, "Contract", "title", element.getTitleElement(), -1); 4852 if (element.hasSubtitleElement()) 4853 composeString(t, "Contract", "subtitle", element.getSubtitleElement(), -1); 4854 for (int i = 0; i < element.getAlias().size(); i++) 4855 composeString(t, "Contract", "alias", element.getAlias().get(i), i); 4856 if (element.hasAuthor()) 4857 composeReference(t, "Contract", "author", element.getAuthor(), -1); 4858 if (element.hasScope()) 4859 composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1); 4860 if (element.hasTopic()) 4861 composeType(t, "Contract", "topic", element.getTopic(), -1); 4862 if (element.hasType()) 4863 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4864 for (int i = 0; i < element.getSubType().size(); i++) 4865 composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i); 4866 if (element.hasContentDefinition()) 4867 composeContractContentDefinitionComponent(t, "Contract", "contentDefinition", element.getContentDefinition(), -1); 4868 for (int i = 0; i < element.getTerm().size(); i++) 4869 composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i); 4870 for (int i = 0; i < element.getSupportingInfo().size(); i++) 4871 composeReference(t, "Contract", "supportingInfo", element.getSupportingInfo().get(i), i); 4872 for (int i = 0; i < element.getRelevantHistory().size(); i++) 4873 composeReference(t, "Contract", "relevantHistory", element.getRelevantHistory().get(i), i); 4874 for (int i = 0; i < element.getSigner().size(); i++) 4875 composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i); 4876 for (int i = 0; i < element.getFriendly().size(); i++) 4877 composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i); 4878 for (int i = 0; i < element.getLegal().size(); i++) 4879 composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i); 4880 for (int i = 0; i < element.getRule().size(); i++) 4881 composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i); 4882 if (element.hasLegallyBinding()) 4883 composeType(t, "Contract", "legallyBinding", element.getLegallyBinding(), -1); 4884 } 4885 4886 protected void composeContractContentDefinitionComponent(Complex parent, String parentType, String name, Contract.ContentDefinitionComponent element, int index) { 4887 if (element == null) 4888 return; 4889 Complex t; 4890 if (Utilities.noString(parentType)) 4891 t = parent; 4892 else { 4893 t = parent.predicate("fhir:"+parentType+'.'+name); 4894 } 4895 composeBackboneElement(t, "contentDefinition", name, element, index); 4896 if (element.hasType()) 4897 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4898 if (element.hasSubType()) 4899 composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1); 4900 if (element.hasPublisher()) 4901 composeReference(t, "Contract", "publisher", element.getPublisher(), -1); 4902 if (element.hasPublicationDateElement()) 4903 composeDateTime(t, "Contract", "publicationDate", element.getPublicationDateElement(), -1); 4904 if (element.hasPublicationStatusElement()) 4905 composeEnum(t, "Contract", "publicationStatus", element.getPublicationStatusElement(), -1); 4906 if (element.hasCopyrightElement()) 4907 composeMarkdown(t, "Contract", "copyright", element.getCopyrightElement(), -1); 4908 } 4909 4910 protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) { 4911 if (element == null) 4912 return; 4913 Complex t; 4914 if (Utilities.noString(parentType)) 4915 t = parent; 4916 else { 4917 t = parent.predicate("fhir:"+parentType+'.'+name); 4918 } 4919 composeBackboneElement(t, "term", name, element, index); 4920 if (element.hasIdentifier()) 4921 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4922 if (element.hasIssuedElement()) 4923 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 4924 if (element.hasApplies()) 4925 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 4926 if (element.hasTopic()) 4927 composeType(t, "Contract", "topic", element.getTopic(), -1); 4928 if (element.hasType()) 4929 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4930 if (element.hasSubType()) 4931 composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1); 4932 if (element.hasTextElement()) 4933 composeString(t, "Contract", "text", element.getTextElement(), -1); 4934 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4935 composeContractSecurityLabelComponent(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i); 4936 if (element.hasOffer()) 4937 composeContractContractOfferComponent(t, "Contract", "offer", element.getOffer(), -1); 4938 for (int i = 0; i < element.getAsset().size(); i++) 4939 composeContractContractAssetComponent(t, "Contract", "asset", element.getAsset().get(i), i); 4940 for (int i = 0; i < element.getAction().size(); i++) 4941 composeContractActionComponent(t, "Contract", "action", element.getAction().get(i), i); 4942 for (int i = 0; i < element.getGroup().size(); i++) 4943 composeContractTermComponent(t, "Contract", "group", element.getGroup().get(i), i); 4944 } 4945 4946 protected void composeContractSecurityLabelComponent(Complex parent, String parentType, String name, Contract.SecurityLabelComponent element, int index) { 4947 if (element == null) 4948 return; 4949 Complex t; 4950 if (Utilities.noString(parentType)) 4951 t = parent; 4952 else { 4953 t = parent.predicate("fhir:"+parentType+'.'+name); 4954 } 4955 composeBackboneElement(t, "securityLabel", name, element, index); 4956 for (int i = 0; i < element.getNumber().size(); i++) 4957 composeUnsignedInt(t, "Contract", "number", element.getNumber().get(i), i); 4958 if (element.hasClassification()) 4959 composeCoding(t, "Contract", "classification", element.getClassification(), -1); 4960 for (int i = 0; i < element.getCategory().size(); i++) 4961 composeCoding(t, "Contract", "category", element.getCategory().get(i), i); 4962 for (int i = 0; i < element.getControl().size(); i++) 4963 composeCoding(t, "Contract", "control", element.getControl().get(i), i); 4964 } 4965 4966 protected void composeContractContractOfferComponent(Complex parent, String parentType, String name, Contract.ContractOfferComponent element, int index) { 4967 if (element == null) 4968 return; 4969 Complex t; 4970 if (Utilities.noString(parentType)) 4971 t = parent; 4972 else { 4973 t = parent.predicate("fhir:"+parentType+'.'+name); 4974 } 4975 composeBackboneElement(t, "offer", name, element, index); 4976 for (int i = 0; i < element.getIdentifier().size(); i++) 4977 composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i); 4978 for (int i = 0; i < element.getParty().size(); i++) 4979 composeContractContractPartyComponent(t, "Contract", "party", element.getParty().get(i), i); 4980 if (element.hasTopic()) 4981 composeReference(t, "Contract", "topic", element.getTopic(), -1); 4982 if (element.hasType()) 4983 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4984 if (element.hasDecision()) 4985 composeCodeableConcept(t, "Contract", "decision", element.getDecision(), -1); 4986 for (int i = 0; i < element.getDecisionMode().size(); i++) 4987 composeCodeableConcept(t, "Contract", "decisionMode", element.getDecisionMode().get(i), i); 4988 for (int i = 0; i < element.getAnswer().size(); i++) 4989 composeContractAnswerComponent(t, "Contract", "answer", element.getAnswer().get(i), i); 4990 if (element.hasTextElement()) 4991 composeString(t, "Contract", "text", element.getTextElement(), -1); 4992 for (int i = 0; i < element.getLinkId().size(); i++) 4993 composeString(t, "Contract", "linkId", element.getLinkId().get(i), i); 4994 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) 4995 composeUnsignedInt(t, "Contract", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 4996 } 4997 4998 protected void composeContractContractPartyComponent(Complex parent, String parentType, String name, Contract.ContractPartyComponent element, int index) { 4999 if (element == null) 5000 return; 5001 Complex t; 5002 if (Utilities.noString(parentType)) 5003 t = parent; 5004 else { 5005 t = parent.predicate("fhir:"+parentType+'.'+name); 5006 } 5007 composeBackboneElement(t, "party", name, element, index); 5008 for (int i = 0; i < element.getReference().size(); i++) 5009 composeReference(t, "Contract", "reference", element.getReference().get(i), i); 5010 if (element.hasRole()) 5011 composeCodeableConcept(t, "Contract", "role", element.getRole(), -1); 5012 } 5013 5014 protected void composeContractAnswerComponent(Complex parent, String parentType, String name, Contract.AnswerComponent element, int index) { 5015 if (element == null) 5016 return; 5017 Complex t; 5018 if (Utilities.noString(parentType)) 5019 t = parent; 5020 else { 5021 t = parent.predicate("fhir:"+parentType+'.'+name); 5022 } 5023 composeBackboneElement(t, "answer", name, element, index); 5024 if (element.hasValue()) 5025 composeType(t, "Contract", "value", element.getValue(), -1); 5026 } 5027 5028 protected void composeContractContractAssetComponent(Complex parent, String parentType, String name, Contract.ContractAssetComponent element, int index) { 5029 if (element == null) 5030 return; 5031 Complex t; 5032 if (Utilities.noString(parentType)) 5033 t = parent; 5034 else { 5035 t = parent.predicate("fhir:"+parentType+'.'+name); 5036 } 5037 composeBackboneElement(t, "asset", name, element, index); 5038 if (element.hasScope()) 5039 composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1); 5040 for (int i = 0; i < element.getType().size(); i++) 5041 composeCodeableConcept(t, "Contract", "type", element.getType().get(i), i); 5042 for (int i = 0; i < element.getTypeReference().size(); i++) 5043 composeReference(t, "Contract", "typeReference", element.getTypeReference().get(i), i); 5044 for (int i = 0; i < element.getSubtype().size(); i++) 5045 composeCodeableConcept(t, "Contract", "subtype", element.getSubtype().get(i), i); 5046 if (element.hasRelationship()) 5047 composeCoding(t, "Contract", "relationship", element.getRelationship(), -1); 5048 for (int i = 0; i < element.getContext().size(); i++) 5049 composeContractAssetContextComponent(t, "Contract", "context", element.getContext().get(i), i); 5050 if (element.hasConditionElement()) 5051 composeString(t, "Contract", "condition", element.getConditionElement(), -1); 5052 for (int i = 0; i < element.getPeriodType().size(); i++) 5053 composeCodeableConcept(t, "Contract", "periodType", element.getPeriodType().get(i), i); 5054 for (int i = 0; i < element.getPeriod().size(); i++) 5055 composePeriod(t, "Contract", "period", element.getPeriod().get(i), i); 5056 for (int i = 0; i < element.getUsePeriod().size(); i++) 5057 composePeriod(t, "Contract", "usePeriod", element.getUsePeriod().get(i), i); 5058 if (element.hasTextElement()) 5059 composeString(t, "Contract", "text", element.getTextElement(), -1); 5060 for (int i = 0; i < element.getLinkId().size(); i++) 5061 composeString(t, "Contract", "linkId", element.getLinkId().get(i), i); 5062 for (int i = 0; i < element.getAnswer().size(); i++) 5063 composeContractAnswerComponent(t, "Contract", "answer", element.getAnswer().get(i), i); 5064 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) 5065 composeUnsignedInt(t, "Contract", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 5066 for (int i = 0; i < element.getValuedItem().size(); i++) 5067 composeContractValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 5068 } 5069 5070 protected void composeContractAssetContextComponent(Complex parent, String parentType, String name, Contract.AssetContextComponent element, int index) { 5071 if (element == null) 5072 return; 5073 Complex t; 5074 if (Utilities.noString(parentType)) 5075 t = parent; 5076 else { 5077 t = parent.predicate("fhir:"+parentType+'.'+name); 5078 } 5079 composeBackboneElement(t, "context", name, element, index); 5080 if (element.hasReference()) 5081 composeReference(t, "Contract", "reference", element.getReference(), -1); 5082 for (int i = 0; i < element.getCode().size(); i++) 5083 composeCodeableConcept(t, "Contract", "code", element.getCode().get(i), i); 5084 if (element.hasTextElement()) 5085 composeString(t, "Contract", "text", element.getTextElement(), -1); 5086 } 5087 5088 protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) { 5089 if (element == null) 5090 return; 5091 Complex t; 5092 if (Utilities.noString(parentType)) 5093 t = parent; 5094 else { 5095 t = parent.predicate("fhir:"+parentType+'.'+name); 5096 } 5097 composeBackboneElement(t, "valuedItem", name, element, index); 5098 if (element.hasEntity()) 5099 composeType(t, "Contract", "entity", element.getEntity(), -1); 5100 if (element.hasIdentifier()) 5101 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 5102 if (element.hasEffectiveTimeElement()) 5103 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 5104 if (element.hasQuantity()) 5105 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 5106 if (element.hasUnitPrice()) 5107 composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 5108 if (element.hasFactorElement()) 5109 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 5110 if (element.hasPointsElement()) 5111 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 5112 if (element.hasNet()) 5113 composeMoney(t, "Contract", "net", element.getNet(), -1); 5114 if (element.hasPaymentElement()) 5115 composeString(t, "Contract", "payment", element.getPaymentElement(), -1); 5116 if (element.hasPaymentDateElement()) 5117 composeDateTime(t, "Contract", "paymentDate", element.getPaymentDateElement(), -1); 5118 if (element.hasResponsible()) 5119 composeReference(t, "Contract", "responsible", element.getResponsible(), -1); 5120 if (element.hasRecipient()) 5121 composeReference(t, "Contract", "recipient", element.getRecipient(), -1); 5122 for (int i = 0; i < element.getLinkId().size(); i++) 5123 composeString(t, "Contract", "linkId", element.getLinkId().get(i), i); 5124 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) 5125 composeUnsignedInt(t, "Contract", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 5126 } 5127 5128 protected void composeContractActionComponent(Complex parent, String parentType, String name, Contract.ActionComponent element, int index) { 5129 if (element == null) 5130 return; 5131 Complex t; 5132 if (Utilities.noString(parentType)) 5133 t = parent; 5134 else { 5135 t = parent.predicate("fhir:"+parentType+'.'+name); 5136 } 5137 composeBackboneElement(t, "action", name, element, index); 5138 if (element.hasDoNotPerformElement()) 5139 composeBoolean(t, "Contract", "doNotPerform", element.getDoNotPerformElement(), -1); 5140 if (element.hasType()) 5141 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 5142 for (int i = 0; i < element.getSubject().size(); i++) 5143 composeContractActionSubjectComponent(t, "Contract", "subject", element.getSubject().get(i), i); 5144 if (element.hasIntent()) 5145 composeCodeableConcept(t, "Contract", "intent", element.getIntent(), -1); 5146 for (int i = 0; i < element.getLinkId().size(); i++) 5147 composeString(t, "Contract", "linkId", element.getLinkId().get(i), i); 5148 if (element.hasStatus()) 5149 composeCodeableConcept(t, "Contract", "status", element.getStatus(), -1); 5150 if (element.hasContext()) 5151 composeReference(t, "Contract", "context", element.getContext(), -1); 5152 for (int i = 0; i < element.getContextLinkId().size(); i++) 5153 composeString(t, "Contract", "contextLinkId", element.getContextLinkId().get(i), i); 5154 if (element.hasOccurrence()) 5155 composeType(t, "Contract", "occurrence", element.getOccurrence(), -1); 5156 for (int i = 0; i < element.getRequester().size(); i++) 5157 composeReference(t, "Contract", "requester", element.getRequester().get(i), i); 5158 for (int i = 0; i < element.getRequesterLinkId().size(); i++) 5159 composeString(t, "Contract", "requesterLinkId", element.getRequesterLinkId().get(i), i); 5160 for (int i = 0; i < element.getPerformerType().size(); i++) 5161 composeCodeableConcept(t, "Contract", "performerType", element.getPerformerType().get(i), i); 5162 if (element.hasPerformerRole()) 5163 composeCodeableConcept(t, "Contract", "performerRole", element.getPerformerRole(), -1); 5164 if (element.hasPerformer()) 5165 composeReference(t, "Contract", "performer", element.getPerformer(), -1); 5166 for (int i = 0; i < element.getPerformerLinkId().size(); i++) 5167 composeString(t, "Contract", "performerLinkId", element.getPerformerLinkId().get(i), i); 5168 for (int i = 0; i < element.getReasonCode().size(); i++) 5169 composeCodeableConcept(t, "Contract", "reasonCode", element.getReasonCode().get(i), i); 5170 for (int i = 0; i < element.getReasonReference().size(); i++) 5171 composeReference(t, "Contract", "reasonReference", element.getReasonReference().get(i), i); 5172 for (int i = 0; i < element.getReason().size(); i++) 5173 composeString(t, "Contract", "reason", element.getReason().get(i), i); 5174 for (int i = 0; i < element.getReasonLinkId().size(); i++) 5175 composeString(t, "Contract", "reasonLinkId", element.getReasonLinkId().get(i), i); 5176 for (int i = 0; i < element.getNote().size(); i++) 5177 composeAnnotation(t, "Contract", "note", element.getNote().get(i), i); 5178 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) 5179 composeUnsignedInt(t, "Contract", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 5180 } 5181 5182 protected void composeContractActionSubjectComponent(Complex parent, String parentType, String name, Contract.ActionSubjectComponent element, int index) { 5183 if (element == null) 5184 return; 5185 Complex t; 5186 if (Utilities.noString(parentType)) 5187 t = parent; 5188 else { 5189 t = parent.predicate("fhir:"+parentType+'.'+name); 5190 } 5191 composeBackboneElement(t, "subject", name, element, index); 5192 for (int i = 0; i < element.getReference().size(); i++) 5193 composeReference(t, "Contract", "reference", element.getReference().get(i), i); 5194 if (element.hasRole()) 5195 composeCodeableConcept(t, "Contract", "role", element.getRole(), -1); 5196 } 5197 5198 protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) { 5199 if (element == null) 5200 return; 5201 Complex t; 5202 if (Utilities.noString(parentType)) 5203 t = parent; 5204 else { 5205 t = parent.predicate("fhir:"+parentType+'.'+name); 5206 } 5207 composeBackboneElement(t, "signer", name, element, index); 5208 if (element.hasType()) 5209 composeCoding(t, "Contract", "type", element.getType(), -1); 5210 if (element.hasParty()) 5211 composeReference(t, "Contract", "party", element.getParty(), -1); 5212 for (int i = 0; i < element.getSignature().size(); i++) 5213 composeSignature(t, "Contract", "signature", element.getSignature().get(i), i); 5214 } 5215 5216 protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) { 5217 if (element == null) 5218 return; 5219 Complex t; 5220 if (Utilities.noString(parentType)) 5221 t = parent; 5222 else { 5223 t = parent.predicate("fhir:"+parentType+'.'+name); 5224 } 5225 composeBackboneElement(t, "friendly", name, element, index); 5226 if (element.hasContent()) 5227 composeType(t, "Contract", "content", element.getContent(), -1); 5228 } 5229 5230 protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) { 5231 if (element == null) 5232 return; 5233 Complex t; 5234 if (Utilities.noString(parentType)) 5235 t = parent; 5236 else { 5237 t = parent.predicate("fhir:"+parentType+'.'+name); 5238 } 5239 composeBackboneElement(t, "legal", name, element, index); 5240 if (element.hasContent()) 5241 composeType(t, "Contract", "content", element.getContent(), -1); 5242 } 5243 5244 protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) { 5245 if (element == null) 5246 return; 5247 Complex t; 5248 if (Utilities.noString(parentType)) 5249 t = parent; 5250 else { 5251 t = parent.predicate("fhir:"+parentType+'.'+name); 5252 } 5253 composeBackboneElement(t, "rule", name, element, index); 5254 if (element.hasContent()) 5255 composeType(t, "Contract", "content", element.getContent(), -1); 5256 } 5257 5258 protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) { 5259 if (element == null) 5260 return; 5261 Complex t; 5262 if (Utilities.noString(parentType)) 5263 t = parent; 5264 else { 5265 t = parent.predicate("fhir:"+parentType+'.'+name); 5266 } 5267 composeDomainResource(t, "Coverage", name, element, index); 5268 for (int i = 0; i < element.getIdentifier().size(); i++) 5269 composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i); 5270 if (element.hasStatusElement()) 5271 composeEnum(t, "Coverage", "status", element.getStatusElement(), -1); 5272 if (element.hasType()) 5273 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 5274 if (element.hasPolicyHolder()) 5275 composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1); 5276 if (element.hasSubscriber()) 5277 composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1); 5278 if (element.hasSubscriberIdElement()) 5279 composeString(t, "Coverage", "subscriberId", element.getSubscriberIdElement(), -1); 5280 if (element.hasBeneficiary()) 5281 composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1); 5282 if (element.hasDependentElement()) 5283 composeString(t, "Coverage", "dependent", element.getDependentElement(), -1); 5284 if (element.hasRelationship()) 5285 composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1); 5286 if (element.hasPeriod()) 5287 composePeriod(t, "Coverage", "period", element.getPeriod(), -1); 5288 for (int i = 0; i < element.getPayor().size(); i++) 5289 composeReference(t, "Coverage", "payor", element.getPayor().get(i), i); 5290 for (int i = 0; i < element.getClass_().size(); i++) 5291 composeCoverageClassComponent(t, "Coverage", "class", element.getClass_().get(i), i); 5292 if (element.hasOrderElement()) 5293 composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1); 5294 if (element.hasNetworkElement()) 5295 composeString(t, "Coverage", "network", element.getNetworkElement(), -1); 5296 for (int i = 0; i < element.getCostToBeneficiary().size(); i++) 5297 composeCoverageCostToBeneficiaryComponent(t, "Coverage", "costToBeneficiary", element.getCostToBeneficiary().get(i), i); 5298 if (element.hasSubrogationElement()) 5299 composeBoolean(t, "Coverage", "subrogation", element.getSubrogationElement(), -1); 5300 for (int i = 0; i < element.getContract().size(); i++) 5301 composeReference(t, "Coverage", "contract", element.getContract().get(i), i); 5302 } 5303 5304 protected void composeCoverageClassComponent(Complex parent, String parentType, String name, Coverage.ClassComponent element, int index) { 5305 if (element == null) 5306 return; 5307 Complex t; 5308 if (Utilities.noString(parentType)) 5309 t = parent; 5310 else { 5311 t = parent.predicate("fhir:"+parentType+'.'+name); 5312 } 5313 composeBackboneElement(t, "class", name, element, index); 5314 if (element.hasType()) 5315 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 5316 if (element.hasValueElement()) 5317 composeString(t, "Coverage", "value", element.getValueElement(), -1); 5318 if (element.hasNameElement()) 5319 composeString(t, "Coverage", "name", element.getNameElement(), -1); 5320 } 5321 5322 protected void composeCoverageCostToBeneficiaryComponent(Complex parent, String parentType, String name, Coverage.CostToBeneficiaryComponent element, int index) { 5323 if (element == null) 5324 return; 5325 Complex t; 5326 if (Utilities.noString(parentType)) 5327 t = parent; 5328 else { 5329 t = parent.predicate("fhir:"+parentType+'.'+name); 5330 } 5331 composeBackboneElement(t, "costToBeneficiary", name, element, index); 5332 if (element.hasType()) 5333 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 5334 if (element.hasValue()) 5335 composeType(t, "Coverage", "value", element.getValue(), -1); 5336 for (int i = 0; i < element.getException().size(); i++) 5337 composeCoverageExemptionComponent(t, "Coverage", "exception", element.getException().get(i), i); 5338 } 5339 5340 protected void composeCoverageExemptionComponent(Complex parent, String parentType, String name, Coverage.ExemptionComponent element, int index) { 5341 if (element == null) 5342 return; 5343 Complex t; 5344 if (Utilities.noString(parentType)) 5345 t = parent; 5346 else { 5347 t = parent.predicate("fhir:"+parentType+'.'+name); 5348 } 5349 composeBackboneElement(t, "exception", name, element, index); 5350 if (element.hasType()) 5351 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 5352 if (element.hasPeriod()) 5353 composePeriod(t, "Coverage", "period", element.getPeriod(), -1); 5354 } 5355 5356 protected void composeCoverageEligibilityRequest(Complex parent, String parentType, String name, CoverageEligibilityRequest element, int index) { 5357 if (element == null) 5358 return; 5359 Complex t; 5360 if (Utilities.noString(parentType)) 5361 t = parent; 5362 else { 5363 t = parent.predicate("fhir:"+parentType+'.'+name); 5364 } 5365 composeDomainResource(t, "CoverageEligibilityRequest", name, element, index); 5366 for (int i = 0; i < element.getIdentifier().size(); i++) 5367 composeIdentifier(t, "CoverageEligibilityRequest", "identifier", element.getIdentifier().get(i), i); 5368 if (element.hasStatusElement()) 5369 composeEnum(t, "CoverageEligibilityRequest", "status", element.getStatusElement(), -1); 5370 if (element.hasPriority()) 5371 composeCodeableConcept(t, "CoverageEligibilityRequest", "priority", element.getPriority(), -1); 5372 for (int i = 0; i < element.getPurpose().size(); i++) 5373 composeEnum(t, "CoverageEligibilityRequest", "purpose", element.getPurpose().get(i), i); 5374 if (element.hasPatient()) 5375 composeReference(t, "CoverageEligibilityRequest", "patient", element.getPatient(), -1); 5376 if (element.hasServiced()) 5377 composeType(t, "CoverageEligibilityRequest", "serviced", element.getServiced(), -1); 5378 if (element.hasCreatedElement()) 5379 composeDateTime(t, "CoverageEligibilityRequest", "created", element.getCreatedElement(), -1); 5380 if (element.hasEnterer()) 5381 composeReference(t, "CoverageEligibilityRequest", "enterer", element.getEnterer(), -1); 5382 if (element.hasProvider()) 5383 composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1); 5384 if (element.hasInsurer()) 5385 composeReference(t, "CoverageEligibilityRequest", "insurer", element.getInsurer(), -1); 5386 if (element.hasFacility()) 5387 composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1); 5388 for (int i = 0; i < element.getSupportingInfo().size(); i++) 5389 composeCoverageEligibilityRequestSupportingInformationComponent(t, "CoverageEligibilityRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 5390 for (int i = 0; i < element.getInsurance().size(); i++) 5391 composeCoverageEligibilityRequestInsuranceComponent(t, "CoverageEligibilityRequest", "insurance", element.getInsurance().get(i), i); 5392 for (int i = 0; i < element.getItem().size(); i++) 5393 composeCoverageEligibilityRequestDetailsComponent(t, "CoverageEligibilityRequest", "item", element.getItem().get(i), i); 5394 } 5395 5396 protected void composeCoverageEligibilityRequestSupportingInformationComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.SupportingInformationComponent element, int index) { 5397 if (element == null) 5398 return; 5399 Complex t; 5400 if (Utilities.noString(parentType)) 5401 t = parent; 5402 else { 5403 t = parent.predicate("fhir:"+parentType+'.'+name); 5404 } 5405 composeBackboneElement(t, "supportingInfo", name, element, index); 5406 if (element.hasSequenceElement()) 5407 composePositiveInt(t, "CoverageEligibilityRequest", "sequence", element.getSequenceElement(), -1); 5408 if (element.hasInformation()) 5409 composeReference(t, "CoverageEligibilityRequest", "information", element.getInformation(), -1); 5410 if (element.hasAppliesToAllElement()) 5411 composeBoolean(t, "CoverageEligibilityRequest", "appliesToAll", element.getAppliesToAllElement(), -1); 5412 } 5413 5414 protected void composeCoverageEligibilityRequestInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.InsuranceComponent element, int index) { 5415 if (element == null) 5416 return; 5417 Complex t; 5418 if (Utilities.noString(parentType)) 5419 t = parent; 5420 else { 5421 t = parent.predicate("fhir:"+parentType+'.'+name); 5422 } 5423 composeBackboneElement(t, "insurance", name, element, index); 5424 if (element.hasFocalElement()) 5425 composeBoolean(t, "CoverageEligibilityRequest", "focal", element.getFocalElement(), -1); 5426 if (element.hasCoverage()) 5427 composeReference(t, "CoverageEligibilityRequest", "coverage", element.getCoverage(), -1); 5428 if (element.hasBusinessArrangementElement()) 5429 composeString(t, "CoverageEligibilityRequest", "businessArrangement", element.getBusinessArrangementElement(), -1); 5430 } 5431 5432 protected void composeCoverageEligibilityRequestDetailsComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DetailsComponent element, int index) { 5433 if (element == null) 5434 return; 5435 Complex t; 5436 if (Utilities.noString(parentType)) 5437 t = parent; 5438 else { 5439 t = parent.predicate("fhir:"+parentType+'.'+name); 5440 } 5441 composeBackboneElement(t, "item", name, element, index); 5442 for (int i = 0; i < element.getSupportingInfoSequence().size(); i++) 5443 composePositiveInt(t, "CoverageEligibilityRequest", "supportingInfoSequence", element.getSupportingInfoSequence().get(i), i); 5444 if (element.hasCategory()) 5445 composeCodeableConcept(t, "CoverageEligibilityRequest", "category", element.getCategory(), -1); 5446 if (element.hasProductOrService()) 5447 composeCodeableConcept(t, "CoverageEligibilityRequest", "productOrService", element.getProductOrService(), -1); 5448 for (int i = 0; i < element.getModifier().size(); i++) 5449 composeCodeableConcept(t, "CoverageEligibilityRequest", "modifier", element.getModifier().get(i), i); 5450 if (element.hasProvider()) 5451 composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1); 5452 if (element.hasQuantity()) 5453 composeQuantity(t, "CoverageEligibilityRequest", "quantity", element.getQuantity(), -1); 5454 if (element.hasUnitPrice()) 5455 composeMoney(t, "CoverageEligibilityRequest", "unitPrice", element.getUnitPrice(), -1); 5456 if (element.hasFacility()) 5457 composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1); 5458 for (int i = 0; i < element.getDiagnosis().size(); i++) 5459 composeCoverageEligibilityRequestDiagnosisComponent(t, "CoverageEligibilityRequest", "diagnosis", element.getDiagnosis().get(i), i); 5460 for (int i = 0; i < element.getDetail().size(); i++) 5461 composeReference(t, "CoverageEligibilityRequest", "detail", element.getDetail().get(i), i); 5462 } 5463 5464 protected void composeCoverageEligibilityRequestDiagnosisComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DiagnosisComponent element, int index) { 5465 if (element == null) 5466 return; 5467 Complex t; 5468 if (Utilities.noString(parentType)) 5469 t = parent; 5470 else { 5471 t = parent.predicate("fhir:"+parentType+'.'+name); 5472 } 5473 composeBackboneElement(t, "diagnosis", name, element, index); 5474 if (element.hasDiagnosis()) 5475 composeType(t, "CoverageEligibilityRequest", "diagnosis", element.getDiagnosis(), -1); 5476 } 5477 5478 protected void composeCoverageEligibilityResponse(Complex parent, String parentType, String name, CoverageEligibilityResponse element, int index) { 5479 if (element == null) 5480 return; 5481 Complex t; 5482 if (Utilities.noString(parentType)) 5483 t = parent; 5484 else { 5485 t = parent.predicate("fhir:"+parentType+'.'+name); 5486 } 5487 composeDomainResource(t, "CoverageEligibilityResponse", name, element, index); 5488 for (int i = 0; i < element.getIdentifier().size(); i++) 5489 composeIdentifier(t, "CoverageEligibilityResponse", "identifier", element.getIdentifier().get(i), i); 5490 if (element.hasStatusElement()) 5491 composeEnum(t, "CoverageEligibilityResponse", "status", element.getStatusElement(), -1); 5492 for (int i = 0; i < element.getPurpose().size(); i++) 5493 composeEnum(t, "CoverageEligibilityResponse", "purpose", element.getPurpose().get(i), i); 5494 if (element.hasPatient()) 5495 composeReference(t, "CoverageEligibilityResponse", "patient", element.getPatient(), -1); 5496 if (element.hasServiced()) 5497 composeType(t, "CoverageEligibilityResponse", "serviced", element.getServiced(), -1); 5498 if (element.hasCreatedElement()) 5499 composeDateTime(t, "CoverageEligibilityResponse", "created", element.getCreatedElement(), -1); 5500 if (element.hasRequestor()) 5501 composeReference(t, "CoverageEligibilityResponse", "requestor", element.getRequestor(), -1); 5502 if (element.hasRequest()) 5503 composeReference(t, "CoverageEligibilityResponse", "request", element.getRequest(), -1); 5504 if (element.hasOutcomeElement()) 5505 composeEnum(t, "CoverageEligibilityResponse", "outcome", element.getOutcomeElement(), -1); 5506 if (element.hasDispositionElement()) 5507 composeString(t, "CoverageEligibilityResponse", "disposition", element.getDispositionElement(), -1); 5508 if (element.hasInsurer()) 5509 composeReference(t, "CoverageEligibilityResponse", "insurer", element.getInsurer(), -1); 5510 for (int i = 0; i < element.getInsurance().size(); i++) 5511 composeCoverageEligibilityResponseInsuranceComponent(t, "CoverageEligibilityResponse", "insurance", element.getInsurance().get(i), i); 5512 if (element.hasPreAuthRefElement()) 5513 composeString(t, "CoverageEligibilityResponse", "preAuthRef", element.getPreAuthRefElement(), -1); 5514 if (element.hasForm()) 5515 composeCodeableConcept(t, "CoverageEligibilityResponse", "form", element.getForm(), -1); 5516 for (int i = 0; i < element.getError().size(); i++) 5517 composeCoverageEligibilityResponseErrorsComponent(t, "CoverageEligibilityResponse", "error", element.getError().get(i), i); 5518 } 5519 5520 protected void composeCoverageEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.InsuranceComponent element, int index) { 5521 if (element == null) 5522 return; 5523 Complex t; 5524 if (Utilities.noString(parentType)) 5525 t = parent; 5526 else { 5527 t = parent.predicate("fhir:"+parentType+'.'+name); 5528 } 5529 composeBackboneElement(t, "insurance", name, element, index); 5530 if (element.hasCoverage()) 5531 composeReference(t, "CoverageEligibilityResponse", "coverage", element.getCoverage(), -1); 5532 if (element.hasInforceElement()) 5533 composeBoolean(t, "CoverageEligibilityResponse", "inforce", element.getInforceElement(), -1); 5534 if (element.hasBenefitPeriod()) 5535 composePeriod(t, "CoverageEligibilityResponse", "benefitPeriod", element.getBenefitPeriod(), -1); 5536 for (int i = 0; i < element.getItem().size(); i++) 5537 composeCoverageEligibilityResponseItemsComponent(t, "CoverageEligibilityResponse", "item", element.getItem().get(i), i); 5538 } 5539 5540 protected void composeCoverageEligibilityResponseItemsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ItemsComponent element, int index) { 5541 if (element == null) 5542 return; 5543 Complex t; 5544 if (Utilities.noString(parentType)) 5545 t = parent; 5546 else { 5547 t = parent.predicate("fhir:"+parentType+'.'+name); 5548 } 5549 composeBackboneElement(t, "item", name, element, index); 5550 if (element.hasCategory()) 5551 composeCodeableConcept(t, "CoverageEligibilityResponse", "category", element.getCategory(), -1); 5552 if (element.hasProductOrService()) 5553 composeCodeableConcept(t, "CoverageEligibilityResponse", "productOrService", element.getProductOrService(), -1); 5554 for (int i = 0; i < element.getModifier().size(); i++) 5555 composeCodeableConcept(t, "CoverageEligibilityResponse", "modifier", element.getModifier().get(i), i); 5556 if (element.hasProvider()) 5557 composeReference(t, "CoverageEligibilityResponse", "provider", element.getProvider(), -1); 5558 if (element.hasExcludedElement()) 5559 composeBoolean(t, "CoverageEligibilityResponse", "excluded", element.getExcludedElement(), -1); 5560 if (element.hasNameElement()) 5561 composeString(t, "CoverageEligibilityResponse", "name", element.getNameElement(), -1); 5562 if (element.hasDescriptionElement()) 5563 composeString(t, "CoverageEligibilityResponse", "description", element.getDescriptionElement(), -1); 5564 if (element.hasNetwork()) 5565 composeCodeableConcept(t, "CoverageEligibilityResponse", "network", element.getNetwork(), -1); 5566 if (element.hasUnit()) 5567 composeCodeableConcept(t, "CoverageEligibilityResponse", "unit", element.getUnit(), -1); 5568 if (element.hasTerm()) 5569 composeCodeableConcept(t, "CoverageEligibilityResponse", "term", element.getTerm(), -1); 5570 for (int i = 0; i < element.getBenefit().size(); i++) 5571 composeCoverageEligibilityResponseBenefitComponent(t, "CoverageEligibilityResponse", "benefit", element.getBenefit().get(i), i); 5572 if (element.hasAuthorizationRequiredElement()) 5573 composeBoolean(t, "CoverageEligibilityResponse", "authorizationRequired", element.getAuthorizationRequiredElement(), -1); 5574 for (int i = 0; i < element.getAuthorizationSupporting().size(); i++) 5575 composeCodeableConcept(t, "CoverageEligibilityResponse", "authorizationSupporting", element.getAuthorizationSupporting().get(i), i); 5576 if (element.hasAuthorizationUrlElement()) 5577 composeUri(t, "CoverageEligibilityResponse", "authorizationUrl", element.getAuthorizationUrlElement(), -1); 5578 } 5579 5580 protected void composeCoverageEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.BenefitComponent element, int index) { 5581 if (element == null) 5582 return; 5583 Complex t; 5584 if (Utilities.noString(parentType)) 5585 t = parent; 5586 else { 5587 t = parent.predicate("fhir:"+parentType+'.'+name); 5588 } 5589 composeBackboneElement(t, "benefit", name, element, index); 5590 if (element.hasType()) 5591 composeCodeableConcept(t, "CoverageEligibilityResponse", "type", element.getType(), -1); 5592 if (element.hasAllowed()) 5593 composeType(t, "CoverageEligibilityResponse", "allowed", element.getAllowed(), -1); 5594 if (element.hasUsed()) 5595 composeType(t, "CoverageEligibilityResponse", "used", element.getUsed(), -1); 5596 } 5597 5598 protected void composeCoverageEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ErrorsComponent element, int index) { 5599 if (element == null) 5600 return; 5601 Complex t; 5602 if (Utilities.noString(parentType)) 5603 t = parent; 5604 else { 5605 t = parent.predicate("fhir:"+parentType+'.'+name); 5606 } 5607 composeBackboneElement(t, "error", name, element, index); 5608 if (element.hasCode()) 5609 composeCodeableConcept(t, "CoverageEligibilityResponse", "code", element.getCode(), -1); 5610 } 5611 5612 protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) { 5613 if (element == null) 5614 return; 5615 Complex t; 5616 if (Utilities.noString(parentType)) 5617 t = parent; 5618 else { 5619 t = parent.predicate("fhir:"+parentType+'.'+name); 5620 } 5621 composeDomainResource(t, "DetectedIssue", name, element, index); 5622 for (int i = 0; i < element.getIdentifier().size(); i++) 5623 composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier().get(i), i); 5624 if (element.hasStatusElement()) 5625 composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1); 5626 if (element.hasCode()) 5627 composeCodeableConcept(t, "DetectedIssue", "code", element.getCode(), -1); 5628 if (element.hasSeverityElement()) 5629 composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1); 5630 if (element.hasPatient()) 5631 composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1); 5632 if (element.hasIdentified()) 5633 composeType(t, "DetectedIssue", "identified", element.getIdentified(), -1); 5634 if (element.hasAuthor()) 5635 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 5636 for (int i = 0; i < element.getImplicated().size(); i++) 5637 composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i); 5638 for (int i = 0; i < element.getEvidence().size(); i++) 5639 composeDetectedIssueDetectedIssueEvidenceComponent(t, "DetectedIssue", "evidence", element.getEvidence().get(i), i); 5640 if (element.hasDetailElement()) 5641 composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1); 5642 if (element.hasReferenceElement()) 5643 composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1); 5644 for (int i = 0; i < element.getMitigation().size(); i++) 5645 composeDetectedIssueDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i); 5646 } 5647 5648 protected void composeDetectedIssueDetectedIssueEvidenceComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueEvidenceComponent element, int index) { 5649 if (element == null) 5650 return; 5651 Complex t; 5652 if (Utilities.noString(parentType)) 5653 t = parent; 5654 else { 5655 t = parent.predicate("fhir:"+parentType+'.'+name); 5656 } 5657 composeBackboneElement(t, "evidence", name, element, index); 5658 for (int i = 0; i < element.getCode().size(); i++) 5659 composeCodeableConcept(t, "DetectedIssue", "code", element.getCode().get(i), i); 5660 for (int i = 0; i < element.getDetail().size(); i++) 5661 composeReference(t, "DetectedIssue", "detail", element.getDetail().get(i), i); 5662 } 5663 5664 protected void composeDetectedIssueDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) { 5665 if (element == null) 5666 return; 5667 Complex t; 5668 if (Utilities.noString(parentType)) 5669 t = parent; 5670 else { 5671 t = parent.predicate("fhir:"+parentType+'.'+name); 5672 } 5673 composeBackboneElement(t, "mitigation", name, element, index); 5674 if (element.hasAction()) 5675 composeCodeableConcept(t, "DetectedIssue", "action", element.getAction(), -1); 5676 if (element.hasDateElement()) 5677 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 5678 if (element.hasAuthor()) 5679 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 5680 } 5681 5682 protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) { 5683 if (element == null) 5684 return; 5685 Complex t; 5686 if (Utilities.noString(parentType)) 5687 t = parent; 5688 else { 5689 t = parent.predicate("fhir:"+parentType+'.'+name); 5690 } 5691 composeDomainResource(t, "Device", name, element, index); 5692 for (int i = 0; i < element.getIdentifier().size(); i++) 5693 composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i); 5694 if (element.hasDefinition()) 5695 composeReference(t, "Device", "definition", element.getDefinition(), -1); 5696 for (int i = 0; i < element.getUdiCarrier().size(); i++) 5697 composeDeviceDeviceUdiCarrierComponent(t, "Device", "udiCarrier", element.getUdiCarrier().get(i), i); 5698 if (element.hasStatusElement()) 5699 composeEnum(t, "Device", "status", element.getStatusElement(), -1); 5700 for (int i = 0; i < element.getStatusReason().size(); i++) 5701 composeCodeableConcept(t, "Device", "statusReason", element.getStatusReason().get(i), i); 5702 if (element.hasDistinctIdentifierElement()) 5703 composeString(t, "Device", "distinctIdentifier", element.getDistinctIdentifierElement(), -1); 5704 if (element.hasManufacturerElement()) 5705 composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1); 5706 if (element.hasManufactureDateElement()) 5707 composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1); 5708 if (element.hasExpirationDateElement()) 5709 composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1); 5710 if (element.hasLotNumberElement()) 5711 composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1); 5712 if (element.hasSerialNumberElement()) 5713 composeString(t, "Device", "serialNumber", element.getSerialNumberElement(), -1); 5714 for (int i = 0; i < element.getDeviceName().size(); i++) 5715 composeDeviceDeviceDeviceNameComponent(t, "Device", "deviceName", element.getDeviceName().get(i), i); 5716 if (element.hasModelNumberElement()) 5717 composeString(t, "Device", "modelNumber", element.getModelNumberElement(), -1); 5718 if (element.hasPartNumberElement()) 5719 composeString(t, "Device", "partNumber", element.getPartNumberElement(), -1); 5720 if (element.hasType()) 5721 composeCodeableConcept(t, "Device", "type", element.getType(), -1); 5722 for (int i = 0; i < element.getSpecialization().size(); i++) 5723 composeDeviceDeviceSpecializationComponent(t, "Device", "specialization", element.getSpecialization().get(i), i); 5724 for (int i = 0; i < element.getVersion().size(); i++) 5725 composeDeviceDeviceVersionComponent(t, "Device", "version", element.getVersion().get(i), i); 5726 for (int i = 0; i < element.getProperty().size(); i++) 5727 composeDeviceDevicePropertyComponent(t, "Device", "property", element.getProperty().get(i), i); 5728 if (element.hasPatient()) 5729 composeReference(t, "Device", "patient", element.getPatient(), -1); 5730 if (element.hasOwner()) 5731 composeReference(t, "Device", "owner", element.getOwner(), -1); 5732 for (int i = 0; i < element.getContact().size(); i++) 5733 composeContactPoint(t, "Device", "contact", element.getContact().get(i), i); 5734 if (element.hasLocation()) 5735 composeReference(t, "Device", "location", element.getLocation(), -1); 5736 if (element.hasUrlElement()) 5737 composeUri(t, "Device", "url", element.getUrlElement(), -1); 5738 for (int i = 0; i < element.getNote().size(); i++) 5739 composeAnnotation(t, "Device", "note", element.getNote().get(i), i); 5740 for (int i = 0; i < element.getSafety().size(); i++) 5741 composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i); 5742 if (element.hasParent()) 5743 composeReference(t, "Device", "parent", element.getParent(), -1); 5744 } 5745 5746 protected void composeDeviceDeviceUdiCarrierComponent(Complex parent, String parentType, String name, Device.DeviceUdiCarrierComponent element, int index) { 5747 if (element == null) 5748 return; 5749 Complex t; 5750 if (Utilities.noString(parentType)) 5751 t = parent; 5752 else { 5753 t = parent.predicate("fhir:"+parentType+'.'+name); 5754 } 5755 composeBackboneElement(t, "udiCarrier", name, element, index); 5756 if (element.hasDeviceIdentifierElement()) 5757 composeString(t, "Device", "deviceIdentifier", element.getDeviceIdentifierElement(), -1); 5758 if (element.hasIssuerElement()) 5759 composeUri(t, "Device", "issuer", element.getIssuerElement(), -1); 5760 if (element.hasJurisdictionElement()) 5761 composeUri(t, "Device", "jurisdiction", element.getJurisdictionElement(), -1); 5762 if (element.hasCarrierAIDCElement()) 5763 composeBase64Binary(t, "Device", "carrierAIDC", element.getCarrierAIDCElement(), -1); 5764 if (element.hasCarrierHRFElement()) 5765 composeString(t, "Device", "carrierHRF", element.getCarrierHRFElement(), -1); 5766 if (element.hasEntryTypeElement()) 5767 composeEnum(t, "Device", "entryType", element.getEntryTypeElement(), -1); 5768 } 5769 5770 protected void composeDeviceDeviceDeviceNameComponent(Complex parent, String parentType, String name, Device.DeviceDeviceNameComponent element, int index) { 5771 if (element == null) 5772 return; 5773 Complex t; 5774 if (Utilities.noString(parentType)) 5775 t = parent; 5776 else { 5777 t = parent.predicate("fhir:"+parentType+'.'+name); 5778 } 5779 composeBackboneElement(t, "deviceName", name, element, index); 5780 if (element.hasNameElement()) 5781 composeString(t, "Device", "name", element.getNameElement(), -1); 5782 if (element.hasTypeElement()) 5783 composeEnum(t, "Device", "type", element.getTypeElement(), -1); 5784 } 5785 5786 protected void composeDeviceDeviceSpecializationComponent(Complex parent, String parentType, String name, Device.DeviceSpecializationComponent element, int index) { 5787 if (element == null) 5788 return; 5789 Complex t; 5790 if (Utilities.noString(parentType)) 5791 t = parent; 5792 else { 5793 t = parent.predicate("fhir:"+parentType+'.'+name); 5794 } 5795 composeBackboneElement(t, "specialization", name, element, index); 5796 if (element.hasSystemType()) 5797 composeCodeableConcept(t, "Device", "systemType", element.getSystemType(), -1); 5798 if (element.hasVersionElement()) 5799 composeString(t, "Device", "version", element.getVersionElement(), -1); 5800 } 5801 5802 protected void composeDeviceDeviceVersionComponent(Complex parent, String parentType, String name, Device.DeviceVersionComponent element, int index) { 5803 if (element == null) 5804 return; 5805 Complex t; 5806 if (Utilities.noString(parentType)) 5807 t = parent; 5808 else { 5809 t = parent.predicate("fhir:"+parentType+'.'+name); 5810 } 5811 composeBackboneElement(t, "version", name, element, index); 5812 if (element.hasType()) 5813 composeCodeableConcept(t, "Device", "type", element.getType(), -1); 5814 if (element.hasComponent()) 5815 composeIdentifier(t, "Device", "component", element.getComponent(), -1); 5816 if (element.hasValueElement()) 5817 composeString(t, "Device", "value", element.getValueElement(), -1); 5818 } 5819 5820 protected void composeDeviceDevicePropertyComponent(Complex parent, String parentType, String name, Device.DevicePropertyComponent element, int index) { 5821 if (element == null) 5822 return; 5823 Complex t; 5824 if (Utilities.noString(parentType)) 5825 t = parent; 5826 else { 5827 t = parent.predicate("fhir:"+parentType+'.'+name); 5828 } 5829 composeBackboneElement(t, "property", name, element, index); 5830 if (element.hasType()) 5831 composeCodeableConcept(t, "Device", "type", element.getType(), -1); 5832 for (int i = 0; i < element.getValueQuantity().size(); i++) 5833 composeQuantity(t, "Device", "valueQuantity", element.getValueQuantity().get(i), i); 5834 for (int i = 0; i < element.getValueCode().size(); i++) 5835 composeCodeableConcept(t, "Device", "valueCode", element.getValueCode().get(i), i); 5836 } 5837 5838 protected void composeDeviceDefinition(Complex parent, String parentType, String name, DeviceDefinition element, int index) { 5839 if (element == null) 5840 return; 5841 Complex t; 5842 if (Utilities.noString(parentType)) 5843 t = parent; 5844 else { 5845 t = parent.predicate("fhir:"+parentType+'.'+name); 5846 } 5847 composeDomainResource(t, "DeviceDefinition", name, element, index); 5848 for (int i = 0; i < element.getIdentifier().size(); i++) 5849 composeIdentifier(t, "DeviceDefinition", "identifier", element.getIdentifier().get(i), i); 5850 for (int i = 0; i < element.getUdiDeviceIdentifier().size(); i++) 5851 composeDeviceDefinitionDeviceDefinitionUdiDeviceIdentifierComponent(t, "DeviceDefinition", "udiDeviceIdentifier", element.getUdiDeviceIdentifier().get(i), i); 5852 if (element.hasManufacturer()) 5853 composeType(t, "DeviceDefinition", "manufacturer", element.getManufacturer(), -1); 5854 for (int i = 0; i < element.getDeviceName().size(); i++) 5855 composeDeviceDefinitionDeviceDefinitionDeviceNameComponent(t, "DeviceDefinition", "deviceName", element.getDeviceName().get(i), i); 5856 if (element.hasModelNumberElement()) 5857 composeString(t, "DeviceDefinition", "modelNumber", element.getModelNumberElement(), -1); 5858 if (element.hasType()) 5859 composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1); 5860 for (int i = 0; i < element.getSpecialization().size(); i++) 5861 composeDeviceDefinitionDeviceDefinitionSpecializationComponent(t, "DeviceDefinition", "specialization", element.getSpecialization().get(i), i); 5862 for (int i = 0; i < element.getVersion().size(); i++) 5863 composeString(t, "DeviceDefinition", "version", element.getVersion().get(i), i); 5864 for (int i = 0; i < element.getSafety().size(); i++) 5865 composeCodeableConcept(t, "DeviceDefinition", "safety", element.getSafety().get(i), i); 5866 for (int i = 0; i < element.getShelfLifeStorage().size(); i++) 5867 composeProductShelfLife(t, "DeviceDefinition", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i); 5868 if (element.hasPhysicalCharacteristics()) 5869 composeProdCharacteristic(t, "DeviceDefinition", "physicalCharacteristics", element.getPhysicalCharacteristics(), -1); 5870 for (int i = 0; i < element.getLanguageCode().size(); i++) 5871 composeCodeableConcept(t, "DeviceDefinition", "languageCode", element.getLanguageCode().get(i), i); 5872 for (int i = 0; i < element.getCapability().size(); i++) 5873 composeDeviceDefinitionDeviceDefinitionCapabilityComponent(t, "DeviceDefinition", "capability", element.getCapability().get(i), i); 5874 for (int i = 0; i < element.getProperty().size(); i++) 5875 composeDeviceDefinitionDeviceDefinitionPropertyComponent(t, "DeviceDefinition", "property", element.getProperty().get(i), i); 5876 if (element.hasOwner()) 5877 composeReference(t, "DeviceDefinition", "owner", element.getOwner(), -1); 5878 for (int i = 0; i < element.getContact().size(); i++) 5879 composeContactPoint(t, "DeviceDefinition", "contact", element.getContact().get(i), i); 5880 if (element.hasUrlElement()) 5881 composeUri(t, "DeviceDefinition", "url", element.getUrlElement(), -1); 5882 if (element.hasOnlineInformationElement()) 5883 composeUri(t, "DeviceDefinition", "onlineInformation", element.getOnlineInformationElement(), -1); 5884 for (int i = 0; i < element.getNote().size(); i++) 5885 composeAnnotation(t, "DeviceDefinition", "note", element.getNote().get(i), i); 5886 if (element.hasQuantity()) 5887 composeQuantity(t, "DeviceDefinition", "quantity", element.getQuantity(), -1); 5888 if (element.hasParentDevice()) 5889 composeReference(t, "DeviceDefinition", "parentDevice", element.getParentDevice(), -1); 5890 for (int i = 0; i < element.getMaterial().size(); i++) 5891 composeDeviceDefinitionDeviceDefinitionMaterialComponent(t, "DeviceDefinition", "material", element.getMaterial().get(i), i); 5892 } 5893 5894 protected void composeDeviceDefinitionDeviceDefinitionUdiDeviceIdentifierComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionUdiDeviceIdentifierComponent element, int index) { 5895 if (element == null) 5896 return; 5897 Complex t; 5898 if (Utilities.noString(parentType)) 5899 t = parent; 5900 else { 5901 t = parent.predicate("fhir:"+parentType+'.'+name); 5902 } 5903 composeBackboneElement(t, "udiDeviceIdentifier", name, element, index); 5904 if (element.hasDeviceIdentifierElement()) 5905 composeString(t, "DeviceDefinition", "deviceIdentifier", element.getDeviceIdentifierElement(), -1); 5906 if (element.hasIssuerElement()) 5907 composeUri(t, "DeviceDefinition", "issuer", element.getIssuerElement(), -1); 5908 if (element.hasJurisdictionElement()) 5909 composeUri(t, "DeviceDefinition", "jurisdiction", element.getJurisdictionElement(), -1); 5910 } 5911 5912 protected void composeDeviceDefinitionDeviceDefinitionDeviceNameComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionDeviceNameComponent element, int index) { 5913 if (element == null) 5914 return; 5915 Complex t; 5916 if (Utilities.noString(parentType)) 5917 t = parent; 5918 else { 5919 t = parent.predicate("fhir:"+parentType+'.'+name); 5920 } 5921 composeBackboneElement(t, "deviceName", name, element, index); 5922 if (element.hasNameElement()) 5923 composeString(t, "DeviceDefinition", "name", element.getNameElement(), -1); 5924 if (element.hasTypeElement()) 5925 composeEnum(t, "DeviceDefinition", "type", element.getTypeElement(), -1); 5926 } 5927 5928 protected void composeDeviceDefinitionDeviceDefinitionSpecializationComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionSpecializationComponent element, int index) { 5929 if (element == null) 5930 return; 5931 Complex t; 5932 if (Utilities.noString(parentType)) 5933 t = parent; 5934 else { 5935 t = parent.predicate("fhir:"+parentType+'.'+name); 5936 } 5937 composeBackboneElement(t, "specialization", name, element, index); 5938 if (element.hasSystemTypeElement()) 5939 composeString(t, "DeviceDefinition", "systemType", element.getSystemTypeElement(), -1); 5940 if (element.hasVersionElement()) 5941 composeString(t, "DeviceDefinition", "version", element.getVersionElement(), -1); 5942 } 5943 5944 protected void composeDeviceDefinitionDeviceDefinitionCapabilityComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionCapabilityComponent element, int index) { 5945 if (element == null) 5946 return; 5947 Complex t; 5948 if (Utilities.noString(parentType)) 5949 t = parent; 5950 else { 5951 t = parent.predicate("fhir:"+parentType+'.'+name); 5952 } 5953 composeBackboneElement(t, "capability", name, element, index); 5954 if (element.hasType()) 5955 composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1); 5956 for (int i = 0; i < element.getDescription().size(); i++) 5957 composeCodeableConcept(t, "DeviceDefinition", "description", element.getDescription().get(i), i); 5958 } 5959 5960 protected void composeDeviceDefinitionDeviceDefinitionPropertyComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionPropertyComponent element, int index) { 5961 if (element == null) 5962 return; 5963 Complex t; 5964 if (Utilities.noString(parentType)) 5965 t = parent; 5966 else { 5967 t = parent.predicate("fhir:"+parentType+'.'+name); 5968 } 5969 composeBackboneElement(t, "property", name, element, index); 5970 if (element.hasType()) 5971 composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1); 5972 for (int i = 0; i < element.getValueQuantity().size(); i++) 5973 composeQuantity(t, "DeviceDefinition", "valueQuantity", element.getValueQuantity().get(i), i); 5974 for (int i = 0; i < element.getValueCode().size(); i++) 5975 composeCodeableConcept(t, "DeviceDefinition", "valueCode", element.getValueCode().get(i), i); 5976 } 5977 5978 protected void composeDeviceDefinitionDeviceDefinitionMaterialComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionMaterialComponent element, int index) { 5979 if (element == null) 5980 return; 5981 Complex t; 5982 if (Utilities.noString(parentType)) 5983 t = parent; 5984 else { 5985 t = parent.predicate("fhir:"+parentType+'.'+name); 5986 } 5987 composeBackboneElement(t, "material", name, element, index); 5988 if (element.hasSubstance()) 5989 composeCodeableConcept(t, "DeviceDefinition", "substance", element.getSubstance(), -1); 5990 if (element.hasAlternateElement()) 5991 composeBoolean(t, "DeviceDefinition", "alternate", element.getAlternateElement(), -1); 5992 if (element.hasAllergenicIndicatorElement()) 5993 composeBoolean(t, "DeviceDefinition", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1); 5994 } 5995 5996 protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) { 5997 if (element == null) 5998 return; 5999 Complex t; 6000 if (Utilities.noString(parentType)) 6001 t = parent; 6002 else { 6003 t = parent.predicate("fhir:"+parentType+'.'+name); 6004 } 6005 composeDomainResource(t, "DeviceMetric", name, element, index); 6006 for (int i = 0; i < element.getIdentifier().size(); i++) 6007 composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier().get(i), i); 6008 if (element.hasType()) 6009 composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1); 6010 if (element.hasUnit()) 6011 composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1); 6012 if (element.hasSource()) 6013 composeReference(t, "DeviceMetric", "source", element.getSource(), -1); 6014 if (element.hasParent()) 6015 composeReference(t, "DeviceMetric", "parent", element.getParent(), -1); 6016 if (element.hasOperationalStatusElement()) 6017 composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1); 6018 if (element.hasColorElement()) 6019 composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1); 6020 if (element.hasCategoryElement()) 6021 composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1); 6022 if (element.hasMeasurementPeriod()) 6023 composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1); 6024 for (int i = 0; i < element.getCalibration().size(); i++) 6025 composeDeviceMetricDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i); 6026 } 6027 6028 protected void composeDeviceMetricDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) { 6029 if (element == null) 6030 return; 6031 Complex t; 6032 if (Utilities.noString(parentType)) 6033 t = parent; 6034 else { 6035 t = parent.predicate("fhir:"+parentType+'.'+name); 6036 } 6037 composeBackboneElement(t, "calibration", name, element, index); 6038 if (element.hasTypeElement()) 6039 composeEnum(t, "DeviceMetric", "type", element.getTypeElement(), -1); 6040 if (element.hasStateElement()) 6041 composeEnum(t, "DeviceMetric", "state", element.getStateElement(), -1); 6042 if (element.hasTimeElement()) 6043 composeInstant(t, "DeviceMetric", "time", element.getTimeElement(), -1); 6044 } 6045 6046 protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest element, int index) { 6047 if (element == null) 6048 return; 6049 Complex t; 6050 if (Utilities.noString(parentType)) 6051 t = parent; 6052 else { 6053 t = parent.predicate("fhir:"+parentType+'.'+name); 6054 } 6055 composeDomainResource(t, "DeviceRequest", name, element, index); 6056 for (int i = 0; i < element.getIdentifier().size(); i++) 6057 composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i); 6058 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 6059 composeCanonical(t, "DeviceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 6060 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 6061 composeUri(t, "DeviceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i); 6062 for (int i = 0; i < element.getBasedOn().size(); i++) 6063 composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i); 6064 for (int i = 0; i < element.getPriorRequest().size(); i++) 6065 composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i); 6066 if (element.hasGroupIdentifier()) 6067 composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 6068 if (element.hasStatusElement()) 6069 composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1); 6070 if (element.hasIntentElement()) 6071 composeEnum(t, "DeviceRequest", "intent", element.getIntentElement(), -1); 6072 if (element.hasPriorityElement()) 6073 composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1); 6074 if (element.hasCode()) 6075 composeType(t, "DeviceRequest", "code", element.getCode(), -1); 6076 for (int i = 0; i < element.getParameter().size(); i++) 6077 composeDeviceRequestDeviceRequestParameterComponent(t, "DeviceRequest", "parameter", element.getParameter().get(i), i); 6078 if (element.hasSubject()) 6079 composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1); 6080 if (element.hasEncounter()) 6081 composeReference(t, "DeviceRequest", "encounter", element.getEncounter(), -1); 6082 if (element.hasOccurrence()) 6083 composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1); 6084 if (element.hasAuthoredOnElement()) 6085 composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1); 6086 if (element.hasRequester()) 6087 composeReference(t, "DeviceRequest", "requester", element.getRequester(), -1); 6088 if (element.hasPerformerType()) 6089 composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1); 6090 if (element.hasPerformer()) 6091 composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1); 6092 for (int i = 0; i < element.getReasonCode().size(); i++) 6093 composeCodeableConcept(t, "DeviceRequest", "reasonCode", element.getReasonCode().get(i), i); 6094 for (int i = 0; i < element.getReasonReference().size(); i++) 6095 composeReference(t, "DeviceRequest", "reasonReference", element.getReasonReference().get(i), i); 6096 for (int i = 0; i < element.getInsurance().size(); i++) 6097 composeReference(t, "DeviceRequest", "insurance", element.getInsurance().get(i), i); 6098 for (int i = 0; i < element.getSupportingInfo().size(); i++) 6099 composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 6100 for (int i = 0; i < element.getNote().size(); i++) 6101 composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i); 6102 for (int i = 0; i < element.getRelevantHistory().size(); i++) 6103 composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 6104 } 6105 6106 protected void composeDeviceRequestDeviceRequestParameterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestParameterComponent element, int index) { 6107 if (element == null) 6108 return; 6109 Complex t; 6110 if (Utilities.noString(parentType)) 6111 t = parent; 6112 else { 6113 t = parent.predicate("fhir:"+parentType+'.'+name); 6114 } 6115 composeBackboneElement(t, "parameter", name, element, index); 6116 if (element.hasCode()) 6117 composeCodeableConcept(t, "DeviceRequest", "code", element.getCode(), -1); 6118 if (element.hasValue()) 6119 composeType(t, "DeviceRequest", "value", element.getValue(), -1); 6120 } 6121 6122 protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) { 6123 if (element == null) 6124 return; 6125 Complex t; 6126 if (Utilities.noString(parentType)) 6127 t = parent; 6128 else { 6129 t = parent.predicate("fhir:"+parentType+'.'+name); 6130 } 6131 composeDomainResource(t, "DeviceUseStatement", name, element, index); 6132 for (int i = 0; i < element.getIdentifier().size(); i++) 6133 composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i); 6134 for (int i = 0; i < element.getBasedOn().size(); i++) 6135 composeReference(t, "DeviceUseStatement", "basedOn", element.getBasedOn().get(i), i); 6136 if (element.hasStatusElement()) 6137 composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1); 6138 if (element.hasSubject()) 6139 composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1); 6140 for (int i = 0; i < element.getDerivedFrom().size(); i++) 6141 composeReference(t, "DeviceUseStatement", "derivedFrom", element.getDerivedFrom().get(i), i); 6142 if (element.hasTiming()) 6143 composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1); 6144 if (element.hasRecordedOnElement()) 6145 composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1); 6146 if (element.hasSource()) 6147 composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1); 6148 if (element.hasDevice()) 6149 composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1); 6150 for (int i = 0; i < element.getReasonCode().size(); i++) 6151 composeCodeableConcept(t, "DeviceUseStatement", "reasonCode", element.getReasonCode().get(i), i); 6152 for (int i = 0; i < element.getReasonReference().size(); i++) 6153 composeReference(t, "DeviceUseStatement", "reasonReference", element.getReasonReference().get(i), i); 6154 if (element.hasBodySite()) 6155 composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1); 6156 for (int i = 0; i < element.getNote().size(); i++) 6157 composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i); 6158 } 6159 6160 protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) { 6161 if (element == null) 6162 return; 6163 Complex t; 6164 if (Utilities.noString(parentType)) 6165 t = parent; 6166 else { 6167 t = parent.predicate("fhir:"+parentType+'.'+name); 6168 } 6169 composeDomainResource(t, "DiagnosticReport", name, element, index); 6170 for (int i = 0; i < element.getIdentifier().size(); i++) 6171 composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i); 6172 for (int i = 0; i < element.getBasedOn().size(); i++) 6173 composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i); 6174 if (element.hasStatusElement()) 6175 composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1); 6176 for (int i = 0; i < element.getCategory().size(); i++) 6177 composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory().get(i), i); 6178 if (element.hasCode()) 6179 composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1); 6180 if (element.hasSubject()) 6181 composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1); 6182 if (element.hasEncounter()) 6183 composeReference(t, "DiagnosticReport", "encounter", element.getEncounter(), -1); 6184 if (element.hasEffective()) 6185 composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1); 6186 if (element.hasIssuedElement()) 6187 composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1); 6188 for (int i = 0; i < element.getPerformer().size(); i++) 6189 composeReference(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i); 6190 for (int i = 0; i < element.getResultsInterpreter().size(); i++) 6191 composeReference(t, "DiagnosticReport", "resultsInterpreter", element.getResultsInterpreter().get(i), i); 6192 for (int i = 0; i < element.getSpecimen().size(); i++) 6193 composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i); 6194 for (int i = 0; i < element.getResult().size(); i++) 6195 composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i); 6196 for (int i = 0; i < element.getImagingStudy().size(); i++) 6197 composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i); 6198 for (int i = 0; i < element.getMedia().size(); i++) 6199 composeDiagnosticReportDiagnosticReportMediaComponent(t, "DiagnosticReport", "media", element.getMedia().get(i), i); 6200 if (element.hasConclusionElement()) 6201 composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1); 6202 for (int i = 0; i < element.getConclusionCode().size(); i++) 6203 composeCodeableConcept(t, "DiagnosticReport", "conclusionCode", element.getConclusionCode().get(i), i); 6204 for (int i = 0; i < element.getPresentedForm().size(); i++) 6205 composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i); 6206 } 6207 6208 protected void composeDiagnosticReportDiagnosticReportMediaComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportMediaComponent element, int index) { 6209 if (element == null) 6210 return; 6211 Complex t; 6212 if (Utilities.noString(parentType)) 6213 t = parent; 6214 else { 6215 t = parent.predicate("fhir:"+parentType+'.'+name); 6216 } 6217 composeBackboneElement(t, "media", name, element, index); 6218 if (element.hasCommentElement()) 6219 composeString(t, "DiagnosticReport", "comment", element.getCommentElement(), -1); 6220 if (element.hasLink()) 6221 composeReference(t, "DiagnosticReport", "link", element.getLink(), -1); 6222 } 6223 6224 protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) { 6225 if (element == null) 6226 return; 6227 Complex t; 6228 if (Utilities.noString(parentType)) 6229 t = parent; 6230 else { 6231 t = parent.predicate("fhir:"+parentType+'.'+name); 6232 } 6233 composeDomainResource(t, "DocumentManifest", name, element, index); 6234 if (element.hasMasterIdentifier()) 6235 composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1); 6236 for (int i = 0; i < element.getIdentifier().size(); i++) 6237 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i); 6238 if (element.hasStatusElement()) 6239 composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1); 6240 if (element.hasType()) 6241 composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1); 6242 if (element.hasSubject()) 6243 composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1); 6244 if (element.hasCreatedElement()) 6245 composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1); 6246 for (int i = 0; i < element.getAuthor().size(); i++) 6247 composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i); 6248 for (int i = 0; i < element.getRecipient().size(); i++) 6249 composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i); 6250 if (element.hasSourceElement()) 6251 composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1); 6252 if (element.hasDescriptionElement()) 6253 composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1); 6254 for (int i = 0; i < element.getContent().size(); i++) 6255 composeReference(t, "DocumentManifest", "content", element.getContent().get(i), i); 6256 for (int i = 0; i < element.getRelated().size(); i++) 6257 composeDocumentManifestDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i); 6258 } 6259 6260 protected void composeDocumentManifestDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) { 6261 if (element == null) 6262 return; 6263 Complex t; 6264 if (Utilities.noString(parentType)) 6265 t = parent; 6266 else { 6267 t = parent.predicate("fhir:"+parentType+'.'+name); 6268 } 6269 composeBackboneElement(t, "related", name, element, index); 6270 if (element.hasIdentifier()) 6271 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier(), -1); 6272 if (element.hasRef()) 6273 composeReference(t, "DocumentManifest", "ref", element.getRef(), -1); 6274 } 6275 6276 protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) { 6277 if (element == null) 6278 return; 6279 Complex t; 6280 if (Utilities.noString(parentType)) 6281 t = parent; 6282 else { 6283 t = parent.predicate("fhir:"+parentType+'.'+name); 6284 } 6285 composeDomainResource(t, "DocumentReference", name, element, index); 6286 if (element.hasMasterIdentifier()) 6287 composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1); 6288 for (int i = 0; i < element.getIdentifier().size(); i++) 6289 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i); 6290 if (element.hasStatusElement()) 6291 composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1); 6292 if (element.hasDocStatusElement()) 6293 composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1); 6294 if (element.hasType()) 6295 composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1); 6296 for (int i = 0; i < element.getCategory().size(); i++) 6297 composeCodeableConcept(t, "DocumentReference", "category", element.getCategory().get(i), i); 6298 if (element.hasSubject()) 6299 composeReference(t, "DocumentReference", "subject", element.getSubject(), -1); 6300 if (element.hasDateElement()) 6301 composeInstant(t, "DocumentReference", "date", element.getDateElement(), -1); 6302 for (int i = 0; i < element.getAuthor().size(); i++) 6303 composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i); 6304 if (element.hasAuthenticator()) 6305 composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1); 6306 if (element.hasCustodian()) 6307 composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1); 6308 for (int i = 0; i < element.getRelatesTo().size(); i++) 6309 composeDocumentReferenceDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i); 6310 if (element.hasDescriptionElement()) 6311 composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1); 6312 for (int i = 0; i < element.getSecurityLabel().size(); i++) 6313 composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i); 6314 for (int i = 0; i < element.getContent().size(); i++) 6315 composeDocumentReferenceDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i); 6316 if (element.hasContext()) 6317 composeDocumentReferenceDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1); 6318 } 6319 6320 protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) { 6321 if (element == null) 6322 return; 6323 Complex t; 6324 if (Utilities.noString(parentType)) 6325 t = parent; 6326 else { 6327 t = parent.predicate("fhir:"+parentType+'.'+name); 6328 } 6329 composeBackboneElement(t, "relatesTo", name, element, index); 6330 if (element.hasCodeElement()) 6331 composeEnum(t, "DocumentReference", "code", element.getCodeElement(), -1); 6332 if (element.hasTarget()) 6333 composeReference(t, "DocumentReference", "target", element.getTarget(), -1); 6334 } 6335 6336 protected void composeDocumentReferenceDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) { 6337 if (element == null) 6338 return; 6339 Complex t; 6340 if (Utilities.noString(parentType)) 6341 t = parent; 6342 else { 6343 t = parent.predicate("fhir:"+parentType+'.'+name); 6344 } 6345 composeBackboneElement(t, "content", name, element, index); 6346 if (element.hasAttachment()) 6347 composeAttachment(t, "DocumentReference", "attachment", element.getAttachment(), -1); 6348 if (element.hasFormat()) 6349 composeCoding(t, "DocumentReference", "format", element.getFormat(), -1); 6350 } 6351 6352 protected void composeDocumentReferenceDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) { 6353 if (element == null) 6354 return; 6355 Complex t; 6356 if (Utilities.noString(parentType)) 6357 t = parent; 6358 else { 6359 t = parent.predicate("fhir:"+parentType+'.'+name); 6360 } 6361 composeBackboneElement(t, "context", name, element, index); 6362 for (int i = 0; i < element.getEncounter().size(); i++) 6363 composeReference(t, "DocumentReference", "encounter", element.getEncounter().get(i), i); 6364 for (int i = 0; i < element.getEvent().size(); i++) 6365 composeCodeableConcept(t, "DocumentReference", "event", element.getEvent().get(i), i); 6366 if (element.hasPeriod()) 6367 composePeriod(t, "DocumentReference", "period", element.getPeriod(), -1); 6368 if (element.hasFacilityType()) 6369 composeCodeableConcept(t, "DocumentReference", "facilityType", element.getFacilityType(), -1); 6370 if (element.hasPracticeSetting()) 6371 composeCodeableConcept(t, "DocumentReference", "practiceSetting", element.getPracticeSetting(), -1); 6372 if (element.hasSourcePatientInfo()) 6373 composeReference(t, "DocumentReference", "sourcePatientInfo", element.getSourcePatientInfo(), -1); 6374 for (int i = 0; i < element.getRelated().size(); i++) 6375 composeReference(t, "DocumentReference", "related", element.getRelated().get(i), i); 6376 } 6377 6378 protected void composeEffectEvidenceSynthesis(Complex parent, String parentType, String name, EffectEvidenceSynthesis element, int index) { 6379 if (element == null) 6380 return; 6381 Complex t; 6382 if (Utilities.noString(parentType)) 6383 t = parent; 6384 else { 6385 t = parent.predicate("fhir:"+parentType+'.'+name); 6386 } 6387 composeDomainResource(t, "EffectEvidenceSynthesis", name, element, index); 6388 if (element.hasUrlElement()) 6389 composeUri(t, "EffectEvidenceSynthesis", "url", element.getUrlElement(), -1); 6390 for (int i = 0; i < element.getIdentifier().size(); i++) 6391 composeIdentifier(t, "EffectEvidenceSynthesis", "identifier", element.getIdentifier().get(i), i); 6392 if (element.hasVersionElement()) 6393 composeString(t, "EffectEvidenceSynthesis", "version", element.getVersionElement(), -1); 6394 if (element.hasNameElement()) 6395 composeString(t, "EffectEvidenceSynthesis", "name", element.getNameElement(), -1); 6396 if (element.hasTitleElement()) 6397 composeString(t, "EffectEvidenceSynthesis", "title", element.getTitleElement(), -1); 6398 if (element.hasStatusElement()) 6399 composeEnum(t, "EffectEvidenceSynthesis", "status", element.getStatusElement(), -1); 6400 if (element.hasDateElement()) 6401 composeDateTime(t, "EffectEvidenceSynthesis", "date", element.getDateElement(), -1); 6402 if (element.hasPublisherElement()) 6403 composeString(t, "EffectEvidenceSynthesis", "publisher", element.getPublisherElement(), -1); 6404 for (int i = 0; i < element.getContact().size(); i++) 6405 composeContactDetail(t, "EffectEvidenceSynthesis", "contact", element.getContact().get(i), i); 6406 if (element.hasDescriptionElement()) 6407 composeMarkdown(t, "EffectEvidenceSynthesis", "description", element.getDescriptionElement(), -1); 6408 for (int i = 0; i < element.getNote().size(); i++) 6409 composeAnnotation(t, "EffectEvidenceSynthesis", "note", element.getNote().get(i), i); 6410 for (int i = 0; i < element.getUseContext().size(); i++) 6411 composeUsageContext(t, "EffectEvidenceSynthesis", "useContext", element.getUseContext().get(i), i); 6412 for (int i = 0; i < element.getJurisdiction().size(); i++) 6413 composeCodeableConcept(t, "EffectEvidenceSynthesis", "jurisdiction", element.getJurisdiction().get(i), i); 6414 if (element.hasCopyrightElement()) 6415 composeMarkdown(t, "EffectEvidenceSynthesis", "copyright", element.getCopyrightElement(), -1); 6416 if (element.hasApprovalDateElement()) 6417 composeDate(t, "EffectEvidenceSynthesis", "approvalDate", element.getApprovalDateElement(), -1); 6418 if (element.hasLastReviewDateElement()) 6419 composeDate(t, "EffectEvidenceSynthesis", "lastReviewDate", element.getLastReviewDateElement(), -1); 6420 if (element.hasEffectivePeriod()) 6421 composePeriod(t, "EffectEvidenceSynthesis", "effectivePeriod", element.getEffectivePeriod(), -1); 6422 for (int i = 0; i < element.getTopic().size(); i++) 6423 composeCodeableConcept(t, "EffectEvidenceSynthesis", "topic", element.getTopic().get(i), i); 6424 for (int i = 0; i < element.getAuthor().size(); i++) 6425 composeContactDetail(t, "EffectEvidenceSynthesis", "author", element.getAuthor().get(i), i); 6426 for (int i = 0; i < element.getEditor().size(); i++) 6427 composeContactDetail(t, "EffectEvidenceSynthesis", "editor", element.getEditor().get(i), i); 6428 for (int i = 0; i < element.getReviewer().size(); i++) 6429 composeContactDetail(t, "EffectEvidenceSynthesis", "reviewer", element.getReviewer().get(i), i); 6430 for (int i = 0; i < element.getEndorser().size(); i++) 6431 composeContactDetail(t, "EffectEvidenceSynthesis", "endorser", element.getEndorser().get(i), i); 6432 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 6433 composeRelatedArtifact(t, "EffectEvidenceSynthesis", "relatedArtifact", element.getRelatedArtifact().get(i), i); 6434 if (element.hasSynthesisType()) 6435 composeCodeableConcept(t, "EffectEvidenceSynthesis", "synthesisType", element.getSynthesisType(), -1); 6436 if (element.hasStudyType()) 6437 composeCodeableConcept(t, "EffectEvidenceSynthesis", "studyType", element.getStudyType(), -1); 6438 if (element.hasPopulation()) 6439 composeReference(t, "EffectEvidenceSynthesis", "population", element.getPopulation(), -1); 6440 if (element.hasExposure()) 6441 composeReference(t, "EffectEvidenceSynthesis", "exposure", element.getExposure(), -1); 6442 if (element.hasExposureAlternative()) 6443 composeReference(t, "EffectEvidenceSynthesis", "exposureAlternative", element.getExposureAlternative(), -1); 6444 if (element.hasOutcome()) 6445 composeReference(t, "EffectEvidenceSynthesis", "outcome", element.getOutcome(), -1); 6446 if (element.hasSampleSize()) 6447 composeEffectEvidenceSynthesisEffectEvidenceSynthesisSampleSizeComponent(t, "EffectEvidenceSynthesis", "sampleSize", element.getSampleSize(), -1); 6448 for (int i = 0; i < element.getResultsByExposure().size(); i++) 6449 composeEffectEvidenceSynthesisEffectEvidenceSynthesisResultsByExposureComponent(t, "EffectEvidenceSynthesis", "resultsByExposure", element.getResultsByExposure().get(i), i); 6450 for (int i = 0; i < element.getEffectEstimate().size(); i++) 6451 composeEffectEvidenceSynthesisEffectEvidenceSynthesisEffectEstimateComponent(t, "EffectEvidenceSynthesis", "effectEstimate", element.getEffectEstimate().get(i), i); 6452 for (int i = 0; i < element.getCertainty().size(); i++) 6453 composeEffectEvidenceSynthesisEffectEvidenceSynthesisCertaintyComponent(t, "EffectEvidenceSynthesis", "certainty", element.getCertainty().get(i), i); 6454 } 6455 6456 protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisSampleSizeComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisSampleSizeComponent element, int index) { 6457 if (element == null) 6458 return; 6459 Complex t; 6460 if (Utilities.noString(parentType)) 6461 t = parent; 6462 else { 6463 t = parent.predicate("fhir:"+parentType+'.'+name); 6464 } 6465 composeBackboneElement(t, "sampleSize", name, element, index); 6466 if (element.hasDescriptionElement()) 6467 composeString(t, "EffectEvidenceSynthesis", "description", element.getDescriptionElement(), -1); 6468 if (element.hasNumberOfStudiesElement()) 6469 composeInteger(t, "EffectEvidenceSynthesis", "numberOfStudies", element.getNumberOfStudiesElement(), -1); 6470 if (element.hasNumberOfParticipantsElement()) 6471 composeInteger(t, "EffectEvidenceSynthesis", "numberOfParticipants", element.getNumberOfParticipantsElement(), -1); 6472 } 6473 6474 protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisResultsByExposureComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisResultsByExposureComponent element, int index) { 6475 if (element == null) 6476 return; 6477 Complex t; 6478 if (Utilities.noString(parentType)) 6479 t = parent; 6480 else { 6481 t = parent.predicate("fhir:"+parentType+'.'+name); 6482 } 6483 composeBackboneElement(t, "resultsByExposure", name, element, index); 6484 if (element.hasDescriptionElement()) 6485 composeString(t, "EffectEvidenceSynthesis", "description", element.getDescriptionElement(), -1); 6486 if (element.hasExposureStateElement()) 6487 composeEnum(t, "EffectEvidenceSynthesis", "exposureState", element.getExposureStateElement(), -1); 6488 if (element.hasVariantState()) 6489 composeCodeableConcept(t, "EffectEvidenceSynthesis", "variantState", element.getVariantState(), -1); 6490 if (element.hasRiskEvidenceSynthesis()) 6491 composeReference(t, "EffectEvidenceSynthesis", "riskEvidenceSynthesis", element.getRiskEvidenceSynthesis(), -1); 6492 } 6493 6494 protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisEffectEstimateComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisEffectEstimateComponent element, int index) { 6495 if (element == null) 6496 return; 6497 Complex t; 6498 if (Utilities.noString(parentType)) 6499 t = parent; 6500 else { 6501 t = parent.predicate("fhir:"+parentType+'.'+name); 6502 } 6503 composeBackboneElement(t, "effectEstimate", name, element, index); 6504 if (element.hasDescriptionElement()) 6505 composeString(t, "EffectEvidenceSynthesis", "description", element.getDescriptionElement(), -1); 6506 if (element.hasType()) 6507 composeCodeableConcept(t, "EffectEvidenceSynthesis", "type", element.getType(), -1); 6508 if (element.hasVariantState()) 6509 composeCodeableConcept(t, "EffectEvidenceSynthesis", "variantState", element.getVariantState(), -1); 6510 if (element.hasValueElement()) 6511 composeDecimal(t, "EffectEvidenceSynthesis", "value", element.getValueElement(), -1); 6512 if (element.hasUnitOfMeasure()) 6513 composeCodeableConcept(t, "EffectEvidenceSynthesis", "unitOfMeasure", element.getUnitOfMeasure(), -1); 6514 for (int i = 0; i < element.getPrecisionEstimate().size(); i++) 6515 composeEffectEvidenceSynthesisEffectEvidenceSynthesisEffectEstimatePrecisionEstimateComponent(t, "EffectEvidenceSynthesis", "precisionEstimate", element.getPrecisionEstimate().get(i), i); 6516 } 6517 6518 protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisEffectEstimatePrecisionEstimateComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisEffectEstimatePrecisionEstimateComponent element, int index) { 6519 if (element == null) 6520 return; 6521 Complex t; 6522 if (Utilities.noString(parentType)) 6523 t = parent; 6524 else { 6525 t = parent.predicate("fhir:"+parentType+'.'+name); 6526 } 6527 composeBackboneElement(t, "precisionEstimate", name, element, index); 6528 if (element.hasType()) 6529 composeCodeableConcept(t, "EffectEvidenceSynthesis", "type", element.getType(), -1); 6530 if (element.hasLevelElement()) 6531 composeDecimal(t, "EffectEvidenceSynthesis", "level", element.getLevelElement(), -1); 6532 if (element.hasFromElement()) 6533 composeDecimal(t, "EffectEvidenceSynthesis", "from", element.getFromElement(), -1); 6534 if (element.hasToElement()) 6535 composeDecimal(t, "EffectEvidenceSynthesis", "to", element.getToElement(), -1); 6536 } 6537 6538 protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisCertaintyComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisCertaintyComponent element, int index) { 6539 if (element == null) 6540 return; 6541 Complex t; 6542 if (Utilities.noString(parentType)) 6543 t = parent; 6544 else { 6545 t = parent.predicate("fhir:"+parentType+'.'+name); 6546 } 6547 composeBackboneElement(t, "certainty", name, element, index); 6548 for (int i = 0; i < element.getRating().size(); i++) 6549 composeCodeableConcept(t, "EffectEvidenceSynthesis", "rating", element.getRating().get(i), i); 6550 for (int i = 0; i < element.getNote().size(); i++) 6551 composeAnnotation(t, "EffectEvidenceSynthesis", "note", element.getNote().get(i), i); 6552 for (int i = 0; i < element.getCertaintySubcomponent().size(); i++) 6553 composeEffectEvidenceSynthesisEffectEvidenceSynthesisCertaintyCertaintySubcomponentComponent(t, "EffectEvidenceSynthesis", "certaintySubcomponent", element.getCertaintySubcomponent().get(i), i); 6554 } 6555 6556 protected void composeEffectEvidenceSynthesisEffectEvidenceSynthesisCertaintyCertaintySubcomponentComponent(Complex parent, String parentType, String name, EffectEvidenceSynthesis.EffectEvidenceSynthesisCertaintyCertaintySubcomponentComponent element, int index) { 6557 if (element == null) 6558 return; 6559 Complex t; 6560 if (Utilities.noString(parentType)) 6561 t = parent; 6562 else { 6563 t = parent.predicate("fhir:"+parentType+'.'+name); 6564 } 6565 composeBackboneElement(t, "certaintySubcomponent", name, element, index); 6566 if (element.hasType()) 6567 composeCodeableConcept(t, "EffectEvidenceSynthesis", "type", element.getType(), -1); 6568 for (int i = 0; i < element.getRating().size(); i++) 6569 composeCodeableConcept(t, "EffectEvidenceSynthesis", "rating", element.getRating().get(i), i); 6570 for (int i = 0; i < element.getNote().size(); i++) 6571 composeAnnotation(t, "EffectEvidenceSynthesis", "note", element.getNote().get(i), i); 6572 } 6573 6574 protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) { 6575 if (element == null) 6576 return; 6577 Complex t; 6578 if (Utilities.noString(parentType)) 6579 t = parent; 6580 else { 6581 t = parent.predicate("fhir:"+parentType+'.'+name); 6582 } 6583 composeDomainResource(t, "Encounter", name, element, index); 6584 for (int i = 0; i < element.getIdentifier().size(); i++) 6585 composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i); 6586 if (element.hasStatusElement()) 6587 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 6588 for (int i = 0; i < element.getStatusHistory().size(); i++) 6589 composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i); 6590 if (element.hasClass_()) 6591 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 6592 for (int i = 0; i < element.getClassHistory().size(); i++) 6593 composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i); 6594 for (int i = 0; i < element.getType().size(); i++) 6595 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 6596 if (element.hasServiceType()) 6597 composeCodeableConcept(t, "Encounter", "serviceType", element.getServiceType(), -1); 6598 if (element.hasPriority()) 6599 composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1); 6600 if (element.hasSubject()) 6601 composeReference(t, "Encounter", "subject", element.getSubject(), -1); 6602 for (int i = 0; i < element.getEpisodeOfCare().size(); i++) 6603 composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i); 6604 for (int i = 0; i < element.getBasedOn().size(); i++) 6605 composeReference(t, "Encounter", "basedOn", element.getBasedOn().get(i), i); 6606 for (int i = 0; i < element.getParticipant().size(); i++) 6607 composeEncounterEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i); 6608 for (int i = 0; i < element.getAppointment().size(); i++) 6609 composeReference(t, "Encounter", "appointment", element.getAppointment().get(i), i); 6610 if (element.hasPeriod()) 6611 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 6612 if (element.hasLength()) 6613 composeDuration(t, "Encounter", "length", element.getLength(), -1); 6614 for (int i = 0; i < element.getReasonCode().size(); i++) 6615 composeCodeableConcept(t, "Encounter", "reasonCode", element.getReasonCode().get(i), i); 6616 for (int i = 0; i < element.getReasonReference().size(); i++) 6617 composeReference(t, "Encounter", "reasonReference", element.getReasonReference().get(i), i); 6618 for (int i = 0; i < element.getDiagnosis().size(); i++) 6619 composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i); 6620 for (int i = 0; i < element.getAccount().size(); i++) 6621 composeReference(t, "Encounter", "account", element.getAccount().get(i), i); 6622 if (element.hasHospitalization()) 6623 composeEncounterEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1); 6624 for (int i = 0; i < element.getLocation().size(); i++) 6625 composeEncounterEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i); 6626 if (element.hasServiceProvider()) 6627 composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1); 6628 if (element.hasPartOf()) 6629 composeReference(t, "Encounter", "partOf", element.getPartOf(), -1); 6630 } 6631 6632 protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent element, int index) { 6633 if (element == null) 6634 return; 6635 Complex t; 6636 if (Utilities.noString(parentType)) 6637 t = parent; 6638 else { 6639 t = parent.predicate("fhir:"+parentType+'.'+name); 6640 } 6641 composeBackboneElement(t, "statusHistory", name, element, index); 6642 if (element.hasStatusElement()) 6643 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 6644 if (element.hasPeriod()) 6645 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 6646 } 6647 6648 protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent element, int index) { 6649 if (element == null) 6650 return; 6651 Complex t; 6652 if (Utilities.noString(parentType)) 6653 t = parent; 6654 else { 6655 t = parent.predicate("fhir:"+parentType+'.'+name); 6656 } 6657 composeBackboneElement(t, "classHistory", name, element, index); 6658 if (element.hasClass_()) 6659 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 6660 if (element.hasPeriod()) 6661 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 6662 } 6663 6664 protected void composeEncounterEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) { 6665 if (element == null) 6666 return; 6667 Complex t; 6668 if (Utilities.noString(parentType)) 6669 t = parent; 6670 else { 6671 t = parent.predicate("fhir:"+parentType+'.'+name); 6672 } 6673 composeBackboneElement(t, "participant", name, element, index); 6674 for (int i = 0; i < element.getType().size(); i++) 6675 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 6676 if (element.hasPeriod()) 6677 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 6678 if (element.hasIndividual()) 6679 composeReference(t, "Encounter", "individual", element.getIndividual(), -1); 6680 } 6681 6682 protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) { 6683 if (element == null) 6684 return; 6685 Complex t; 6686 if (Utilities.noString(parentType)) 6687 t = parent; 6688 else { 6689 t = parent.predicate("fhir:"+parentType+'.'+name); 6690 } 6691 composeBackboneElement(t, "diagnosis", name, element, index); 6692 if (element.hasCondition()) 6693 composeReference(t, "Encounter", "condition", element.getCondition(), -1); 6694 if (element.hasUse()) 6695 composeCodeableConcept(t, "Encounter", "use", element.getUse(), -1); 6696 if (element.hasRankElement()) 6697 composePositiveInt(t, "Encounter", "rank", element.getRankElement(), -1); 6698 } 6699 6700 protected void composeEncounterEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) { 6701 if (element == null) 6702 return; 6703 Complex t; 6704 if (Utilities.noString(parentType)) 6705 t = parent; 6706 else { 6707 t = parent.predicate("fhir:"+parentType+'.'+name); 6708 } 6709 composeBackboneElement(t, "hospitalization", name, element, index); 6710 if (element.hasPreAdmissionIdentifier()) 6711 composeIdentifier(t, "Encounter", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1); 6712 if (element.hasOrigin()) 6713 composeReference(t, "Encounter", "origin", element.getOrigin(), -1); 6714 if (element.hasAdmitSource()) 6715 composeCodeableConcept(t, "Encounter", "admitSource", element.getAdmitSource(), -1); 6716 if (element.hasReAdmission()) 6717 composeCodeableConcept(t, "Encounter", "reAdmission", element.getReAdmission(), -1); 6718 for (int i = 0; i < element.getDietPreference().size(); i++) 6719 composeCodeableConcept(t, "Encounter", "dietPreference", element.getDietPreference().get(i), i); 6720 for (int i = 0; i < element.getSpecialCourtesy().size(); i++) 6721 composeCodeableConcept(t, "Encounter", "specialCourtesy", element.getSpecialCourtesy().get(i), i); 6722 for (int i = 0; i < element.getSpecialArrangement().size(); i++) 6723 composeCodeableConcept(t, "Encounter", "specialArrangement", element.getSpecialArrangement().get(i), i); 6724 if (element.hasDestination()) 6725 composeReference(t, "Encounter", "destination", element.getDestination(), -1); 6726 if (element.hasDischargeDisposition()) 6727 composeCodeableConcept(t, "Encounter", "dischargeDisposition", element.getDischargeDisposition(), -1); 6728 } 6729 6730 protected void composeEncounterEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) { 6731 if (element == null) 6732 return; 6733 Complex t; 6734 if (Utilities.noString(parentType)) 6735 t = parent; 6736 else { 6737 t = parent.predicate("fhir:"+parentType+'.'+name); 6738 } 6739 composeBackboneElement(t, "location", name, element, index); 6740 if (element.hasLocation()) 6741 composeReference(t, "Encounter", "location", element.getLocation(), -1); 6742 if (element.hasStatusElement()) 6743 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 6744 if (element.hasPhysicalType()) 6745 composeCodeableConcept(t, "Encounter", "physicalType", element.getPhysicalType(), -1); 6746 if (element.hasPeriod()) 6747 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 6748 } 6749 6750 protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) { 6751 if (element == null) 6752 return; 6753 Complex t; 6754 if (Utilities.noString(parentType)) 6755 t = parent; 6756 else { 6757 t = parent.predicate("fhir:"+parentType+'.'+name); 6758 } 6759 composeDomainResource(t, "Endpoint", name, element, index); 6760 for (int i = 0; i < element.getIdentifier().size(); i++) 6761 composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i); 6762 if (element.hasStatusElement()) 6763 composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1); 6764 if (element.hasConnectionType()) 6765 composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1); 6766 if (element.hasNameElement()) 6767 composeString(t, "Endpoint", "name", element.getNameElement(), -1); 6768 if (element.hasManagingOrganization()) 6769 composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1); 6770 for (int i = 0; i < element.getContact().size(); i++) 6771 composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i); 6772 if (element.hasPeriod()) 6773 composePeriod(t, "Endpoint", "period", element.getPeriod(), -1); 6774 for (int i = 0; i < element.getPayloadType().size(); i++) 6775 composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i); 6776 for (int i = 0; i < element.getPayloadMimeType().size(); i++) 6777 composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i); 6778 if (element.hasAddressElement()) 6779 composeUrl(t, "Endpoint", "address", element.getAddressElement(), -1); 6780 for (int i = 0; i < element.getHeader().size(); i++) 6781 composeString(t, "Endpoint", "header", element.getHeader().get(i), i); 6782 } 6783 6784 protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) { 6785 if (element == null) 6786 return; 6787 Complex t; 6788 if (Utilities.noString(parentType)) 6789 t = parent; 6790 else { 6791 t = parent.predicate("fhir:"+parentType+'.'+name); 6792 } 6793 composeDomainResource(t, "EnrollmentRequest", name, element, index); 6794 for (int i = 0; i < element.getIdentifier().size(); i++) 6795 composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i); 6796 if (element.hasStatusElement()) 6797 composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1); 6798 if (element.hasCreatedElement()) 6799 composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1); 6800 if (element.hasInsurer()) 6801 composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1); 6802 if (element.hasProvider()) 6803 composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1); 6804 if (element.hasCandidate()) 6805 composeReference(t, "EnrollmentRequest", "candidate", element.getCandidate(), -1); 6806 if (element.hasCoverage()) 6807 composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1); 6808 } 6809 6810 protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) { 6811 if (element == null) 6812 return; 6813 Complex t; 6814 if (Utilities.noString(parentType)) 6815 t = parent; 6816 else { 6817 t = parent.predicate("fhir:"+parentType+'.'+name); 6818 } 6819 composeDomainResource(t, "EnrollmentResponse", name, element, index); 6820 for (int i = 0; i < element.getIdentifier().size(); i++) 6821 composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i); 6822 if (element.hasStatusElement()) 6823 composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1); 6824 if (element.hasRequest()) 6825 composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1); 6826 if (element.hasOutcomeElement()) 6827 composeEnum(t, "EnrollmentResponse", "outcome", element.getOutcomeElement(), -1); 6828 if (element.hasDispositionElement()) 6829 composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1); 6830 if (element.hasCreatedElement()) 6831 composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1); 6832 if (element.hasOrganization()) 6833 composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1); 6834 if (element.hasRequestProvider()) 6835 composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1); 6836 } 6837 6838 protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) { 6839 if (element == null) 6840 return; 6841 Complex t; 6842 if (Utilities.noString(parentType)) 6843 t = parent; 6844 else { 6845 t = parent.predicate("fhir:"+parentType+'.'+name); 6846 } 6847 composeDomainResource(t, "EpisodeOfCare", name, element, index); 6848 for (int i = 0; i < element.getIdentifier().size(); i++) 6849 composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i); 6850 if (element.hasStatusElement()) 6851 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 6852 for (int i = 0; i < element.getStatusHistory().size(); i++) 6853 composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i); 6854 for (int i = 0; i < element.getType().size(); i++) 6855 composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i); 6856 for (int i = 0; i < element.getDiagnosis().size(); i++) 6857 composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i); 6858 if (element.hasPatient()) 6859 composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1); 6860 if (element.hasManagingOrganization()) 6861 composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1); 6862 if (element.hasPeriod()) 6863 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 6864 for (int i = 0; i < element.getReferralRequest().size(); i++) 6865 composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i); 6866 if (element.hasCareManager()) 6867 composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1); 6868 for (int i = 0; i < element.getTeam().size(); i++) 6869 composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i); 6870 for (int i = 0; i < element.getAccount().size(); i++) 6871 composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i); 6872 } 6873 6874 protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) { 6875 if (element == null) 6876 return; 6877 Complex t; 6878 if (Utilities.noString(parentType)) 6879 t = parent; 6880 else { 6881 t = parent.predicate("fhir:"+parentType+'.'+name); 6882 } 6883 composeBackboneElement(t, "statusHistory", name, element, index); 6884 if (element.hasStatusElement()) 6885 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 6886 if (element.hasPeriod()) 6887 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 6888 } 6889 6890 protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) { 6891 if (element == null) 6892 return; 6893 Complex t; 6894 if (Utilities.noString(parentType)) 6895 t = parent; 6896 else { 6897 t = parent.predicate("fhir:"+parentType+'.'+name); 6898 } 6899 composeBackboneElement(t, "diagnosis", name, element, index); 6900 if (element.hasCondition()) 6901 composeReference(t, "EpisodeOfCare", "condition", element.getCondition(), -1); 6902 if (element.hasRole()) 6903 composeCodeableConcept(t, "EpisodeOfCare", "role", element.getRole(), -1); 6904 if (element.hasRankElement()) 6905 composePositiveInt(t, "EpisodeOfCare", "rank", element.getRankElement(), -1); 6906 } 6907 6908 protected void composeEventDefinition(Complex parent, String parentType, String name, EventDefinition element, int index) { 6909 if (element == null) 6910 return; 6911 Complex t; 6912 if (Utilities.noString(parentType)) 6913 t = parent; 6914 else { 6915 t = parent.predicate("fhir:"+parentType+'.'+name); 6916 } 6917 composeDomainResource(t, "EventDefinition", name, element, index); 6918 if (element.hasUrlElement()) 6919 composeUri(t, "EventDefinition", "url", element.getUrlElement(), -1); 6920 for (int i = 0; i < element.getIdentifier().size(); i++) 6921 composeIdentifier(t, "EventDefinition", "identifier", element.getIdentifier().get(i), i); 6922 if (element.hasVersionElement()) 6923 composeString(t, "EventDefinition", "version", element.getVersionElement(), -1); 6924 if (element.hasNameElement()) 6925 composeString(t, "EventDefinition", "name", element.getNameElement(), -1); 6926 if (element.hasTitleElement()) 6927 composeString(t, "EventDefinition", "title", element.getTitleElement(), -1); 6928 if (element.hasSubtitleElement()) 6929 composeString(t, "EventDefinition", "subtitle", element.getSubtitleElement(), -1); 6930 if (element.hasStatusElement()) 6931 composeEnum(t, "EventDefinition", "status", element.getStatusElement(), -1); 6932 if (element.hasExperimentalElement()) 6933 composeBoolean(t, "EventDefinition", "experimental", element.getExperimentalElement(), -1); 6934 if (element.hasSubject()) 6935 composeType(t, "EventDefinition", "subject", element.getSubject(), -1); 6936 if (element.hasDateElement()) 6937 composeDateTime(t, "EventDefinition", "date", element.getDateElement(), -1); 6938 if (element.hasPublisherElement()) 6939 composeString(t, "EventDefinition", "publisher", element.getPublisherElement(), -1); 6940 for (int i = 0; i < element.getContact().size(); i++) 6941 composeContactDetail(t, "EventDefinition", "contact", element.getContact().get(i), i); 6942 if (element.hasDescriptionElement()) 6943 composeMarkdown(t, "EventDefinition", "description", element.getDescriptionElement(), -1); 6944 for (int i = 0; i < element.getUseContext().size(); i++) 6945 composeUsageContext(t, "EventDefinition", "useContext", element.getUseContext().get(i), i); 6946 for (int i = 0; i < element.getJurisdiction().size(); i++) 6947 composeCodeableConcept(t, "EventDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 6948 if (element.hasPurposeElement()) 6949 composeMarkdown(t, "EventDefinition", "purpose", element.getPurposeElement(), -1); 6950 if (element.hasUsageElement()) 6951 composeString(t, "EventDefinition", "usage", element.getUsageElement(), -1); 6952 if (element.hasCopyrightElement()) 6953 composeMarkdown(t, "EventDefinition", "copyright", element.getCopyrightElement(), -1); 6954 if (element.hasApprovalDateElement()) 6955 composeDate(t, "EventDefinition", "approvalDate", element.getApprovalDateElement(), -1); 6956 if (element.hasLastReviewDateElement()) 6957 composeDate(t, "EventDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 6958 if (element.hasEffectivePeriod()) 6959 composePeriod(t, "EventDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 6960 for (int i = 0; i < element.getTopic().size(); i++) 6961 composeCodeableConcept(t, "EventDefinition", "topic", element.getTopic().get(i), i); 6962 for (int i = 0; i < element.getAuthor().size(); i++) 6963 composeContactDetail(t, "EventDefinition", "author", element.getAuthor().get(i), i); 6964 for (int i = 0; i < element.getEditor().size(); i++) 6965 composeContactDetail(t, "EventDefinition", "editor", element.getEditor().get(i), i); 6966 for (int i = 0; i < element.getReviewer().size(); i++) 6967 composeContactDetail(t, "EventDefinition", "reviewer", element.getReviewer().get(i), i); 6968 for (int i = 0; i < element.getEndorser().size(); i++) 6969 composeContactDetail(t, "EventDefinition", "endorser", element.getEndorser().get(i), i); 6970 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 6971 composeRelatedArtifact(t, "EventDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 6972 for (int i = 0; i < element.getTrigger().size(); i++) 6973 composeTriggerDefinition(t, "EventDefinition", "trigger", element.getTrigger().get(i), i); 6974 } 6975 6976 protected void composeEvidence(Complex parent, String parentType, String name, Evidence element, int index) { 6977 if (element == null) 6978 return; 6979 Complex t; 6980 if (Utilities.noString(parentType)) 6981 t = parent; 6982 else { 6983 t = parent.predicate("fhir:"+parentType+'.'+name); 6984 } 6985 composeDomainResource(t, "Evidence", name, element, index); 6986 if (element.hasUrlElement()) 6987 composeUri(t, "Evidence", "url", element.getUrlElement(), -1); 6988 for (int i = 0; i < element.getIdentifier().size(); i++) 6989 composeIdentifier(t, "Evidence", "identifier", element.getIdentifier().get(i), i); 6990 if (element.hasVersionElement()) 6991 composeString(t, "Evidence", "version", element.getVersionElement(), -1); 6992 if (element.hasNameElement()) 6993 composeString(t, "Evidence", "name", element.getNameElement(), -1); 6994 if (element.hasTitleElement()) 6995 composeString(t, "Evidence", "title", element.getTitleElement(), -1); 6996 if (element.hasShortTitleElement()) 6997 composeString(t, "Evidence", "shortTitle", element.getShortTitleElement(), -1); 6998 if (element.hasSubtitleElement()) 6999 composeString(t, "Evidence", "subtitle", element.getSubtitleElement(), -1); 7000 if (element.hasStatusElement()) 7001 composeEnum(t, "Evidence", "status", element.getStatusElement(), -1); 7002 if (element.hasDateElement()) 7003 composeDateTime(t, "Evidence", "date", element.getDateElement(), -1); 7004 if (element.hasPublisherElement()) 7005 composeString(t, "Evidence", "publisher", element.getPublisherElement(), -1); 7006 for (int i = 0; i < element.getContact().size(); i++) 7007 composeContactDetail(t, "Evidence", "contact", element.getContact().get(i), i); 7008 if (element.hasDescriptionElement()) 7009 composeMarkdown(t, "Evidence", "description", element.getDescriptionElement(), -1); 7010 for (int i = 0; i < element.getNote().size(); i++) 7011 composeAnnotation(t, "Evidence", "note", element.getNote().get(i), i); 7012 for (int i = 0; i < element.getUseContext().size(); i++) 7013 composeUsageContext(t, "Evidence", "useContext", element.getUseContext().get(i), i); 7014 for (int i = 0; i < element.getJurisdiction().size(); i++) 7015 composeCodeableConcept(t, "Evidence", "jurisdiction", element.getJurisdiction().get(i), i); 7016 if (element.hasCopyrightElement()) 7017 composeMarkdown(t, "Evidence", "copyright", element.getCopyrightElement(), -1); 7018 if (element.hasApprovalDateElement()) 7019 composeDate(t, "Evidence", "approvalDate", element.getApprovalDateElement(), -1); 7020 if (element.hasLastReviewDateElement()) 7021 composeDate(t, "Evidence", "lastReviewDate", element.getLastReviewDateElement(), -1); 7022 if (element.hasEffectivePeriod()) 7023 composePeriod(t, "Evidence", "effectivePeriod", element.getEffectivePeriod(), -1); 7024 for (int i = 0; i < element.getTopic().size(); i++) 7025 composeCodeableConcept(t, "Evidence", "topic", element.getTopic().get(i), i); 7026 for (int i = 0; i < element.getAuthor().size(); i++) 7027 composeContactDetail(t, "Evidence", "author", element.getAuthor().get(i), i); 7028 for (int i = 0; i < element.getEditor().size(); i++) 7029 composeContactDetail(t, "Evidence", "editor", element.getEditor().get(i), i); 7030 for (int i = 0; i < element.getReviewer().size(); i++) 7031 composeContactDetail(t, "Evidence", "reviewer", element.getReviewer().get(i), i); 7032 for (int i = 0; i < element.getEndorser().size(); i++) 7033 composeContactDetail(t, "Evidence", "endorser", element.getEndorser().get(i), i); 7034 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 7035 composeRelatedArtifact(t, "Evidence", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7036 if (element.hasExposureBackground()) 7037 composeReference(t, "Evidence", "exposureBackground", element.getExposureBackground(), -1); 7038 for (int i = 0; i < element.getExposureVariant().size(); i++) 7039 composeReference(t, "Evidence", "exposureVariant", element.getExposureVariant().get(i), i); 7040 for (int i = 0; i < element.getOutcome().size(); i++) 7041 composeReference(t, "Evidence", "outcome", element.getOutcome().get(i), i); 7042 } 7043 7044 protected void composeEvidenceVariable(Complex parent, String parentType, String name, EvidenceVariable element, int index) { 7045 if (element == null) 7046 return; 7047 Complex t; 7048 if (Utilities.noString(parentType)) 7049 t = parent; 7050 else { 7051 t = parent.predicate("fhir:"+parentType+'.'+name); 7052 } 7053 composeDomainResource(t, "EvidenceVariable", name, element, index); 7054 if (element.hasUrlElement()) 7055 composeUri(t, "EvidenceVariable", "url", element.getUrlElement(), -1); 7056 for (int i = 0; i < element.getIdentifier().size(); i++) 7057 composeIdentifier(t, "EvidenceVariable", "identifier", element.getIdentifier().get(i), i); 7058 if (element.hasVersionElement()) 7059 composeString(t, "EvidenceVariable", "version", element.getVersionElement(), -1); 7060 if (element.hasNameElement()) 7061 composeString(t, "EvidenceVariable", "name", element.getNameElement(), -1); 7062 if (element.hasTitleElement()) 7063 composeString(t, "EvidenceVariable", "title", element.getTitleElement(), -1); 7064 if (element.hasShortTitleElement()) 7065 composeString(t, "EvidenceVariable", "shortTitle", element.getShortTitleElement(), -1); 7066 if (element.hasSubtitleElement()) 7067 composeString(t, "EvidenceVariable", "subtitle", element.getSubtitleElement(), -1); 7068 if (element.hasStatusElement()) 7069 composeEnum(t, "EvidenceVariable", "status", element.getStatusElement(), -1); 7070 if (element.hasDateElement()) 7071 composeDateTime(t, "EvidenceVariable", "date", element.getDateElement(), -1); 7072 if (element.hasPublisherElement()) 7073 composeString(t, "EvidenceVariable", "publisher", element.getPublisherElement(), -1); 7074 for (int i = 0; i < element.getContact().size(); i++) 7075 composeContactDetail(t, "EvidenceVariable", "contact", element.getContact().get(i), i); 7076 if (element.hasDescriptionElement()) 7077 composeMarkdown(t, "EvidenceVariable", "description", element.getDescriptionElement(), -1); 7078 for (int i = 0; i < element.getNote().size(); i++) 7079 composeAnnotation(t, "EvidenceVariable", "note", element.getNote().get(i), i); 7080 for (int i = 0; i < element.getUseContext().size(); i++) 7081 composeUsageContext(t, "EvidenceVariable", "useContext", element.getUseContext().get(i), i); 7082 for (int i = 0; i < element.getJurisdiction().size(); i++) 7083 composeCodeableConcept(t, "EvidenceVariable", "jurisdiction", element.getJurisdiction().get(i), i); 7084 if (element.hasCopyrightElement()) 7085 composeMarkdown(t, "EvidenceVariable", "copyright", element.getCopyrightElement(), -1); 7086 if (element.hasApprovalDateElement()) 7087 composeDate(t, "EvidenceVariable", "approvalDate", element.getApprovalDateElement(), -1); 7088 if (element.hasLastReviewDateElement()) 7089 composeDate(t, "EvidenceVariable", "lastReviewDate", element.getLastReviewDateElement(), -1); 7090 if (element.hasEffectivePeriod()) 7091 composePeriod(t, "EvidenceVariable", "effectivePeriod", element.getEffectivePeriod(), -1); 7092 for (int i = 0; i < element.getTopic().size(); i++) 7093 composeCodeableConcept(t, "EvidenceVariable", "topic", element.getTopic().get(i), i); 7094 for (int i = 0; i < element.getAuthor().size(); i++) 7095 composeContactDetail(t, "EvidenceVariable", "author", element.getAuthor().get(i), i); 7096 for (int i = 0; i < element.getEditor().size(); i++) 7097 composeContactDetail(t, "EvidenceVariable", "editor", element.getEditor().get(i), i); 7098 for (int i = 0; i < element.getReviewer().size(); i++) 7099 composeContactDetail(t, "EvidenceVariable", "reviewer", element.getReviewer().get(i), i); 7100 for (int i = 0; i < element.getEndorser().size(); i++) 7101 composeContactDetail(t, "EvidenceVariable", "endorser", element.getEndorser().get(i), i); 7102 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 7103 composeRelatedArtifact(t, "EvidenceVariable", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7104 if (element.hasTypeElement()) 7105 composeEnum(t, "EvidenceVariable", "type", element.getTypeElement(), -1); 7106 for (int i = 0; i < element.getCharacteristic().size(); i++) 7107 composeEvidenceVariableEvidenceVariableCharacteristicComponent(t, "EvidenceVariable", "characteristic", element.getCharacteristic().get(i), i); 7108 } 7109 7110 protected void composeEvidenceVariableEvidenceVariableCharacteristicComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicComponent element, int index) { 7111 if (element == null) 7112 return; 7113 Complex t; 7114 if (Utilities.noString(parentType)) 7115 t = parent; 7116 else { 7117 t = parent.predicate("fhir:"+parentType+'.'+name); 7118 } 7119 composeBackboneElement(t, "characteristic", name, element, index); 7120 if (element.hasDescriptionElement()) 7121 composeString(t, "EvidenceVariable", "description", element.getDescriptionElement(), -1); 7122 if (element.hasDefinition()) 7123 composeType(t, "EvidenceVariable", "definition", element.getDefinition(), -1); 7124 for (int i = 0; i < element.getUsageContext().size(); i++) 7125 composeUsageContext(t, "EvidenceVariable", "usageContext", element.getUsageContext().get(i), i); 7126 if (element.hasExcludeElement()) 7127 composeBoolean(t, "EvidenceVariable", "exclude", element.getExcludeElement(), -1); 7128 if (element.hasParticipantEffective()) 7129 composeType(t, "EvidenceVariable", "participantEffective", element.getParticipantEffective(), -1); 7130 if (element.hasTimeFromStart()) 7131 composeDuration(t, "EvidenceVariable", "timeFromStart", element.getTimeFromStart(), -1); 7132 if (element.hasGroupMeasureElement()) 7133 composeEnum(t, "EvidenceVariable", "groupMeasure", element.getGroupMeasureElement(), -1); 7134 } 7135 7136 protected void composeExampleScenario(Complex parent, String parentType, String name, ExampleScenario element, int index) { 7137 if (element == null) 7138 return; 7139 Complex t; 7140 if (Utilities.noString(parentType)) 7141 t = parent; 7142 else { 7143 t = parent.predicate("fhir:"+parentType+'.'+name); 7144 } 7145 composeDomainResource(t, "ExampleScenario", name, element, index); 7146 if (element.hasUrlElement()) 7147 composeUri(t, "ExampleScenario", "url", element.getUrlElement(), -1); 7148 for (int i = 0; i < element.getIdentifier().size(); i++) 7149 composeIdentifier(t, "ExampleScenario", "identifier", element.getIdentifier().get(i), i); 7150 if (element.hasVersionElement()) 7151 composeString(t, "ExampleScenario", "version", element.getVersionElement(), -1); 7152 if (element.hasNameElement()) 7153 composeString(t, "ExampleScenario", "name", element.getNameElement(), -1); 7154 if (element.hasStatusElement()) 7155 composeEnum(t, "ExampleScenario", "status", element.getStatusElement(), -1); 7156 if (element.hasExperimentalElement()) 7157 composeBoolean(t, "ExampleScenario", "experimental", element.getExperimentalElement(), -1); 7158 if (element.hasDateElement()) 7159 composeDateTime(t, "ExampleScenario", "date", element.getDateElement(), -1); 7160 if (element.hasPublisherElement()) 7161 composeString(t, "ExampleScenario", "publisher", element.getPublisherElement(), -1); 7162 for (int i = 0; i < element.getContact().size(); i++) 7163 composeContactDetail(t, "ExampleScenario", "contact", element.getContact().get(i), i); 7164 for (int i = 0; i < element.getUseContext().size(); i++) 7165 composeUsageContext(t, "ExampleScenario", "useContext", element.getUseContext().get(i), i); 7166 for (int i = 0; i < element.getJurisdiction().size(); i++) 7167 composeCodeableConcept(t, "ExampleScenario", "jurisdiction", element.getJurisdiction().get(i), i); 7168 if (element.hasCopyrightElement()) 7169 composeMarkdown(t, "ExampleScenario", "copyright", element.getCopyrightElement(), -1); 7170 if (element.hasPurposeElement()) 7171 composeMarkdown(t, "ExampleScenario", "purpose", element.getPurposeElement(), -1); 7172 for (int i = 0; i < element.getActor().size(); i++) 7173 composeExampleScenarioExampleScenarioActorComponent(t, "ExampleScenario", "actor", element.getActor().get(i), i); 7174 for (int i = 0; i < element.getInstance().size(); i++) 7175 composeExampleScenarioExampleScenarioInstanceComponent(t, "ExampleScenario", "instance", element.getInstance().get(i), i); 7176 for (int i = 0; i < element.getProcess().size(); i++) 7177 composeExampleScenarioExampleScenarioProcessComponent(t, "ExampleScenario", "process", element.getProcess().get(i), i); 7178 for (int i = 0; i < element.getWorkflow().size(); i++) 7179 composeCanonical(t, "ExampleScenario", "workflow", element.getWorkflow().get(i), i); 7180 } 7181 7182 protected void composeExampleScenarioExampleScenarioActorComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioActorComponent element, int index) { 7183 if (element == null) 7184 return; 7185 Complex t; 7186 if (Utilities.noString(parentType)) 7187 t = parent; 7188 else { 7189 t = parent.predicate("fhir:"+parentType+'.'+name); 7190 } 7191 composeBackboneElement(t, "actor", name, element, index); 7192 if (element.hasActorIdElement()) 7193 composeString(t, "ExampleScenario", "actorId", element.getActorIdElement(), -1); 7194 if (element.hasTypeElement()) 7195 composeEnum(t, "ExampleScenario", "type", element.getTypeElement(), -1); 7196 if (element.hasNameElement()) 7197 composeString(t, "ExampleScenario", "name", element.getNameElement(), -1); 7198 if (element.hasDescriptionElement()) 7199 composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1); 7200 } 7201 7202 protected void composeExampleScenarioExampleScenarioInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceComponent element, int index) { 7203 if (element == null) 7204 return; 7205 Complex t; 7206 if (Utilities.noString(parentType)) 7207 t = parent; 7208 else { 7209 t = parent.predicate("fhir:"+parentType+'.'+name); 7210 } 7211 composeBackboneElement(t, "instance", name, element, index); 7212 if (element.hasResourceIdElement()) 7213 composeString(t, "ExampleScenario", "resourceId", element.getResourceIdElement(), -1); 7214 if (element.hasResourceTypeElement()) 7215 composeEnum(t, "ExampleScenario", "resourceType", element.getResourceTypeElement(), -1); 7216 if (element.hasNameElement()) 7217 composeString(t, "ExampleScenario", "name", element.getNameElement(), -1); 7218 if (element.hasDescriptionElement()) 7219 composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1); 7220 for (int i = 0; i < element.getVersion().size(); i++) 7221 composeExampleScenarioExampleScenarioInstanceVersionComponent(t, "ExampleScenario", "version", element.getVersion().get(i), i); 7222 for (int i = 0; i < element.getContainedInstance().size(); i++) 7223 composeExampleScenarioExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenario", "containedInstance", element.getContainedInstance().get(i), i); 7224 } 7225 7226 protected void composeExampleScenarioExampleScenarioInstanceVersionComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceVersionComponent element, int index) { 7227 if (element == null) 7228 return; 7229 Complex t; 7230 if (Utilities.noString(parentType)) 7231 t = parent; 7232 else { 7233 t = parent.predicate("fhir:"+parentType+'.'+name); 7234 } 7235 composeBackboneElement(t, "version", name, element, index); 7236 if (element.hasVersionIdElement()) 7237 composeString(t, "ExampleScenario", "versionId", element.getVersionIdElement(), -1); 7238 if (element.hasDescriptionElement()) 7239 composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1); 7240 } 7241 7242 protected void composeExampleScenarioExampleScenarioInstanceContainedInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceContainedInstanceComponent element, int index) { 7243 if (element == null) 7244 return; 7245 Complex t; 7246 if (Utilities.noString(parentType)) 7247 t = parent; 7248 else { 7249 t = parent.predicate("fhir:"+parentType+'.'+name); 7250 } 7251 composeBackboneElement(t, "containedInstance", name, element, index); 7252 if (element.hasResourceIdElement()) 7253 composeString(t, "ExampleScenario", "resourceId", element.getResourceIdElement(), -1); 7254 if (element.hasVersionIdElement()) 7255 composeString(t, "ExampleScenario", "versionId", element.getVersionIdElement(), -1); 7256 } 7257 7258 protected void composeExampleScenarioExampleScenarioProcessComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessComponent element, int index) { 7259 if (element == null) 7260 return; 7261 Complex t; 7262 if (Utilities.noString(parentType)) 7263 t = parent; 7264 else { 7265 t = parent.predicate("fhir:"+parentType+'.'+name); 7266 } 7267 composeBackboneElement(t, "process", name, element, index); 7268 if (element.hasTitleElement()) 7269 composeString(t, "ExampleScenario", "title", element.getTitleElement(), -1); 7270 if (element.hasDescriptionElement()) 7271 composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1); 7272 if (element.hasPreConditionsElement()) 7273 composeMarkdown(t, "ExampleScenario", "preConditions", element.getPreConditionsElement(), -1); 7274 if (element.hasPostConditionsElement()) 7275 composeMarkdown(t, "ExampleScenario", "postConditions", element.getPostConditionsElement(), -1); 7276 for (int i = 0; i < element.getStep().size(); i++) 7277 composeExampleScenarioExampleScenarioProcessStepComponent(t, "ExampleScenario", "step", element.getStep().get(i), i); 7278 } 7279 7280 protected void composeExampleScenarioExampleScenarioProcessStepComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepComponent element, int index) { 7281 if (element == null) 7282 return; 7283 Complex t; 7284 if (Utilities.noString(parentType)) 7285 t = parent; 7286 else { 7287 t = parent.predicate("fhir:"+parentType+'.'+name); 7288 } 7289 composeBackboneElement(t, "step", name, element, index); 7290 for (int i = 0; i < element.getProcess().size(); i++) 7291 composeExampleScenarioExampleScenarioProcessComponent(t, "ExampleScenario", "process", element.getProcess().get(i), i); 7292 if (element.hasPauseElement()) 7293 composeBoolean(t, "ExampleScenario", "pause", element.getPauseElement(), -1); 7294 if (element.hasOperation()) 7295 composeExampleScenarioExampleScenarioProcessStepOperationComponent(t, "ExampleScenario", "operation", element.getOperation(), -1); 7296 for (int i = 0; i < element.getAlternative().size(); i++) 7297 composeExampleScenarioExampleScenarioProcessStepAlternativeComponent(t, "ExampleScenario", "alternative", element.getAlternative().get(i), i); 7298 } 7299 7300 protected void composeExampleScenarioExampleScenarioProcessStepOperationComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepOperationComponent element, int index) { 7301 if (element == null) 7302 return; 7303 Complex t; 7304 if (Utilities.noString(parentType)) 7305 t = parent; 7306 else { 7307 t = parent.predicate("fhir:"+parentType+'.'+name); 7308 } 7309 composeBackboneElement(t, "operation", name, element, index); 7310 if (element.hasNumberElement()) 7311 composeString(t, "ExampleScenario", "number", element.getNumberElement(), -1); 7312 if (element.hasTypeElement()) 7313 composeString(t, "ExampleScenario", "type", element.getTypeElement(), -1); 7314 if (element.hasNameElement()) 7315 composeString(t, "ExampleScenario", "name", element.getNameElement(), -1); 7316 if (element.hasInitiatorElement()) 7317 composeString(t, "ExampleScenario", "initiator", element.getInitiatorElement(), -1); 7318 if (element.hasReceiverElement()) 7319 composeString(t, "ExampleScenario", "receiver", element.getReceiverElement(), -1); 7320 if (element.hasDescriptionElement()) 7321 composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1); 7322 if (element.hasInitiatorActiveElement()) 7323 composeBoolean(t, "ExampleScenario", "initiatorActive", element.getInitiatorActiveElement(), -1); 7324 if (element.hasReceiverActiveElement()) 7325 composeBoolean(t, "ExampleScenario", "receiverActive", element.getReceiverActiveElement(), -1); 7326 if (element.hasRequest()) 7327 composeExampleScenarioExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenario", "request", element.getRequest(), -1); 7328 if (element.hasResponse()) 7329 composeExampleScenarioExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenario", "response", element.getResponse(), -1); 7330 } 7331 7332 protected void composeExampleScenarioExampleScenarioProcessStepAlternativeComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepAlternativeComponent element, int index) { 7333 if (element == null) 7334 return; 7335 Complex t; 7336 if (Utilities.noString(parentType)) 7337 t = parent; 7338 else { 7339 t = parent.predicate("fhir:"+parentType+'.'+name); 7340 } 7341 composeBackboneElement(t, "alternative", name, element, index); 7342 if (element.hasTitleElement()) 7343 composeString(t, "ExampleScenario", "title", element.getTitleElement(), -1); 7344 if (element.hasDescriptionElement()) 7345 composeMarkdown(t, "ExampleScenario", "description", element.getDescriptionElement(), -1); 7346 for (int i = 0; i < element.getStep().size(); i++) 7347 composeExampleScenarioExampleScenarioProcessStepComponent(t, "ExampleScenario", "step", element.getStep().get(i), i); 7348 } 7349 7350 protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) { 7351 if (element == null) 7352 return; 7353 Complex t; 7354 if (Utilities.noString(parentType)) 7355 t = parent; 7356 else { 7357 t = parent.predicate("fhir:"+parentType+'.'+name); 7358 } 7359 composeDomainResource(t, "ExplanationOfBenefit", name, element, index); 7360 for (int i = 0; i < element.getIdentifier().size(); i++) 7361 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i); 7362 if (element.hasStatusElement()) 7363 composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1); 7364 if (element.hasType()) 7365 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 7366 if (element.hasSubType()) 7367 composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType(), -1); 7368 if (element.hasUseElement()) 7369 composeEnum(t, "ExplanationOfBenefit", "use", element.getUseElement(), -1); 7370 if (element.hasPatient()) 7371 composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1); 7372 if (element.hasBillablePeriod()) 7373 composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1); 7374 if (element.hasCreatedElement()) 7375 composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1); 7376 if (element.hasEnterer()) 7377 composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1); 7378 if (element.hasInsurer()) 7379 composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1); 7380 if (element.hasProvider()) 7381 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 7382 if (element.hasPriority()) 7383 composeCodeableConcept(t, "ExplanationOfBenefit", "priority", element.getPriority(), -1); 7384 if (element.hasFundsReserveRequested()) 7385 composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserveRequested", element.getFundsReserveRequested(), -1); 7386 if (element.hasFundsReserve()) 7387 composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserve", element.getFundsReserve(), -1); 7388 for (int i = 0; i < element.getRelated().size(); i++) 7389 composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i); 7390 if (element.hasPrescription()) 7391 composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1); 7392 if (element.hasOriginalPrescription()) 7393 composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1); 7394 if (element.hasPayee()) 7395 composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1); 7396 if (element.hasReferral()) 7397 composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1); 7398 if (element.hasFacility()) 7399 composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1); 7400 if (element.hasClaim()) 7401 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 7402 if (element.hasClaimResponse()) 7403 composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1); 7404 if (element.hasOutcomeElement()) 7405 composeEnum(t, "ExplanationOfBenefit", "outcome", element.getOutcomeElement(), -1); 7406 if (element.hasDispositionElement()) 7407 composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1); 7408 for (int i = 0; i < element.getPreAuthRef().size(); i++) 7409 composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i); 7410 for (int i = 0; i < element.getPreAuthRefPeriod().size(); i++) 7411 composePeriod(t, "ExplanationOfBenefit", "preAuthRefPeriod", element.getPreAuthRefPeriod().get(i), i); 7412 for (int i = 0; i < element.getCareTeam().size(); i++) 7413 composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i); 7414 for (int i = 0; i < element.getSupportingInfo().size(); i++) 7415 composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "supportingInfo", element.getSupportingInfo().get(i), i); 7416 for (int i = 0; i < element.getDiagnosis().size(); i++) 7417 composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i); 7418 for (int i = 0; i < element.getProcedure().size(); i++) 7419 composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i); 7420 if (element.hasPrecedenceElement()) 7421 composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1); 7422 for (int i = 0; i < element.getInsurance().size(); i++) 7423 composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance().get(i), i); 7424 if (element.hasAccident()) 7425 composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1); 7426 for (int i = 0; i < element.getItem().size(); i++) 7427 composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i); 7428 for (int i = 0; i < element.getAddItem().size(); i++) 7429 composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i); 7430 for (int i = 0; i < element.getAdjudication().size(); i++) 7431 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 7432 for (int i = 0; i < element.getTotal().size(); i++) 7433 composeExplanationOfBenefitTotalComponent(t, "ExplanationOfBenefit", "total", element.getTotal().get(i), i); 7434 if (element.hasPayment()) 7435 composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1); 7436 if (element.hasFormCode()) 7437 composeCodeableConcept(t, "ExplanationOfBenefit", "formCode", element.getFormCode(), -1); 7438 if (element.hasForm()) 7439 composeAttachment(t, "ExplanationOfBenefit", "form", element.getForm(), -1); 7440 for (int i = 0; i < element.getProcessNote().size(); i++) 7441 composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i); 7442 if (element.hasBenefitPeriod()) 7443 composePeriod(t, "ExplanationOfBenefit", "benefitPeriod", element.getBenefitPeriod(), -1); 7444 for (int i = 0; i < element.getBenefitBalance().size(); i++) 7445 composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i); 7446 } 7447 7448 protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) { 7449 if (element == null) 7450 return; 7451 Complex t; 7452 if (Utilities.noString(parentType)) 7453 t = parent; 7454 else { 7455 t = parent.predicate("fhir:"+parentType+'.'+name); 7456 } 7457 composeBackboneElement(t, "related", name, element, index); 7458 if (element.hasClaim()) 7459 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 7460 if (element.hasRelationship()) 7461 composeCodeableConcept(t, "ExplanationOfBenefit", "relationship", element.getRelationship(), -1); 7462 if (element.hasReference()) 7463 composeIdentifier(t, "ExplanationOfBenefit", "reference", element.getReference(), -1); 7464 } 7465 7466 protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) { 7467 if (element == null) 7468 return; 7469 Complex t; 7470 if (Utilities.noString(parentType)) 7471 t = parent; 7472 else { 7473 t = parent.predicate("fhir:"+parentType+'.'+name); 7474 } 7475 composeBackboneElement(t, "payee", name, element, index); 7476 if (element.hasType()) 7477 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 7478 if (element.hasParty()) 7479 composeReference(t, "ExplanationOfBenefit", "party", element.getParty(), -1); 7480 } 7481 7482 protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) { 7483 if (element == null) 7484 return; 7485 Complex t; 7486 if (Utilities.noString(parentType)) 7487 t = parent; 7488 else { 7489 t = parent.predicate("fhir:"+parentType+'.'+name); 7490 } 7491 composeBackboneElement(t, "careTeam", name, element, index); 7492 if (element.hasSequenceElement()) 7493 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 7494 if (element.hasProvider()) 7495 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 7496 if (element.hasResponsibleElement()) 7497 composeBoolean(t, "ExplanationOfBenefit", "responsible", element.getResponsibleElement(), -1); 7498 if (element.hasRole()) 7499 composeCodeableConcept(t, "ExplanationOfBenefit", "role", element.getRole(), -1); 7500 if (element.hasQualification()) 7501 composeCodeableConcept(t, "ExplanationOfBenefit", "qualification", element.getQualification(), -1); 7502 } 7503 7504 protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) { 7505 if (element == null) 7506 return; 7507 Complex t; 7508 if (Utilities.noString(parentType)) 7509 t = parent; 7510 else { 7511 t = parent.predicate("fhir:"+parentType+'.'+name); 7512 } 7513 composeBackboneElement(t, "supportingInfo", name, element, index); 7514 if (element.hasSequenceElement()) 7515 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 7516 if (element.hasCategory()) 7517 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 7518 if (element.hasCode()) 7519 composeCodeableConcept(t, "ExplanationOfBenefit", "code", element.getCode(), -1); 7520 if (element.hasTiming()) 7521 composeType(t, "ExplanationOfBenefit", "timing", element.getTiming(), -1); 7522 if (element.hasValue()) 7523 composeType(t, "ExplanationOfBenefit", "value", element.getValue(), -1); 7524 if (element.hasReason()) 7525 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 7526 } 7527 7528 protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) { 7529 if (element == null) 7530 return; 7531 Complex t; 7532 if (Utilities.noString(parentType)) 7533 t = parent; 7534 else { 7535 t = parent.predicate("fhir:"+parentType+'.'+name); 7536 } 7537 composeBackboneElement(t, "diagnosis", name, element, index); 7538 if (element.hasSequenceElement()) 7539 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 7540 if (element.hasDiagnosis()) 7541 composeType(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis(), -1); 7542 for (int i = 0; i < element.getType().size(); i++) 7543 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType().get(i), i); 7544 if (element.hasOnAdmission()) 7545 composeCodeableConcept(t, "ExplanationOfBenefit", "onAdmission", element.getOnAdmission(), -1); 7546 if (element.hasPackageCode()) 7547 composeCodeableConcept(t, "ExplanationOfBenefit", "packageCode", element.getPackageCode(), -1); 7548 } 7549 7550 protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) { 7551 if (element == null) 7552 return; 7553 Complex t; 7554 if (Utilities.noString(parentType)) 7555 t = parent; 7556 else { 7557 t = parent.predicate("fhir:"+parentType+'.'+name); 7558 } 7559 composeBackboneElement(t, "procedure", name, element, index); 7560 if (element.hasSequenceElement()) 7561 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 7562 for (int i = 0; i < element.getType().size(); i++) 7563 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType().get(i), i); 7564 if (element.hasDateElement()) 7565 composeDateTime(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 7566 if (element.hasProcedure()) 7567 composeType(t, "ExplanationOfBenefit", "procedure", element.getProcedure(), -1); 7568 for (int i = 0; i < element.getUdi().size(); i++) 7569 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 7570 } 7571 7572 protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) { 7573 if (element == null) 7574 return; 7575 Complex t; 7576 if (Utilities.noString(parentType)) 7577 t = parent; 7578 else { 7579 t = parent.predicate("fhir:"+parentType+'.'+name); 7580 } 7581 composeBackboneElement(t, "insurance", name, element, index); 7582 if (element.hasFocalElement()) 7583 composeBoolean(t, "ExplanationOfBenefit", "focal", element.getFocalElement(), -1); 7584 if (element.hasCoverage()) 7585 composeReference(t, "ExplanationOfBenefit", "coverage", element.getCoverage(), -1); 7586 for (int i = 0; i < element.getPreAuthRef().size(); i++) 7587 composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i); 7588 } 7589 7590 protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) { 7591 if (element == null) 7592 return; 7593 Complex t; 7594 if (Utilities.noString(parentType)) 7595 t = parent; 7596 else { 7597 t = parent.predicate("fhir:"+parentType+'.'+name); 7598 } 7599 composeBackboneElement(t, "accident", name, element, index); 7600 if (element.hasDateElement()) 7601 composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 7602 if (element.hasType()) 7603 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 7604 if (element.hasLocation()) 7605 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 7606 } 7607 7608 protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent element, int index) { 7609 if (element == null) 7610 return; 7611 Complex t; 7612 if (Utilities.noString(parentType)) 7613 t = parent; 7614 else { 7615 t = parent.predicate("fhir:"+parentType+'.'+name); 7616 } 7617 composeBackboneElement(t, "item", name, element, index); 7618 if (element.hasSequenceElement()) 7619 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 7620 for (int i = 0; i < element.getCareTeamSequence().size(); i++) 7621 composePositiveInt(t, "ExplanationOfBenefit", "careTeamSequence", element.getCareTeamSequence().get(i), i); 7622 for (int i = 0; i < element.getDiagnosisSequence().size(); i++) 7623 composePositiveInt(t, "ExplanationOfBenefit", "diagnosisSequence", element.getDiagnosisSequence().get(i), i); 7624 for (int i = 0; i < element.getProcedureSequence().size(); i++) 7625 composePositiveInt(t, "ExplanationOfBenefit", "procedureSequence", element.getProcedureSequence().get(i), i); 7626 for (int i = 0; i < element.getInformationSequence().size(); i++) 7627 composePositiveInt(t, "ExplanationOfBenefit", "informationSequence", element.getInformationSequence().get(i), i); 7628 if (element.hasRevenue()) 7629 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 7630 if (element.hasCategory()) 7631 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 7632 if (element.hasProductOrService()) 7633 composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1); 7634 for (int i = 0; i < element.getModifier().size(); i++) 7635 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 7636 for (int i = 0; i < element.getProgramCode().size(); i++) 7637 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 7638 if (element.hasServiced()) 7639 composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1); 7640 if (element.hasLocation()) 7641 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 7642 if (element.hasQuantity()) 7643 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 7644 if (element.hasUnitPrice()) 7645 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 7646 if (element.hasFactorElement()) 7647 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 7648 if (element.hasNet()) 7649 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 7650 for (int i = 0; i < element.getUdi().size(); i++) 7651 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 7652 if (element.hasBodySite()) 7653 composeCodeableConcept(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1); 7654 for (int i = 0; i < element.getSubSite().size(); i++) 7655 composeCodeableConcept(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i); 7656 for (int i = 0; i < element.getEncounter().size(); i++) 7657 composeReference(t, "ExplanationOfBenefit", "encounter", element.getEncounter().get(i), i); 7658 for (int i = 0; i < element.getNoteNumber().size(); i++) 7659 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 7660 for (int i = 0; i < element.getAdjudication().size(); i++) 7661 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 7662 for (int i = 0; i < element.getDetail().size(); i++) 7663 composeExplanationOfBenefitDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 7664 } 7665 7666 protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) { 7667 if (element == null) 7668 return; 7669 Complex t; 7670 if (Utilities.noString(parentType)) 7671 t = parent; 7672 else { 7673 t = parent.predicate("fhir:"+parentType+'.'+name); 7674 } 7675 composeBackboneElement(t, "adjudication", name, element, index); 7676 if (element.hasCategory()) 7677 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 7678 if (element.hasReason()) 7679 composeCodeableConcept(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 7680 if (element.hasAmount()) 7681 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 7682 if (element.hasValueElement()) 7683 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 7684 } 7685 7686 protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) { 7687 if (element == null) 7688 return; 7689 Complex t; 7690 if (Utilities.noString(parentType)) 7691 t = parent; 7692 else { 7693 t = parent.predicate("fhir:"+parentType+'.'+name); 7694 } 7695 composeBackboneElement(t, "detail", name, element, index); 7696 if (element.hasSequenceElement()) 7697 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 7698 if (element.hasRevenue()) 7699 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 7700 if (element.hasCategory()) 7701 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 7702 if (element.hasProductOrService()) 7703 composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1); 7704 for (int i = 0; i < element.getModifier().size(); i++) 7705 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 7706 for (int i = 0; i < element.getProgramCode().size(); i++) 7707 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 7708 if (element.hasQuantity()) 7709 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 7710 if (element.hasUnitPrice()) 7711 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 7712 if (element.hasFactorElement()) 7713 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 7714 if (element.hasNet()) 7715 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 7716 for (int i = 0; i < element.getUdi().size(); i++) 7717 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 7718 for (int i = 0; i < element.getNoteNumber().size(); i++) 7719 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 7720 for (int i = 0; i < element.getAdjudication().size(); i++) 7721 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 7722 for (int i = 0; i < element.getSubDetail().size(); i++) 7723 composeExplanationOfBenefitSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i); 7724 } 7725 7726 protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) { 7727 if (element == null) 7728 return; 7729 Complex t; 7730 if (Utilities.noString(parentType)) 7731 t = parent; 7732 else { 7733 t = parent.predicate("fhir:"+parentType+'.'+name); 7734 } 7735 composeBackboneElement(t, "subDetail", name, element, index); 7736 if (element.hasSequenceElement()) 7737 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 7738 if (element.hasRevenue()) 7739 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 7740 if (element.hasCategory()) 7741 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 7742 if (element.hasProductOrService()) 7743 composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1); 7744 for (int i = 0; i < element.getModifier().size(); i++) 7745 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 7746 for (int i = 0; i < element.getProgramCode().size(); i++) 7747 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 7748 if (element.hasQuantity()) 7749 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 7750 if (element.hasUnitPrice()) 7751 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 7752 if (element.hasFactorElement()) 7753 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 7754 if (element.hasNet()) 7755 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 7756 for (int i = 0; i < element.getUdi().size(); i++) 7757 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 7758 for (int i = 0; i < element.getNoteNumber().size(); i++) 7759 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 7760 for (int i = 0; i < element.getAdjudication().size(); i++) 7761 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 7762 } 7763 7764 protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) { 7765 if (element == null) 7766 return; 7767 Complex t; 7768 if (Utilities.noString(parentType)) 7769 t = parent; 7770 else { 7771 t = parent.predicate("fhir:"+parentType+'.'+name); 7772 } 7773 composeBackboneElement(t, "addItem", name, element, index); 7774 for (int i = 0; i < element.getItemSequence().size(); i++) 7775 composePositiveInt(t, "ExplanationOfBenefit", "itemSequence", element.getItemSequence().get(i), i); 7776 for (int i = 0; i < element.getDetailSequence().size(); i++) 7777 composePositiveInt(t, "ExplanationOfBenefit", "detailSequence", element.getDetailSequence().get(i), i); 7778 for (int i = 0; i < element.getSubDetailSequence().size(); i++) 7779 composePositiveInt(t, "ExplanationOfBenefit", "subDetailSequence", element.getSubDetailSequence().get(i), i); 7780 for (int i = 0; i < element.getProvider().size(); i++) 7781 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider().get(i), i); 7782 if (element.hasProductOrService()) 7783 composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1); 7784 for (int i = 0; i < element.getModifier().size(); i++) 7785 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 7786 for (int i = 0; i < element.getProgramCode().size(); i++) 7787 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 7788 if (element.hasServiced()) 7789 composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1); 7790 if (element.hasLocation()) 7791 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 7792 if (element.hasQuantity()) 7793 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 7794 if (element.hasUnitPrice()) 7795 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 7796 if (element.hasFactorElement()) 7797 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 7798 if (element.hasNet()) 7799 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 7800 if (element.hasBodySite()) 7801 composeCodeableConcept(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1); 7802 for (int i = 0; i < element.getSubSite().size(); i++) 7803 composeCodeableConcept(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i); 7804 for (int i = 0; i < element.getNoteNumber().size(); i++) 7805 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 7806 for (int i = 0; i < element.getAdjudication().size(); i++) 7807 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 7808 for (int i = 0; i < element.getDetail().size(); i++) 7809 composeExplanationOfBenefitAddedItemDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 7810 } 7811 7812 protected void composeExplanationOfBenefitAddedItemDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailComponent element, int index) { 7813 if (element == null) 7814 return; 7815 Complex t; 7816 if (Utilities.noString(parentType)) 7817 t = parent; 7818 else { 7819 t = parent.predicate("fhir:"+parentType+'.'+name); 7820 } 7821 composeBackboneElement(t, "detail", name, element, index); 7822 if (element.hasProductOrService()) 7823 composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1); 7824 for (int i = 0; i < element.getModifier().size(); i++) 7825 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 7826 if (element.hasQuantity()) 7827 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 7828 if (element.hasUnitPrice()) 7829 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 7830 if (element.hasFactorElement()) 7831 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 7832 if (element.hasNet()) 7833 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 7834 for (int i = 0; i < element.getNoteNumber().size(); i++) 7835 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 7836 for (int i = 0; i < element.getAdjudication().size(); i++) 7837 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 7838 for (int i = 0; i < element.getSubDetail().size(); i++) 7839 composeExplanationOfBenefitAddedItemDetailSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i); 7840 } 7841 7842 protected void composeExplanationOfBenefitAddedItemDetailSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailSubDetailComponent element, int index) { 7843 if (element == null) 7844 return; 7845 Complex t; 7846 if (Utilities.noString(parentType)) 7847 t = parent; 7848 else { 7849 t = parent.predicate("fhir:"+parentType+'.'+name); 7850 } 7851 composeBackboneElement(t, "subDetail", name, element, index); 7852 if (element.hasProductOrService()) 7853 composeCodeableConcept(t, "ExplanationOfBenefit", "productOrService", element.getProductOrService(), -1); 7854 for (int i = 0; i < element.getModifier().size(); i++) 7855 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 7856 if (element.hasQuantity()) 7857 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 7858 if (element.hasUnitPrice()) 7859 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 7860 if (element.hasFactorElement()) 7861 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 7862 if (element.hasNet()) 7863 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 7864 for (int i = 0; i < element.getNoteNumber().size(); i++) 7865 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 7866 for (int i = 0; i < element.getAdjudication().size(); i++) 7867 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 7868 } 7869 7870 protected void composeExplanationOfBenefitTotalComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.TotalComponent element, int index) { 7871 if (element == null) 7872 return; 7873 Complex t; 7874 if (Utilities.noString(parentType)) 7875 t = parent; 7876 else { 7877 t = parent.predicate("fhir:"+parentType+'.'+name); 7878 } 7879 composeBackboneElement(t, "total", name, element, index); 7880 if (element.hasCategory()) 7881 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 7882 if (element.hasAmount()) 7883 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 7884 } 7885 7886 protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) { 7887 if (element == null) 7888 return; 7889 Complex t; 7890 if (Utilities.noString(parentType)) 7891 t = parent; 7892 else { 7893 t = parent.predicate("fhir:"+parentType+'.'+name); 7894 } 7895 composeBackboneElement(t, "payment", name, element, index); 7896 if (element.hasType()) 7897 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 7898 if (element.hasAdjustment()) 7899 composeMoney(t, "ExplanationOfBenefit", "adjustment", element.getAdjustment(), -1); 7900 if (element.hasAdjustmentReason()) 7901 composeCodeableConcept(t, "ExplanationOfBenefit", "adjustmentReason", element.getAdjustmentReason(), -1); 7902 if (element.hasDateElement()) 7903 composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 7904 if (element.hasAmount()) 7905 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 7906 if (element.hasIdentifier()) 7907 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier(), -1); 7908 } 7909 7910 protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) { 7911 if (element == null) 7912 return; 7913 Complex t; 7914 if (Utilities.noString(parentType)) 7915 t = parent; 7916 else { 7917 t = parent.predicate("fhir:"+parentType+'.'+name); 7918 } 7919 composeBackboneElement(t, "processNote", name, element, index); 7920 if (element.hasNumberElement()) 7921 composePositiveInt(t, "ExplanationOfBenefit", "number", element.getNumberElement(), -1); 7922 if (element.hasTypeElement()) 7923 composeEnum(t, "ExplanationOfBenefit", "type", element.getTypeElement(), -1); 7924 if (element.hasTextElement()) 7925 composeString(t, "ExplanationOfBenefit", "text", element.getTextElement(), -1); 7926 if (element.hasLanguage()) 7927 composeCodeableConcept(t, "ExplanationOfBenefit", "language", element.getLanguage(), -1); 7928 } 7929 7930 protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) { 7931 if (element == null) 7932 return; 7933 Complex t; 7934 if (Utilities.noString(parentType)) 7935 t = parent; 7936 else { 7937 t = parent.predicate("fhir:"+parentType+'.'+name); 7938 } 7939 composeBackboneElement(t, "benefitBalance", name, element, index); 7940 if (element.hasCategory()) 7941 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 7942 if (element.hasExcludedElement()) 7943 composeBoolean(t, "ExplanationOfBenefit", "excluded", element.getExcludedElement(), -1); 7944 if (element.hasNameElement()) 7945 composeString(t, "ExplanationOfBenefit", "name", element.getNameElement(), -1); 7946 if (element.hasDescriptionElement()) 7947 composeString(t, "ExplanationOfBenefit", "description", element.getDescriptionElement(), -1); 7948 if (element.hasNetwork()) 7949 composeCodeableConcept(t, "ExplanationOfBenefit", "network", element.getNetwork(), -1); 7950 if (element.hasUnit()) 7951 composeCodeableConcept(t, "ExplanationOfBenefit", "unit", element.getUnit(), -1); 7952 if (element.hasTerm()) 7953 composeCodeableConcept(t, "ExplanationOfBenefit", "term", element.getTerm(), -1); 7954 for (int i = 0; i < element.getFinancial().size(); i++) 7955 composeExplanationOfBenefitBenefitComponent(t, "ExplanationOfBenefit", "financial", element.getFinancial().get(i), i); 7956 } 7957 7958 protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) { 7959 if (element == null) 7960 return; 7961 Complex t; 7962 if (Utilities.noString(parentType)) 7963 t = parent; 7964 else { 7965 t = parent.predicate("fhir:"+parentType+'.'+name); 7966 } 7967 composeBackboneElement(t, "financial", name, element, index); 7968 if (element.hasType()) 7969 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 7970 if (element.hasAllowed()) 7971 composeType(t, "ExplanationOfBenefit", "allowed", element.getAllowed(), -1); 7972 if (element.hasUsed()) 7973 composeType(t, "ExplanationOfBenefit", "used", element.getUsed(), -1); 7974 } 7975 7976 protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) { 7977 if (element == null) 7978 return; 7979 Complex t; 7980 if (Utilities.noString(parentType)) 7981 t = parent; 7982 else { 7983 t = parent.predicate("fhir:"+parentType+'.'+name); 7984 } 7985 composeDomainResource(t, "FamilyMemberHistory", name, element, index); 7986 for (int i = 0; i < element.getIdentifier().size(); i++) 7987 composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i); 7988 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 7989 composeCanonical(t, "FamilyMemberHistory", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 7990 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 7991 composeUri(t, "FamilyMemberHistory", "instantiatesUri", element.getInstantiatesUri().get(i), i); 7992 if (element.hasStatusElement()) 7993 composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1); 7994 if (element.hasDataAbsentReason()) 7995 composeCodeableConcept(t, "FamilyMemberHistory", "dataAbsentReason", element.getDataAbsentReason(), -1); 7996 if (element.hasPatient()) 7997 composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1); 7998 if (element.hasDateElement()) 7999 composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1); 8000 if (element.hasNameElement()) 8001 composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1); 8002 if (element.hasRelationship()) 8003 composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1); 8004 if (element.hasSex()) 8005 composeCodeableConcept(t, "FamilyMemberHistory", "sex", element.getSex(), -1); 8006 if (element.hasBorn()) 8007 composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1); 8008 if (element.hasAge()) 8009 composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1); 8010 if (element.hasEstimatedAgeElement()) 8011 composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1); 8012 if (element.hasDeceased()) 8013 composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1); 8014 for (int i = 0; i < element.getReasonCode().size(); i++) 8015 composeCodeableConcept(t, "FamilyMemberHistory", "reasonCode", element.getReasonCode().get(i), i); 8016 for (int i = 0; i < element.getReasonReference().size(); i++) 8017 composeReference(t, "FamilyMemberHistory", "reasonReference", element.getReasonReference().get(i), i); 8018 for (int i = 0; i < element.getNote().size(); i++) 8019 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 8020 for (int i = 0; i < element.getCondition().size(); i++) 8021 composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i); 8022 } 8023 8024 protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) { 8025 if (element == null) 8026 return; 8027 Complex t; 8028 if (Utilities.noString(parentType)) 8029 t = parent; 8030 else { 8031 t = parent.predicate("fhir:"+parentType+'.'+name); 8032 } 8033 composeBackboneElement(t, "condition", name, element, index); 8034 if (element.hasCode()) 8035 composeCodeableConcept(t, "FamilyMemberHistory", "code", element.getCode(), -1); 8036 if (element.hasOutcome()) 8037 composeCodeableConcept(t, "FamilyMemberHistory", "outcome", element.getOutcome(), -1); 8038 if (element.hasContributedToDeathElement()) 8039 composeBoolean(t, "FamilyMemberHistory", "contributedToDeath", element.getContributedToDeathElement(), -1); 8040 if (element.hasOnset()) 8041 composeType(t, "FamilyMemberHistory", "onset", element.getOnset(), -1); 8042 for (int i = 0; i < element.getNote().size(); i++) 8043 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 8044 } 8045 8046 protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) { 8047 if (element == null) 8048 return; 8049 Complex t; 8050 if (Utilities.noString(parentType)) 8051 t = parent; 8052 else { 8053 t = parent.predicate("fhir:"+parentType+'.'+name); 8054 } 8055 composeDomainResource(t, "Flag", name, element, index); 8056 for (int i = 0; i < element.getIdentifier().size(); i++) 8057 composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i); 8058 if (element.hasStatusElement()) 8059 composeEnum(t, "Flag", "status", element.getStatusElement(), -1); 8060 for (int i = 0; i < element.getCategory().size(); i++) 8061 composeCodeableConcept(t, "Flag", "category", element.getCategory().get(i), i); 8062 if (element.hasCode()) 8063 composeCodeableConcept(t, "Flag", "code", element.getCode(), -1); 8064 if (element.hasSubject()) 8065 composeReference(t, "Flag", "subject", element.getSubject(), -1); 8066 if (element.hasPeriod()) 8067 composePeriod(t, "Flag", "period", element.getPeriod(), -1); 8068 if (element.hasEncounter()) 8069 composeReference(t, "Flag", "encounter", element.getEncounter(), -1); 8070 if (element.hasAuthor()) 8071 composeReference(t, "Flag", "author", element.getAuthor(), -1); 8072 } 8073 8074 protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) { 8075 if (element == null) 8076 return; 8077 Complex t; 8078 if (Utilities.noString(parentType)) 8079 t = parent; 8080 else { 8081 t = parent.predicate("fhir:"+parentType+'.'+name); 8082 } 8083 composeDomainResource(t, "Goal", name, element, index); 8084 for (int i = 0; i < element.getIdentifier().size(); i++) 8085 composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i); 8086 if (element.hasLifecycleStatusElement()) 8087 composeEnum(t, "Goal", "lifecycleStatus", element.getLifecycleStatusElement(), -1); 8088 if (element.hasAchievementStatus()) 8089 composeCodeableConcept(t, "Goal", "achievementStatus", element.getAchievementStatus(), -1); 8090 for (int i = 0; i < element.getCategory().size(); i++) 8091 composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i); 8092 if (element.hasPriority()) 8093 composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1); 8094 if (element.hasDescription()) 8095 composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1); 8096 if (element.hasSubject()) 8097 composeReference(t, "Goal", "subject", element.getSubject(), -1); 8098 if (element.hasStart()) 8099 composeType(t, "Goal", "start", element.getStart(), -1); 8100 for (int i = 0; i < element.getTarget().size(); i++) 8101 composeGoalGoalTargetComponent(t, "Goal", "target", element.getTarget().get(i), i); 8102 if (element.hasStatusDateElement()) 8103 composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1); 8104 if (element.hasStatusReasonElement()) 8105 composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1); 8106 if (element.hasExpressedBy()) 8107 composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1); 8108 for (int i = 0; i < element.getAddresses().size(); i++) 8109 composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i); 8110 for (int i = 0; i < element.getNote().size(); i++) 8111 composeAnnotation(t, "Goal", "note", element.getNote().get(i), i); 8112 for (int i = 0; i < element.getOutcomeCode().size(); i++) 8113 composeCodeableConcept(t, "Goal", "outcomeCode", element.getOutcomeCode().get(i), i); 8114 for (int i = 0; i < element.getOutcomeReference().size(); i++) 8115 composeReference(t, "Goal", "outcomeReference", element.getOutcomeReference().get(i), i); 8116 } 8117 8118 protected void composeGoalGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent element, int index) { 8119 if (element == null) 8120 return; 8121 Complex t; 8122 if (Utilities.noString(parentType)) 8123 t = parent; 8124 else { 8125 t = parent.predicate("fhir:"+parentType+'.'+name); 8126 } 8127 composeBackboneElement(t, "target", name, element, index); 8128 if (element.hasMeasure()) 8129 composeCodeableConcept(t, "Goal", "measure", element.getMeasure(), -1); 8130 if (element.hasDetail()) 8131 composeType(t, "Goal", "detail", element.getDetail(), -1); 8132 if (element.hasDue()) 8133 composeType(t, "Goal", "due", element.getDue(), -1); 8134 } 8135 8136 protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) { 8137 if (element == null) 8138 return; 8139 Complex t; 8140 if (Utilities.noString(parentType)) 8141 t = parent; 8142 else { 8143 t = parent.predicate("fhir:"+parentType+'.'+name); 8144 } 8145 composeDomainResource(t, "GraphDefinition", name, element, index); 8146 if (element.hasUrlElement()) 8147 composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1); 8148 if (element.hasVersionElement()) 8149 composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1); 8150 if (element.hasNameElement()) 8151 composeString(t, "GraphDefinition", "name", element.getNameElement(), -1); 8152 if (element.hasStatusElement()) 8153 composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1); 8154 if (element.hasExperimentalElement()) 8155 composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1); 8156 if (element.hasDateElement()) 8157 composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1); 8158 if (element.hasPublisherElement()) 8159 composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1); 8160 for (int i = 0; i < element.getContact().size(); i++) 8161 composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i); 8162 if (element.hasDescriptionElement()) 8163 composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 8164 for (int i = 0; i < element.getUseContext().size(); i++) 8165 composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i); 8166 for (int i = 0; i < element.getJurisdiction().size(); i++) 8167 composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 8168 if (element.hasPurposeElement()) 8169 composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1); 8170 if (element.hasStartElement()) 8171 composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1); 8172 if (element.hasProfileElement()) 8173 composeCanonical(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 8174 for (int i = 0; i < element.getLink().size(); i++) 8175 composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 8176 } 8177 8178 protected void composeGraphDefinitionGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) { 8179 if (element == null) 8180 return; 8181 Complex t; 8182 if (Utilities.noString(parentType)) 8183 t = parent; 8184 else { 8185 t = parent.predicate("fhir:"+parentType+'.'+name); 8186 } 8187 composeBackboneElement(t, "link", name, element, index); 8188 if (element.hasPathElement()) 8189 composeString(t, "GraphDefinition", "path", element.getPathElement(), -1); 8190 if (element.hasSliceNameElement()) 8191 composeString(t, "GraphDefinition", "sliceName", element.getSliceNameElement(), -1); 8192 if (element.hasMinElement()) 8193 composeInteger(t, "GraphDefinition", "min", element.getMinElement(), -1); 8194 if (element.hasMaxElement()) 8195 composeString(t, "GraphDefinition", "max", element.getMaxElement(), -1); 8196 if (element.hasDescriptionElement()) 8197 composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 8198 for (int i = 0; i < element.getTarget().size(); i++) 8199 composeGraphDefinitionGraphDefinitionLinkTargetComponent(t, "GraphDefinition", "target", element.getTarget().get(i), i); 8200 } 8201 8202 protected void composeGraphDefinitionGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) { 8203 if (element == null) 8204 return; 8205 Complex t; 8206 if (Utilities.noString(parentType)) 8207 t = parent; 8208 else { 8209 t = parent.predicate("fhir:"+parentType+'.'+name); 8210 } 8211 composeBackboneElement(t, "target", name, element, index); 8212 if (element.hasTypeElement()) 8213 composeCode(t, "GraphDefinition", "type", element.getTypeElement(), -1); 8214 if (element.hasParamsElement()) 8215 composeString(t, "GraphDefinition", "params", element.getParamsElement(), -1); 8216 if (element.hasProfileElement()) 8217 composeCanonical(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 8218 for (int i = 0; i < element.getCompartment().size(); i++) 8219 composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinition", "compartment", element.getCompartment().get(i), i); 8220 for (int i = 0; i < element.getLink().size(); i++) 8221 composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 8222 } 8223 8224 protected void composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent element, int index) { 8225 if (element == null) 8226 return; 8227 Complex t; 8228 if (Utilities.noString(parentType)) 8229 t = parent; 8230 else { 8231 t = parent.predicate("fhir:"+parentType+'.'+name); 8232 } 8233 composeBackboneElement(t, "compartment", name, element, index); 8234 if (element.hasUseElement()) 8235 composeEnum(t, "GraphDefinition", "use", element.getUseElement(), -1); 8236 if (element.hasCodeElement()) 8237 composeEnum(t, "GraphDefinition", "code", element.getCodeElement(), -1); 8238 if (element.hasRuleElement()) 8239 composeEnum(t, "GraphDefinition", "rule", element.getRuleElement(), -1); 8240 if (element.hasExpressionElement()) 8241 composeString(t, "GraphDefinition", "expression", element.getExpressionElement(), -1); 8242 if (element.hasDescriptionElement()) 8243 composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 8244 } 8245 8246 protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) { 8247 if (element == null) 8248 return; 8249 Complex t; 8250 if (Utilities.noString(parentType)) 8251 t = parent; 8252 else { 8253 t = parent.predicate("fhir:"+parentType+'.'+name); 8254 } 8255 composeDomainResource(t, "Group", name, element, index); 8256 for (int i = 0; i < element.getIdentifier().size(); i++) 8257 composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i); 8258 if (element.hasActiveElement()) 8259 composeBoolean(t, "Group", "active", element.getActiveElement(), -1); 8260 if (element.hasTypeElement()) 8261 composeEnum(t, "Group", "type", element.getTypeElement(), -1); 8262 if (element.hasActualElement()) 8263 composeBoolean(t, "Group", "actual", element.getActualElement(), -1); 8264 if (element.hasCode()) 8265 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 8266 if (element.hasNameElement()) 8267 composeString(t, "Group", "name", element.getNameElement(), -1); 8268 if (element.hasQuantityElement()) 8269 composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1); 8270 if (element.hasManagingEntity()) 8271 composeReference(t, "Group", "managingEntity", element.getManagingEntity(), -1); 8272 for (int i = 0; i < element.getCharacteristic().size(); i++) 8273 composeGroupGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i); 8274 for (int i = 0; i < element.getMember().size(); i++) 8275 composeGroupGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i); 8276 } 8277 8278 protected void composeGroupGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) { 8279 if (element == null) 8280 return; 8281 Complex t; 8282 if (Utilities.noString(parentType)) 8283 t = parent; 8284 else { 8285 t = parent.predicate("fhir:"+parentType+'.'+name); 8286 } 8287 composeBackboneElement(t, "characteristic", name, element, index); 8288 if (element.hasCode()) 8289 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 8290 if (element.hasValue()) 8291 composeType(t, "Group", "value", element.getValue(), -1); 8292 if (element.hasExcludeElement()) 8293 composeBoolean(t, "Group", "exclude", element.getExcludeElement(), -1); 8294 if (element.hasPeriod()) 8295 composePeriod(t, "Group", "period", element.getPeriod(), -1); 8296 } 8297 8298 protected void composeGroupGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) { 8299 if (element == null) 8300 return; 8301 Complex t; 8302 if (Utilities.noString(parentType)) 8303 t = parent; 8304 else { 8305 t = parent.predicate("fhir:"+parentType+'.'+name); 8306 } 8307 composeBackboneElement(t, "member", name, element, index); 8308 if (element.hasEntity()) 8309 composeReference(t, "Group", "entity", element.getEntity(), -1); 8310 if (element.hasPeriod()) 8311 composePeriod(t, "Group", "period", element.getPeriod(), -1); 8312 if (element.hasInactiveElement()) 8313 composeBoolean(t, "Group", "inactive", element.getInactiveElement(), -1); 8314 } 8315 8316 protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) { 8317 if (element == null) 8318 return; 8319 Complex t; 8320 if (Utilities.noString(parentType)) 8321 t = parent; 8322 else { 8323 t = parent.predicate("fhir:"+parentType+'.'+name); 8324 } 8325 composeDomainResource(t, "GuidanceResponse", name, element, index); 8326 if (element.hasRequestIdentifier()) 8327 composeIdentifier(t, "GuidanceResponse", "requestIdentifier", element.getRequestIdentifier(), -1); 8328 for (int i = 0; i < element.getIdentifier().size(); i++) 8329 composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier().get(i), i); 8330 if (element.hasModule()) 8331 composeType(t, "GuidanceResponse", "module", element.getModule(), -1); 8332 if (element.hasStatusElement()) 8333 composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1); 8334 if (element.hasSubject()) 8335 composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1); 8336 if (element.hasEncounter()) 8337 composeReference(t, "GuidanceResponse", "encounter", element.getEncounter(), -1); 8338 if (element.hasOccurrenceDateTimeElement()) 8339 composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1); 8340 if (element.hasPerformer()) 8341 composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1); 8342 for (int i = 0; i < element.getReasonCode().size(); i++) 8343 composeCodeableConcept(t, "GuidanceResponse", "reasonCode", element.getReasonCode().get(i), i); 8344 for (int i = 0; i < element.getReasonReference().size(); i++) 8345 composeReference(t, "GuidanceResponse", "reasonReference", element.getReasonReference().get(i), i); 8346 for (int i = 0; i < element.getNote().size(); i++) 8347 composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i); 8348 for (int i = 0; i < element.getEvaluationMessage().size(); i++) 8349 composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i); 8350 if (element.hasOutputParameters()) 8351 composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1); 8352 if (element.hasResult()) 8353 composeReference(t, "GuidanceResponse", "result", element.getResult(), -1); 8354 for (int i = 0; i < element.getDataRequirement().size(); i++) 8355 composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i); 8356 } 8357 8358 protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) { 8359 if (element == null) 8360 return; 8361 Complex t; 8362 if (Utilities.noString(parentType)) 8363 t = parent; 8364 else { 8365 t = parent.predicate("fhir:"+parentType+'.'+name); 8366 } 8367 composeDomainResource(t, "HealthcareService", name, element, index); 8368 for (int i = 0; i < element.getIdentifier().size(); i++) 8369 composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i); 8370 if (element.hasActiveElement()) 8371 composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1); 8372 if (element.hasProvidedBy()) 8373 composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1); 8374 for (int i = 0; i < element.getCategory().size(); i++) 8375 composeCodeableConcept(t, "HealthcareService", "category", element.getCategory().get(i), i); 8376 for (int i = 0; i < element.getType().size(); i++) 8377 composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i); 8378 for (int i = 0; i < element.getSpecialty().size(); i++) 8379 composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i); 8380 for (int i = 0; i < element.getLocation().size(); i++) 8381 composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i); 8382 if (element.hasNameElement()) 8383 composeString(t, "HealthcareService", "name", element.getNameElement(), -1); 8384 if (element.hasCommentElement()) 8385 composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1); 8386 if (element.hasExtraDetailsElement()) 8387 composeMarkdown(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1); 8388 if (element.hasPhoto()) 8389 composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1); 8390 for (int i = 0; i < element.getTelecom().size(); i++) 8391 composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i); 8392 for (int i = 0; i < element.getCoverageArea().size(); i++) 8393 composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i); 8394 for (int i = 0; i < element.getServiceProvisionCode().size(); i++) 8395 composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i); 8396 for (int i = 0; i < element.getEligibility().size(); i++) 8397 composeHealthcareServiceHealthcareServiceEligibilityComponent(t, "HealthcareService", "eligibility", element.getEligibility().get(i), i); 8398 for (int i = 0; i < element.getProgram().size(); i++) 8399 composeCodeableConcept(t, "HealthcareService", "program", element.getProgram().get(i), i); 8400 for (int i = 0; i < element.getCharacteristic().size(); i++) 8401 composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i); 8402 for (int i = 0; i < element.getCommunication().size(); i++) 8403 composeCodeableConcept(t, "HealthcareService", "communication", element.getCommunication().get(i), i); 8404 for (int i = 0; i < element.getReferralMethod().size(); i++) 8405 composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i); 8406 if (element.hasAppointmentRequiredElement()) 8407 composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1); 8408 for (int i = 0; i < element.getAvailableTime().size(); i++) 8409 composeHealthcareServiceHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i); 8410 for (int i = 0; i < element.getNotAvailable().size(); i++) 8411 composeHealthcareServiceHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i); 8412 if (element.hasAvailabilityExceptionsElement()) 8413 composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 8414 for (int i = 0; i < element.getEndpoint().size(); i++) 8415 composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i); 8416 } 8417 8418 protected void composeHealthcareServiceHealthcareServiceEligibilityComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceEligibilityComponent element, int index) { 8419 if (element == null) 8420 return; 8421 Complex t; 8422 if (Utilities.noString(parentType)) 8423 t = parent; 8424 else { 8425 t = parent.predicate("fhir:"+parentType+'.'+name); 8426 } 8427 composeBackboneElement(t, "eligibility", name, element, index); 8428 if (element.hasCode()) 8429 composeCodeableConcept(t, "HealthcareService", "code", element.getCode(), -1); 8430 if (element.hasCommentElement()) 8431 composeMarkdown(t, "HealthcareService", "comment", element.getCommentElement(), -1); 8432 } 8433 8434 protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) { 8435 if (element == null) 8436 return; 8437 Complex t; 8438 if (Utilities.noString(parentType)) 8439 t = parent; 8440 else { 8441 t = parent.predicate("fhir:"+parentType+'.'+name); 8442 } 8443 composeBackboneElement(t, "availableTime", name, element, index); 8444 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 8445 composeEnum(t, "HealthcareService", "daysOfWeek", element.getDaysOfWeek().get(i), i); 8446 if (element.hasAllDayElement()) 8447 composeBoolean(t, "HealthcareService", "allDay", element.getAllDayElement(), -1); 8448 if (element.hasAvailableStartTimeElement()) 8449 composeTime(t, "HealthcareService", "availableStartTime", element.getAvailableStartTimeElement(), -1); 8450 if (element.hasAvailableEndTimeElement()) 8451 composeTime(t, "HealthcareService", "availableEndTime", element.getAvailableEndTimeElement(), -1); 8452 } 8453 8454 protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) { 8455 if (element == null) 8456 return; 8457 Complex t; 8458 if (Utilities.noString(parentType)) 8459 t = parent; 8460 else { 8461 t = parent.predicate("fhir:"+parentType+'.'+name); 8462 } 8463 composeBackboneElement(t, "notAvailable", name, element, index); 8464 if (element.hasDescriptionElement()) 8465 composeString(t, "HealthcareService", "description", element.getDescriptionElement(), -1); 8466 if (element.hasDuring()) 8467 composePeriod(t, "HealthcareService", "during", element.getDuring(), -1); 8468 } 8469 8470 protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) { 8471 if (element == null) 8472 return; 8473 Complex t; 8474 if (Utilities.noString(parentType)) 8475 t = parent; 8476 else { 8477 t = parent.predicate("fhir:"+parentType+'.'+name); 8478 } 8479 composeDomainResource(t, "ImagingStudy", name, element, index); 8480 for (int i = 0; i < element.getIdentifier().size(); i++) 8481 composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i); 8482 if (element.hasStatusElement()) 8483 composeEnum(t, "ImagingStudy", "status", element.getStatusElement(), -1); 8484 for (int i = 0; i < element.getModality().size(); i++) 8485 composeCoding(t, "ImagingStudy", "modality", element.getModality().get(i), i); 8486 if (element.hasSubject()) 8487 composeReference(t, "ImagingStudy", "subject", element.getSubject(), -1); 8488 if (element.hasEncounter()) 8489 composeReference(t, "ImagingStudy", "encounter", element.getEncounter(), -1); 8490 if (element.hasStartedElement()) 8491 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 8492 for (int i = 0; i < element.getBasedOn().size(); i++) 8493 composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i); 8494 if (element.hasReferrer()) 8495 composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1); 8496 for (int i = 0; i < element.getInterpreter().size(); i++) 8497 composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i); 8498 for (int i = 0; i < element.getEndpoint().size(); i++) 8499 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 8500 if (element.hasNumberOfSeriesElement()) 8501 composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1); 8502 if (element.hasNumberOfInstancesElement()) 8503 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 8504 if (element.hasProcedureReference()) 8505 composeReference(t, "ImagingStudy", "procedureReference", element.getProcedureReference(), -1); 8506 for (int i = 0; i < element.getProcedureCode().size(); i++) 8507 composeCodeableConcept(t, "ImagingStudy", "procedureCode", element.getProcedureCode().get(i), i); 8508 if (element.hasLocation()) 8509 composeReference(t, "ImagingStudy", "location", element.getLocation(), -1); 8510 for (int i = 0; i < element.getReasonCode().size(); i++) 8511 composeCodeableConcept(t, "ImagingStudy", "reasonCode", element.getReasonCode().get(i), i); 8512 for (int i = 0; i < element.getReasonReference().size(); i++) 8513 composeReference(t, "ImagingStudy", "reasonReference", element.getReasonReference().get(i), i); 8514 for (int i = 0; i < element.getNote().size(); i++) 8515 composeAnnotation(t, "ImagingStudy", "note", element.getNote().get(i), i); 8516 if (element.hasDescriptionElement()) 8517 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 8518 for (int i = 0; i < element.getSeries().size(); i++) 8519 composeImagingStudyImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i); 8520 } 8521 8522 protected void composeImagingStudyImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) { 8523 if (element == null) 8524 return; 8525 Complex t; 8526 if (Utilities.noString(parentType)) 8527 t = parent; 8528 else { 8529 t = parent.predicate("fhir:"+parentType+'.'+name); 8530 } 8531 composeBackboneElement(t, "series", name, element, index); 8532 if (element.hasUidElement()) 8533 composeId(t, "ImagingStudy", "uid", element.getUidElement(), -1); 8534 if (element.hasNumberElement()) 8535 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 8536 if (element.hasModality()) 8537 composeCoding(t, "ImagingStudy", "modality", element.getModality(), -1); 8538 if (element.hasDescriptionElement()) 8539 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 8540 if (element.hasNumberOfInstancesElement()) 8541 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 8542 for (int i = 0; i < element.getEndpoint().size(); i++) 8543 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 8544 if (element.hasBodySite()) 8545 composeCoding(t, "ImagingStudy", "bodySite", element.getBodySite(), -1); 8546 if (element.hasLaterality()) 8547 composeCoding(t, "ImagingStudy", "laterality", element.getLaterality(), -1); 8548 for (int i = 0; i < element.getSpecimen().size(); i++) 8549 composeReference(t, "ImagingStudy", "specimen", element.getSpecimen().get(i), i); 8550 if (element.hasStartedElement()) 8551 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 8552 for (int i = 0; i < element.getPerformer().size(); i++) 8553 composeImagingStudyImagingStudySeriesPerformerComponent(t, "ImagingStudy", "performer", element.getPerformer().get(i), i); 8554 for (int i = 0; i < element.getInstance().size(); i++) 8555 composeImagingStudyImagingStudySeriesInstanceComponent(t, "ImagingStudy", "instance", element.getInstance().get(i), i); 8556 } 8557 8558 protected void composeImagingStudyImagingStudySeriesPerformerComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesPerformerComponent element, int index) { 8559 if (element == null) 8560 return; 8561 Complex t; 8562 if (Utilities.noString(parentType)) 8563 t = parent; 8564 else { 8565 t = parent.predicate("fhir:"+parentType+'.'+name); 8566 } 8567 composeBackboneElement(t, "performer", name, element, index); 8568 if (element.hasFunction()) 8569 composeCodeableConcept(t, "ImagingStudy", "function", element.getFunction(), -1); 8570 if (element.hasActor()) 8571 composeReference(t, "ImagingStudy", "actor", element.getActor(), -1); 8572 } 8573 8574 protected void composeImagingStudyImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) { 8575 if (element == null) 8576 return; 8577 Complex t; 8578 if (Utilities.noString(parentType)) 8579 t = parent; 8580 else { 8581 t = parent.predicate("fhir:"+parentType+'.'+name); 8582 } 8583 composeBackboneElement(t, "instance", name, element, index); 8584 if (element.hasUidElement()) 8585 composeId(t, "ImagingStudy", "uid", element.getUidElement(), -1); 8586 if (element.hasSopClass()) 8587 composeCoding(t, "ImagingStudy", "sopClass", element.getSopClass(), -1); 8588 if (element.hasNumberElement()) 8589 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 8590 if (element.hasTitleElement()) 8591 composeString(t, "ImagingStudy", "title", element.getTitleElement(), -1); 8592 } 8593 8594 protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) { 8595 if (element == null) 8596 return; 8597 Complex t; 8598 if (Utilities.noString(parentType)) 8599 t = parent; 8600 else { 8601 t = parent.predicate("fhir:"+parentType+'.'+name); 8602 } 8603 composeDomainResource(t, "Immunization", name, element, index); 8604 for (int i = 0; i < element.getIdentifier().size(); i++) 8605 composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i); 8606 if (element.hasStatusElement()) 8607 composeEnum(t, "Immunization", "status", element.getStatusElement(), -1); 8608 if (element.hasStatusReason()) 8609 composeCodeableConcept(t, "Immunization", "statusReason", element.getStatusReason(), -1); 8610 if (element.hasVaccineCode()) 8611 composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1); 8612 if (element.hasPatient()) 8613 composeReference(t, "Immunization", "patient", element.getPatient(), -1); 8614 if (element.hasEncounter()) 8615 composeReference(t, "Immunization", "encounter", element.getEncounter(), -1); 8616 if (element.hasOccurrence()) 8617 composeType(t, "Immunization", "occurrence", element.getOccurrence(), -1); 8618 if (element.hasRecordedElement()) 8619 composeDateTime(t, "Immunization", "recorded", element.getRecordedElement(), -1); 8620 if (element.hasPrimarySourceElement()) 8621 composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1); 8622 if (element.hasReportOrigin()) 8623 composeCodeableConcept(t, "Immunization", "reportOrigin", element.getReportOrigin(), -1); 8624 if (element.hasLocation()) 8625 composeReference(t, "Immunization", "location", element.getLocation(), -1); 8626 if (element.hasManufacturer()) 8627 composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1); 8628 if (element.hasLotNumberElement()) 8629 composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1); 8630 if (element.hasExpirationDateElement()) 8631 composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1); 8632 if (element.hasSite()) 8633 composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1); 8634 if (element.hasRoute()) 8635 composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1); 8636 if (element.hasDoseQuantity()) 8637 composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1); 8638 for (int i = 0; i < element.getPerformer().size(); i++) 8639 composeImmunizationImmunizationPerformerComponent(t, "Immunization", "performer", element.getPerformer().get(i), i); 8640 for (int i = 0; i < element.getNote().size(); i++) 8641 composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i); 8642 for (int i = 0; i < element.getReasonCode().size(); i++) 8643 composeCodeableConcept(t, "Immunization", "reasonCode", element.getReasonCode().get(i), i); 8644 for (int i = 0; i < element.getReasonReference().size(); i++) 8645 composeReference(t, "Immunization", "reasonReference", element.getReasonReference().get(i), i); 8646 if (element.hasIsSubpotentElement()) 8647 composeBoolean(t, "Immunization", "isSubpotent", element.getIsSubpotentElement(), -1); 8648 for (int i = 0; i < element.getSubpotentReason().size(); i++) 8649 composeCodeableConcept(t, "Immunization", "subpotentReason", element.getSubpotentReason().get(i), i); 8650 for (int i = 0; i < element.getEducation().size(); i++) 8651 composeImmunizationImmunizationEducationComponent(t, "Immunization", "education", element.getEducation().get(i), i); 8652 for (int i = 0; i < element.getProgramEligibility().size(); i++) 8653 composeCodeableConcept(t, "Immunization", "programEligibility", element.getProgramEligibility().get(i), i); 8654 if (element.hasFundingSource()) 8655 composeCodeableConcept(t, "Immunization", "fundingSource", element.getFundingSource(), -1); 8656 for (int i = 0; i < element.getReaction().size(); i++) 8657 composeImmunizationImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i); 8658 for (int i = 0; i < element.getProtocolApplied().size(); i++) 8659 composeImmunizationImmunizationProtocolAppliedComponent(t, "Immunization", "protocolApplied", element.getProtocolApplied().get(i), i); 8660 } 8661 8662 protected void composeImmunizationImmunizationPerformerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPerformerComponent element, int index) { 8663 if (element == null) 8664 return; 8665 Complex t; 8666 if (Utilities.noString(parentType)) 8667 t = parent; 8668 else { 8669 t = parent.predicate("fhir:"+parentType+'.'+name); 8670 } 8671 composeBackboneElement(t, "performer", name, element, index); 8672 if (element.hasFunction()) 8673 composeCodeableConcept(t, "Immunization", "function", element.getFunction(), -1); 8674 if (element.hasActor()) 8675 composeReference(t, "Immunization", "actor", element.getActor(), -1); 8676 } 8677 8678 protected void composeImmunizationImmunizationEducationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationEducationComponent element, int index) { 8679 if (element == null) 8680 return; 8681 Complex t; 8682 if (Utilities.noString(parentType)) 8683 t = parent; 8684 else { 8685 t = parent.predicate("fhir:"+parentType+'.'+name); 8686 } 8687 composeBackboneElement(t, "education", name, element, index); 8688 if (element.hasDocumentTypeElement()) 8689 composeString(t, "Immunization", "documentType", element.getDocumentTypeElement(), -1); 8690 if (element.hasReferenceElement()) 8691 composeUri(t, "Immunization", "reference", element.getReferenceElement(), -1); 8692 if (element.hasPublicationDateElement()) 8693 composeDateTime(t, "Immunization", "publicationDate", element.getPublicationDateElement(), -1); 8694 if (element.hasPresentationDateElement()) 8695 composeDateTime(t, "Immunization", "presentationDate", element.getPresentationDateElement(), -1); 8696 } 8697 8698 protected void composeImmunizationImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) { 8699 if (element == null) 8700 return; 8701 Complex t; 8702 if (Utilities.noString(parentType)) 8703 t = parent; 8704 else { 8705 t = parent.predicate("fhir:"+parentType+'.'+name); 8706 } 8707 composeBackboneElement(t, "reaction", name, element, index); 8708 if (element.hasDateElement()) 8709 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 8710 if (element.hasDetail()) 8711 composeReference(t, "Immunization", "detail", element.getDetail(), -1); 8712 if (element.hasReportedElement()) 8713 composeBoolean(t, "Immunization", "reported", element.getReportedElement(), -1); 8714 } 8715 8716 protected void composeImmunizationImmunizationProtocolAppliedComponent(Complex parent, String parentType, String name, Immunization.ImmunizationProtocolAppliedComponent element, int index) { 8717 if (element == null) 8718 return; 8719 Complex t; 8720 if (Utilities.noString(parentType)) 8721 t = parent; 8722 else { 8723 t = parent.predicate("fhir:"+parentType+'.'+name); 8724 } 8725 composeBackboneElement(t, "protocolApplied", name, element, index); 8726 if (element.hasSeriesElement()) 8727 composeString(t, "Immunization", "series", element.getSeriesElement(), -1); 8728 if (element.hasAuthority()) 8729 composeReference(t, "Immunization", "authority", element.getAuthority(), -1); 8730 for (int i = 0; i < element.getTargetDisease().size(); i++) 8731 composeCodeableConcept(t, "Immunization", "targetDisease", element.getTargetDisease().get(i), i); 8732 if (element.hasDoseNumber()) 8733 composeType(t, "Immunization", "doseNumber", element.getDoseNumber(), -1); 8734 if (element.hasSeriesDoses()) 8735 composeType(t, "Immunization", "seriesDoses", element.getSeriesDoses(), -1); 8736 } 8737 8738 protected void composeImmunizationEvaluation(Complex parent, String parentType, String name, ImmunizationEvaluation element, int index) { 8739 if (element == null) 8740 return; 8741 Complex t; 8742 if (Utilities.noString(parentType)) 8743 t = parent; 8744 else { 8745 t = parent.predicate("fhir:"+parentType+'.'+name); 8746 } 8747 composeDomainResource(t, "ImmunizationEvaluation", name, element, index); 8748 for (int i = 0; i < element.getIdentifier().size(); i++) 8749 composeIdentifier(t, "ImmunizationEvaluation", "identifier", element.getIdentifier().get(i), i); 8750 if (element.hasStatusElement()) 8751 composeEnum(t, "ImmunizationEvaluation", "status", element.getStatusElement(), -1); 8752 if (element.hasPatient()) 8753 composeReference(t, "ImmunizationEvaluation", "patient", element.getPatient(), -1); 8754 if (element.hasDateElement()) 8755 composeDateTime(t, "ImmunizationEvaluation", "date", element.getDateElement(), -1); 8756 if (element.hasAuthority()) 8757 composeReference(t, "ImmunizationEvaluation", "authority", element.getAuthority(), -1); 8758 if (element.hasTargetDisease()) 8759 composeCodeableConcept(t, "ImmunizationEvaluation", "targetDisease", element.getTargetDisease(), -1); 8760 if (element.hasImmunizationEvent()) 8761 composeReference(t, "ImmunizationEvaluation", "immunizationEvent", element.getImmunizationEvent(), -1); 8762 if (element.hasDoseStatus()) 8763 composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatus", element.getDoseStatus(), -1); 8764 for (int i = 0; i < element.getDoseStatusReason().size(); i++) 8765 composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatusReason", element.getDoseStatusReason().get(i), i); 8766 if (element.hasDescriptionElement()) 8767 composeString(t, "ImmunizationEvaluation", "description", element.getDescriptionElement(), -1); 8768 if (element.hasSeriesElement()) 8769 composeString(t, "ImmunizationEvaluation", "series", element.getSeriesElement(), -1); 8770 if (element.hasDoseNumber()) 8771 composeType(t, "ImmunizationEvaluation", "doseNumber", element.getDoseNumber(), -1); 8772 if (element.hasSeriesDoses()) 8773 composeType(t, "ImmunizationEvaluation", "seriesDoses", element.getSeriesDoses(), -1); 8774 } 8775 8776 protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) { 8777 if (element == null) 8778 return; 8779 Complex t; 8780 if (Utilities.noString(parentType)) 8781 t = parent; 8782 else { 8783 t = parent.predicate("fhir:"+parentType+'.'+name); 8784 } 8785 composeDomainResource(t, "ImmunizationRecommendation", name, element, index); 8786 for (int i = 0; i < element.getIdentifier().size(); i++) 8787 composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i); 8788 if (element.hasPatient()) 8789 composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1); 8790 if (element.hasDateElement()) 8791 composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1); 8792 if (element.hasAuthority()) 8793 composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1); 8794 for (int i = 0; i < element.getRecommendation().size(); i++) 8795 composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i); 8796 } 8797 8798 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) { 8799 if (element == null) 8800 return; 8801 Complex t; 8802 if (Utilities.noString(parentType)) 8803 t = parent; 8804 else { 8805 t = parent.predicate("fhir:"+parentType+'.'+name); 8806 } 8807 composeBackboneElement(t, "recommendation", name, element, index); 8808 for (int i = 0; i < element.getVaccineCode().size(); i++) 8809 composeCodeableConcept(t, "ImmunizationRecommendation", "vaccineCode", element.getVaccineCode().get(i), i); 8810 if (element.hasTargetDisease()) 8811 composeCodeableConcept(t, "ImmunizationRecommendation", "targetDisease", element.getTargetDisease(), -1); 8812 for (int i = 0; i < element.getContraindicatedVaccineCode().size(); i++) 8813 composeCodeableConcept(t, "ImmunizationRecommendation", "contraindicatedVaccineCode", element.getContraindicatedVaccineCode().get(i), i); 8814 if (element.hasForecastStatus()) 8815 composeCodeableConcept(t, "ImmunizationRecommendation", "forecastStatus", element.getForecastStatus(), -1); 8816 for (int i = 0; i < element.getForecastReason().size(); i++) 8817 composeCodeableConcept(t, "ImmunizationRecommendation", "forecastReason", element.getForecastReason().get(i), i); 8818 for (int i = 0; i < element.getDateCriterion().size(); i++) 8819 composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendation", "dateCriterion", element.getDateCriterion().get(i), i); 8820 if (element.hasDescriptionElement()) 8821 composeString(t, "ImmunizationRecommendation", "description", element.getDescriptionElement(), -1); 8822 if (element.hasSeriesElement()) 8823 composeString(t, "ImmunizationRecommendation", "series", element.getSeriesElement(), -1); 8824 if (element.hasDoseNumber()) 8825 composeType(t, "ImmunizationRecommendation", "doseNumber", element.getDoseNumber(), -1); 8826 if (element.hasSeriesDoses()) 8827 composeType(t, "ImmunizationRecommendation", "seriesDoses", element.getSeriesDoses(), -1); 8828 for (int i = 0; i < element.getSupportingImmunization().size(); i++) 8829 composeReference(t, "ImmunizationRecommendation", "supportingImmunization", element.getSupportingImmunization().get(i), i); 8830 for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) 8831 composeReference(t, "ImmunizationRecommendation", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i); 8832 } 8833 8834 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) { 8835 if (element == null) 8836 return; 8837 Complex t; 8838 if (Utilities.noString(parentType)) 8839 t = parent; 8840 else { 8841 t = parent.predicate("fhir:"+parentType+'.'+name); 8842 } 8843 composeBackboneElement(t, "dateCriterion", name, element, index); 8844 if (element.hasCode()) 8845 composeCodeableConcept(t, "ImmunizationRecommendation", "code", element.getCode(), -1); 8846 if (element.hasValueElement()) 8847 composeDateTime(t, "ImmunizationRecommendation", "value", element.getValueElement(), -1); 8848 } 8849 8850 protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide element, int index) { 8851 if (element == null) 8852 return; 8853 Complex t; 8854 if (Utilities.noString(parentType)) 8855 t = parent; 8856 else { 8857 t = parent.predicate("fhir:"+parentType+'.'+name); 8858 } 8859 composeDomainResource(t, "ImplementationGuide", name, element, index); 8860 if (element.hasUrlElement()) 8861 composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1); 8862 if (element.hasVersionElement()) 8863 composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1); 8864 if (element.hasNameElement()) 8865 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 8866 if (element.hasTitleElement()) 8867 composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1); 8868 if (element.hasStatusElement()) 8869 composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1); 8870 if (element.hasExperimentalElement()) 8871 composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1); 8872 if (element.hasDateElement()) 8873 composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1); 8874 if (element.hasPublisherElement()) 8875 composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1); 8876 for (int i = 0; i < element.getContact().size(); i++) 8877 composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i); 8878 if (element.hasDescriptionElement()) 8879 composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 8880 for (int i = 0; i < element.getUseContext().size(); i++) 8881 composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i); 8882 for (int i = 0; i < element.getJurisdiction().size(); i++) 8883 composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i); 8884 if (element.hasCopyrightElement()) 8885 composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1); 8886 if (element.hasPackageIdElement()) 8887 composeId(t, "ImplementationGuide", "packageId", element.getPackageIdElement(), -1); 8888 if (element.hasLicenseElement()) 8889 composeEnum(t, "ImplementationGuide", "license", element.getLicenseElement(), -1); 8890 for (int i = 0; i < element.getFhirVersion().size(); i++) 8891 composeEnum(t, "ImplementationGuide", "fhirVersion", element.getFhirVersion().get(i), i); 8892 for (int i = 0; i < element.getDependsOn().size(); i++) 8893 composeImplementationGuideImplementationGuideDependsOnComponent(t, "ImplementationGuide", "dependsOn", element.getDependsOn().get(i), i); 8894 for (int i = 0; i < element.getGlobal().size(); i++) 8895 composeImplementationGuideImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i); 8896 if (element.hasDefinition()) 8897 composeImplementationGuideImplementationGuideDefinitionComponent(t, "ImplementationGuide", "definition", element.getDefinition(), -1); 8898 if (element.hasManifest()) 8899 composeImplementationGuideImplementationGuideManifestComponent(t, "ImplementationGuide", "manifest", element.getManifest(), -1); 8900 } 8901 8902 protected void composeImplementationGuideImplementationGuideDependsOnComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependsOnComponent element, int index) { 8903 if (element == null) 8904 return; 8905 Complex t; 8906 if (Utilities.noString(parentType)) 8907 t = parent; 8908 else { 8909 t = parent.predicate("fhir:"+parentType+'.'+name); 8910 } 8911 composeBackboneElement(t, "dependsOn", name, element, index); 8912 if (element.hasUriElement()) 8913 composeCanonical(t, "ImplementationGuide", "uri", element.getUriElement(), -1); 8914 if (element.hasPackageIdElement()) 8915 composeId(t, "ImplementationGuide", "packageId", element.getPackageIdElement(), -1); 8916 if (element.hasVersionElement()) 8917 composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1); 8918 } 8919 8920 protected void composeImplementationGuideImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) { 8921 if (element == null) 8922 return; 8923 Complex t; 8924 if (Utilities.noString(parentType)) 8925 t = parent; 8926 else { 8927 t = parent.predicate("fhir:"+parentType+'.'+name); 8928 } 8929 composeBackboneElement(t, "global", name, element, index); 8930 if (element.hasTypeElement()) 8931 composeCode(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 8932 if (element.hasProfileElement()) 8933 composeCanonical(t, "ImplementationGuide", "profile", element.getProfileElement(), -1); 8934 } 8935 8936 protected void composeImplementationGuideImplementationGuideDefinitionComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionComponent element, int index) { 8937 if (element == null) 8938 return; 8939 Complex t; 8940 if (Utilities.noString(parentType)) 8941 t = parent; 8942 else { 8943 t = parent.predicate("fhir:"+parentType+'.'+name); 8944 } 8945 composeBackboneElement(t, "definition", name, element, index); 8946 for (int i = 0; i < element.getGrouping().size(); i++) 8947 composeImplementationGuideImplementationGuideDefinitionGroupingComponent(t, "ImplementationGuide", "grouping", element.getGrouping().get(i), i); 8948 for (int i = 0; i < element.getResource().size(); i++) 8949 composeImplementationGuideImplementationGuideDefinitionResourceComponent(t, "ImplementationGuide", "resource", element.getResource().get(i), i); 8950 if (element.hasPage()) 8951 composeImplementationGuideImplementationGuideDefinitionPageComponent(t, "ImplementationGuide", "page", element.getPage(), -1); 8952 for (int i = 0; i < element.getParameter().size(); i++) 8953 composeImplementationGuideImplementationGuideDefinitionParameterComponent(t, "ImplementationGuide", "parameter", element.getParameter().get(i), i); 8954 for (int i = 0; i < element.getTemplate().size(); i++) 8955 composeImplementationGuideImplementationGuideDefinitionTemplateComponent(t, "ImplementationGuide", "template", element.getTemplate().get(i), i); 8956 } 8957 8958 protected void composeImplementationGuideImplementationGuideDefinitionGroupingComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionGroupingComponent element, int index) { 8959 if (element == null) 8960 return; 8961 Complex t; 8962 if (Utilities.noString(parentType)) 8963 t = parent; 8964 else { 8965 t = parent.predicate("fhir:"+parentType+'.'+name); 8966 } 8967 composeBackboneElement(t, "grouping", name, element, index); 8968 if (element.hasNameElement()) 8969 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 8970 if (element.hasDescriptionElement()) 8971 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 8972 } 8973 8974 protected void composeImplementationGuideImplementationGuideDefinitionResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionResourceComponent element, int index) { 8975 if (element == null) 8976 return; 8977 Complex t; 8978 if (Utilities.noString(parentType)) 8979 t = parent; 8980 else { 8981 t = parent.predicate("fhir:"+parentType+'.'+name); 8982 } 8983 composeBackboneElement(t, "resource", name, element, index); 8984 if (element.hasReference()) 8985 composeReference(t, "ImplementationGuide", "reference", element.getReference(), -1); 8986 for (int i = 0; i < element.getFhirVersion().size(); i++) 8987 composeEnum(t, "ImplementationGuide", "fhirVersion", element.getFhirVersion().get(i), i); 8988 if (element.hasNameElement()) 8989 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 8990 if (element.hasDescriptionElement()) 8991 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 8992 if (element.hasExample()) 8993 composeType(t, "ImplementationGuide", "example", element.getExample(), -1); 8994 if (element.hasGroupingIdElement()) 8995 composeId(t, "ImplementationGuide", "groupingId", element.getGroupingIdElement(), -1); 8996 } 8997 8998 protected void composeImplementationGuideImplementationGuideDefinitionPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionPageComponent element, int index) { 8999 if (element == null) 9000 return; 9001 Complex t; 9002 if (Utilities.noString(parentType)) 9003 t = parent; 9004 else { 9005 t = parent.predicate("fhir:"+parentType+'.'+name); 9006 } 9007 composeBackboneElement(t, "page", name, element, index); 9008 if (element.hasName()) 9009 composeType(t, "ImplementationGuide", "name", element.getName(), -1); 9010 if (element.hasTitleElement()) 9011 composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1); 9012 if (element.hasGenerationElement()) 9013 composeEnum(t, "ImplementationGuide", "generation", element.getGenerationElement(), -1); 9014 for (int i = 0; i < element.getPage().size(); i++) 9015 composeImplementationGuideImplementationGuideDefinitionPageComponent(t, "ImplementationGuide", "page", element.getPage().get(i), i); 9016 } 9017 9018 protected void composeImplementationGuideImplementationGuideDefinitionParameterComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionParameterComponent element, int index) { 9019 if (element == null) 9020 return; 9021 Complex t; 9022 if (Utilities.noString(parentType)) 9023 t = parent; 9024 else { 9025 t = parent.predicate("fhir:"+parentType+'.'+name); 9026 } 9027 composeBackboneElement(t, "parameter", name, element, index); 9028 if (element.hasCodeElement()) 9029 composeString(t, "ImplementationGuide", "code", element.getCodeElement(), -1); 9030 if (element.hasValueElement()) 9031 composeString(t, "ImplementationGuide", "value", element.getValueElement(), -1); 9032 } 9033 9034 protected void composeImplementationGuideImplementationGuideDefinitionTemplateComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionTemplateComponent element, int index) { 9035 if (element == null) 9036 return; 9037 Complex t; 9038 if (Utilities.noString(parentType)) 9039 t = parent; 9040 else { 9041 t = parent.predicate("fhir:"+parentType+'.'+name); 9042 } 9043 composeBackboneElement(t, "template", name, element, index); 9044 if (element.hasCodeElement()) 9045 composeCode(t, "ImplementationGuide", "code", element.getCodeElement(), -1); 9046 if (element.hasSourceElement()) 9047 composeString(t, "ImplementationGuide", "source", element.getSourceElement(), -1); 9048 if (element.hasScopeElement()) 9049 composeString(t, "ImplementationGuide", "scope", element.getScopeElement(), -1); 9050 } 9051 9052 protected void composeImplementationGuideImplementationGuideManifestComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideManifestComponent element, int index) { 9053 if (element == null) 9054 return; 9055 Complex t; 9056 if (Utilities.noString(parentType)) 9057 t = parent; 9058 else { 9059 t = parent.predicate("fhir:"+parentType+'.'+name); 9060 } 9061 composeBackboneElement(t, "manifest", name, element, index); 9062 if (element.hasRenderingElement()) 9063 composeUrl(t, "ImplementationGuide", "rendering", element.getRenderingElement(), -1); 9064 for (int i = 0; i < element.getResource().size(); i++) 9065 composeImplementationGuideManifestResourceComponent(t, "ImplementationGuide", "resource", element.getResource().get(i), i); 9066 for (int i = 0; i < element.getPage().size(); i++) 9067 composeImplementationGuideManifestPageComponent(t, "ImplementationGuide", "page", element.getPage().get(i), i); 9068 for (int i = 0; i < element.getImage().size(); i++) 9069 composeString(t, "ImplementationGuide", "image", element.getImage().get(i), i); 9070 for (int i = 0; i < element.getOther().size(); i++) 9071 composeString(t, "ImplementationGuide", "other", element.getOther().get(i), i); 9072 } 9073 9074 protected void composeImplementationGuideManifestResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestResourceComponent element, int index) { 9075 if (element == null) 9076 return; 9077 Complex t; 9078 if (Utilities.noString(parentType)) 9079 t = parent; 9080 else { 9081 t = parent.predicate("fhir:"+parentType+'.'+name); 9082 } 9083 composeBackboneElement(t, "resource", name, element, index); 9084 if (element.hasReference()) 9085 composeReference(t, "ImplementationGuide", "reference", element.getReference(), -1); 9086 if (element.hasExample()) 9087 composeType(t, "ImplementationGuide", "example", element.getExample(), -1); 9088 if (element.hasRelativePathElement()) 9089 composeUrl(t, "ImplementationGuide", "relativePath", element.getRelativePathElement(), -1); 9090 } 9091 9092 protected void composeImplementationGuideManifestPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestPageComponent element, int index) { 9093 if (element == null) 9094 return; 9095 Complex t; 9096 if (Utilities.noString(parentType)) 9097 t = parent; 9098 else { 9099 t = parent.predicate("fhir:"+parentType+'.'+name); 9100 } 9101 composeBackboneElement(t, "page", name, element, index); 9102 if (element.hasNameElement()) 9103 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 9104 if (element.hasTitleElement()) 9105 composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1); 9106 for (int i = 0; i < element.getAnchor().size(); i++) 9107 composeString(t, "ImplementationGuide", "anchor", element.getAnchor().get(i), i); 9108 } 9109 9110 protected void composeInsurancePlan(Complex parent, String parentType, String name, InsurancePlan element, int index) { 9111 if (element == null) 9112 return; 9113 Complex t; 9114 if (Utilities.noString(parentType)) 9115 t = parent; 9116 else { 9117 t = parent.predicate("fhir:"+parentType+'.'+name); 9118 } 9119 composeDomainResource(t, "InsurancePlan", name, element, index); 9120 for (int i = 0; i < element.getIdentifier().size(); i++) 9121 composeIdentifier(t, "InsurancePlan", "identifier", element.getIdentifier().get(i), i); 9122 if (element.hasStatusElement()) 9123 composeEnum(t, "InsurancePlan", "status", element.getStatusElement(), -1); 9124 for (int i = 0; i < element.getType().size(); i++) 9125 composeCodeableConcept(t, "InsurancePlan", "type", element.getType().get(i), i); 9126 if (element.hasNameElement()) 9127 composeString(t, "InsurancePlan", "name", element.getNameElement(), -1); 9128 for (int i = 0; i < element.getAlias().size(); i++) 9129 composeString(t, "InsurancePlan", "alias", element.getAlias().get(i), i); 9130 if (element.hasPeriod()) 9131 composePeriod(t, "InsurancePlan", "period", element.getPeriod(), -1); 9132 if (element.hasOwnedBy()) 9133 composeReference(t, "InsurancePlan", "ownedBy", element.getOwnedBy(), -1); 9134 if (element.hasAdministeredBy()) 9135 composeReference(t, "InsurancePlan", "administeredBy", element.getAdministeredBy(), -1); 9136 for (int i = 0; i < element.getCoverageArea().size(); i++) 9137 composeReference(t, "InsurancePlan", "coverageArea", element.getCoverageArea().get(i), i); 9138 for (int i = 0; i < element.getContact().size(); i++) 9139 composeInsurancePlanInsurancePlanContactComponent(t, "InsurancePlan", "contact", element.getContact().get(i), i); 9140 for (int i = 0; i < element.getEndpoint().size(); i++) 9141 composeReference(t, "InsurancePlan", "endpoint", element.getEndpoint().get(i), i); 9142 for (int i = 0; i < element.getNetwork().size(); i++) 9143 composeReference(t, "InsurancePlan", "network", element.getNetwork().get(i), i); 9144 for (int i = 0; i < element.getCoverage().size(); i++) 9145 composeInsurancePlanInsurancePlanCoverageComponent(t, "InsurancePlan", "coverage", element.getCoverage().get(i), i); 9146 for (int i = 0; i < element.getPlan().size(); i++) 9147 composeInsurancePlanInsurancePlanPlanComponent(t, "InsurancePlan", "plan", element.getPlan().get(i), i); 9148 } 9149 9150 protected void composeInsurancePlanInsurancePlanContactComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanContactComponent element, int index) { 9151 if (element == null) 9152 return; 9153 Complex t; 9154 if (Utilities.noString(parentType)) 9155 t = parent; 9156 else { 9157 t = parent.predicate("fhir:"+parentType+'.'+name); 9158 } 9159 composeBackboneElement(t, "contact", name, element, index); 9160 if (element.hasPurpose()) 9161 composeCodeableConcept(t, "InsurancePlan", "purpose", element.getPurpose(), -1); 9162 if (element.hasName()) 9163 composeHumanName(t, "InsurancePlan", "name", element.getName(), -1); 9164 for (int i = 0; i < element.getTelecom().size(); i++) 9165 composeContactPoint(t, "InsurancePlan", "telecom", element.getTelecom().get(i), i); 9166 if (element.hasAddress()) 9167 composeAddress(t, "InsurancePlan", "address", element.getAddress(), -1); 9168 } 9169 9170 protected void composeInsurancePlanInsurancePlanCoverageComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanCoverageComponent element, int index) { 9171 if (element == null) 9172 return; 9173 Complex t; 9174 if (Utilities.noString(parentType)) 9175 t = parent; 9176 else { 9177 t = parent.predicate("fhir:"+parentType+'.'+name); 9178 } 9179 composeBackboneElement(t, "coverage", name, element, index); 9180 if (element.hasType()) 9181 composeCodeableConcept(t, "InsurancePlan", "type", element.getType(), -1); 9182 for (int i = 0; i < element.getNetwork().size(); i++) 9183 composeReference(t, "InsurancePlan", "network", element.getNetwork().get(i), i); 9184 for (int i = 0; i < element.getBenefit().size(); i++) 9185 composeInsurancePlanCoverageBenefitComponent(t, "InsurancePlan", "benefit", element.getBenefit().get(i), i); 9186 } 9187 9188 protected void composeInsurancePlanCoverageBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitComponent element, int index) { 9189 if (element == null) 9190 return; 9191 Complex t; 9192 if (Utilities.noString(parentType)) 9193 t = parent; 9194 else { 9195 t = parent.predicate("fhir:"+parentType+'.'+name); 9196 } 9197 composeBackboneElement(t, "benefit", name, element, index); 9198 if (element.hasType()) 9199 composeCodeableConcept(t, "InsurancePlan", "type", element.getType(), -1); 9200 if (element.hasRequirementElement()) 9201 composeString(t, "InsurancePlan", "requirement", element.getRequirementElement(), -1); 9202 for (int i = 0; i < element.getLimit().size(); i++) 9203 composeInsurancePlanCoverageBenefitLimitComponent(t, "InsurancePlan", "limit", element.getLimit().get(i), i); 9204 } 9205 9206 protected void composeInsurancePlanCoverageBenefitLimitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitLimitComponent element, int index) { 9207 if (element == null) 9208 return; 9209 Complex t; 9210 if (Utilities.noString(parentType)) 9211 t = parent; 9212 else { 9213 t = parent.predicate("fhir:"+parentType+'.'+name); 9214 } 9215 composeBackboneElement(t, "limit", name, element, index); 9216 if (element.hasValue()) 9217 composeQuantity(t, "InsurancePlan", "value", element.getValue(), -1); 9218 if (element.hasCode()) 9219 composeCodeableConcept(t, "InsurancePlan", "code", element.getCode(), -1); 9220 } 9221 9222 protected void composeInsurancePlanInsurancePlanPlanComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanComponent element, int index) { 9223 if (element == null) 9224 return; 9225 Complex t; 9226 if (Utilities.noString(parentType)) 9227 t = parent; 9228 else { 9229 t = parent.predicate("fhir:"+parentType+'.'+name); 9230 } 9231 composeBackboneElement(t, "plan", name, element, index); 9232 for (int i = 0; i < element.getIdentifier().size(); i++) 9233 composeIdentifier(t, "InsurancePlan", "identifier", element.getIdentifier().get(i), i); 9234 if (element.hasType()) 9235 composeCodeableConcept(t, "InsurancePlan", "type", element.getType(), -1); 9236 for (int i = 0; i < element.getCoverageArea().size(); i++) 9237 composeReference(t, "InsurancePlan", "coverageArea", element.getCoverageArea().get(i), i); 9238 for (int i = 0; i < element.getNetwork().size(); i++) 9239 composeReference(t, "InsurancePlan", "network", element.getNetwork().get(i), i); 9240 for (int i = 0; i < element.getGeneralCost().size(); i++) 9241 composeInsurancePlanInsurancePlanPlanGeneralCostComponent(t, "InsurancePlan", "generalCost", element.getGeneralCost().get(i), i); 9242 for (int i = 0; i < element.getSpecificCost().size(); i++) 9243 composeInsurancePlanInsurancePlanPlanSpecificCostComponent(t, "InsurancePlan", "specificCost", element.getSpecificCost().get(i), i); 9244 } 9245 9246 protected void composeInsurancePlanInsurancePlanPlanGeneralCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanGeneralCostComponent element, int index) { 9247 if (element == null) 9248 return; 9249 Complex t; 9250 if (Utilities.noString(parentType)) 9251 t = parent; 9252 else { 9253 t = parent.predicate("fhir:"+parentType+'.'+name); 9254 } 9255 composeBackboneElement(t, "generalCost", name, element, index); 9256 if (element.hasType()) 9257 composeCodeableConcept(t, "InsurancePlan", "type", element.getType(), -1); 9258 if (element.hasGroupSizeElement()) 9259 composePositiveInt(t, "InsurancePlan", "groupSize", element.getGroupSizeElement(), -1); 9260 if (element.hasCost()) 9261 composeMoney(t, "InsurancePlan", "cost", element.getCost(), -1); 9262 if (element.hasCommentElement()) 9263 composeString(t, "InsurancePlan", "comment", element.getCommentElement(), -1); 9264 } 9265 9266 protected void composeInsurancePlanInsurancePlanPlanSpecificCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanSpecificCostComponent element, int index) { 9267 if (element == null) 9268 return; 9269 Complex t; 9270 if (Utilities.noString(parentType)) 9271 t = parent; 9272 else { 9273 t = parent.predicate("fhir:"+parentType+'.'+name); 9274 } 9275 composeBackboneElement(t, "specificCost", name, element, index); 9276 if (element.hasCategory()) 9277 composeCodeableConcept(t, "InsurancePlan", "category", element.getCategory(), -1); 9278 for (int i = 0; i < element.getBenefit().size(); i++) 9279 composeInsurancePlanPlanBenefitComponent(t, "InsurancePlan", "benefit", element.getBenefit().get(i), i); 9280 } 9281 9282 protected void composeInsurancePlanPlanBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitComponent element, int index) { 9283 if (element == null) 9284 return; 9285 Complex t; 9286 if (Utilities.noString(parentType)) 9287 t = parent; 9288 else { 9289 t = parent.predicate("fhir:"+parentType+'.'+name); 9290 } 9291 composeBackboneElement(t, "benefit", name, element, index); 9292 if (element.hasType()) 9293 composeCodeableConcept(t, "InsurancePlan", "type", element.getType(), -1); 9294 for (int i = 0; i < element.getCost().size(); i++) 9295 composeInsurancePlanPlanBenefitCostComponent(t, "InsurancePlan", "cost", element.getCost().get(i), i); 9296 } 9297 9298 protected void composeInsurancePlanPlanBenefitCostComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitCostComponent element, int index) { 9299 if (element == null) 9300 return; 9301 Complex t; 9302 if (Utilities.noString(parentType)) 9303 t = parent; 9304 else { 9305 t = parent.predicate("fhir:"+parentType+'.'+name); 9306 } 9307 composeBackboneElement(t, "cost", name, element, index); 9308 if (element.hasType()) 9309 composeCodeableConcept(t, "InsurancePlan", "type", element.getType(), -1); 9310 if (element.hasApplicability()) 9311 composeCodeableConcept(t, "InsurancePlan", "applicability", element.getApplicability(), -1); 9312 for (int i = 0; i < element.getQualifiers().size(); i++) 9313 composeCodeableConcept(t, "InsurancePlan", "qualifiers", element.getQualifiers().get(i), i); 9314 if (element.hasValue()) 9315 composeQuantity(t, "InsurancePlan", "value", element.getValue(), -1); 9316 } 9317 9318 protected void composeInvoice(Complex parent, String parentType, String name, Invoice element, int index) { 9319 if (element == null) 9320 return; 9321 Complex t; 9322 if (Utilities.noString(parentType)) 9323 t = parent; 9324 else { 9325 t = parent.predicate("fhir:"+parentType+'.'+name); 9326 } 9327 composeDomainResource(t, "Invoice", name, element, index); 9328 for (int i = 0; i < element.getIdentifier().size(); i++) 9329 composeIdentifier(t, "Invoice", "identifier", element.getIdentifier().get(i), i); 9330 if (element.hasStatusElement()) 9331 composeEnum(t, "Invoice", "status", element.getStatusElement(), -1); 9332 if (element.hasCancelledReasonElement()) 9333 composeString(t, "Invoice", "cancelledReason", element.getCancelledReasonElement(), -1); 9334 if (element.hasType()) 9335 composeCodeableConcept(t, "Invoice", "type", element.getType(), -1); 9336 if (element.hasSubject()) 9337 composeReference(t, "Invoice", "subject", element.getSubject(), -1); 9338 if (element.hasRecipient()) 9339 composeReference(t, "Invoice", "recipient", element.getRecipient(), -1); 9340 if (element.hasDateElement()) 9341 composeDateTime(t, "Invoice", "date", element.getDateElement(), -1); 9342 for (int i = 0; i < element.getParticipant().size(); i++) 9343 composeInvoiceInvoiceParticipantComponent(t, "Invoice", "participant", element.getParticipant().get(i), i); 9344 if (element.hasIssuer()) 9345 composeReference(t, "Invoice", "issuer", element.getIssuer(), -1); 9346 if (element.hasAccount()) 9347 composeReference(t, "Invoice", "account", element.getAccount(), -1); 9348 for (int i = 0; i < element.getLineItem().size(); i++) 9349 composeInvoiceInvoiceLineItemComponent(t, "Invoice", "lineItem", element.getLineItem().get(i), i); 9350 for (int i = 0; i < element.getTotalPriceComponent().size(); i++) 9351 composeInvoiceInvoiceLineItemPriceComponentComponent(t, "Invoice", "totalPriceComponent", element.getTotalPriceComponent().get(i), i); 9352 if (element.hasTotalNet()) 9353 composeMoney(t, "Invoice", "totalNet", element.getTotalNet(), -1); 9354 if (element.hasTotalGross()) 9355 composeMoney(t, "Invoice", "totalGross", element.getTotalGross(), -1); 9356 if (element.hasPaymentTermsElement()) 9357 composeMarkdown(t, "Invoice", "paymentTerms", element.getPaymentTermsElement(), -1); 9358 for (int i = 0; i < element.getNote().size(); i++) 9359 composeAnnotation(t, "Invoice", "note", element.getNote().get(i), i); 9360 } 9361 9362 protected void composeInvoiceInvoiceParticipantComponent(Complex parent, String parentType, String name, Invoice.InvoiceParticipantComponent element, int index) { 9363 if (element == null) 9364 return; 9365 Complex t; 9366 if (Utilities.noString(parentType)) 9367 t = parent; 9368 else { 9369 t = parent.predicate("fhir:"+parentType+'.'+name); 9370 } 9371 composeBackboneElement(t, "participant", name, element, index); 9372 if (element.hasRole()) 9373 composeCodeableConcept(t, "Invoice", "role", element.getRole(), -1); 9374 if (element.hasActor()) 9375 composeReference(t, "Invoice", "actor", element.getActor(), -1); 9376 } 9377 9378 protected void composeInvoiceInvoiceLineItemComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemComponent element, int index) { 9379 if (element == null) 9380 return; 9381 Complex t; 9382 if (Utilities.noString(parentType)) 9383 t = parent; 9384 else { 9385 t = parent.predicate("fhir:"+parentType+'.'+name); 9386 } 9387 composeBackboneElement(t, "lineItem", name, element, index); 9388 if (element.hasSequenceElement()) 9389 composePositiveInt(t, "Invoice", "sequence", element.getSequenceElement(), -1); 9390 if (element.hasChargeItem()) 9391 composeType(t, "Invoice", "chargeItem", element.getChargeItem(), -1); 9392 for (int i = 0; i < element.getPriceComponent().size(); i++) 9393 composeInvoiceInvoiceLineItemPriceComponentComponent(t, "Invoice", "priceComponent", element.getPriceComponent().get(i), i); 9394 } 9395 9396 protected void composeInvoiceInvoiceLineItemPriceComponentComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemPriceComponentComponent element, int index) { 9397 if (element == null) 9398 return; 9399 Complex t; 9400 if (Utilities.noString(parentType)) 9401 t = parent; 9402 else { 9403 t = parent.predicate("fhir:"+parentType+'.'+name); 9404 } 9405 composeBackboneElement(t, "priceComponent", name, element, index); 9406 if (element.hasTypeElement()) 9407 composeEnum(t, "Invoice", "type", element.getTypeElement(), -1); 9408 if (element.hasCode()) 9409 composeCodeableConcept(t, "Invoice", "code", element.getCode(), -1); 9410 if (element.hasFactorElement()) 9411 composeDecimal(t, "Invoice", "factor", element.getFactorElement(), -1); 9412 if (element.hasAmount()) 9413 composeMoney(t, "Invoice", "amount", element.getAmount(), -1); 9414 } 9415 9416 protected void composeLibrary(Complex parent, String parentType, String name, Library element, int index) { 9417 if (element == null) 9418 return; 9419 Complex t; 9420 if (Utilities.noString(parentType)) 9421 t = parent; 9422 else { 9423 t = parent.predicate("fhir:"+parentType+'.'+name); 9424 } 9425 composeDomainResource(t, "Library", name, element, index); 9426 if (element.hasUrlElement()) 9427 composeUri(t, "Library", "url", element.getUrlElement(), -1); 9428 for (int i = 0; i < element.getIdentifier().size(); i++) 9429 composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i); 9430 if (element.hasVersionElement()) 9431 composeString(t, "Library", "version", element.getVersionElement(), -1); 9432 if (element.hasNameElement()) 9433 composeString(t, "Library", "name", element.getNameElement(), -1); 9434 if (element.hasTitleElement()) 9435 composeString(t, "Library", "title", element.getTitleElement(), -1); 9436 if (element.hasSubtitleElement()) 9437 composeString(t, "Library", "subtitle", element.getSubtitleElement(), -1); 9438 if (element.hasStatusElement()) 9439 composeEnum(t, "Library", "status", element.getStatusElement(), -1); 9440 if (element.hasExperimentalElement()) 9441 composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1); 9442 if (element.hasType()) 9443 composeCodeableConcept(t, "Library", "type", element.getType(), -1); 9444 if (element.hasSubject()) 9445 composeType(t, "Library", "subject", element.getSubject(), -1); 9446 if (element.hasDateElement()) 9447 composeDateTime(t, "Library", "date", element.getDateElement(), -1); 9448 if (element.hasPublisherElement()) 9449 composeString(t, "Library", "publisher", element.getPublisherElement(), -1); 9450 for (int i = 0; i < element.getContact().size(); i++) 9451 composeContactDetail(t, "Library", "contact", element.getContact().get(i), i); 9452 if (element.hasDescriptionElement()) 9453 composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1); 9454 for (int i = 0; i < element.getUseContext().size(); i++) 9455 composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i); 9456 for (int i = 0; i < element.getJurisdiction().size(); i++) 9457 composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i); 9458 if (element.hasPurposeElement()) 9459 composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1); 9460 if (element.hasUsageElement()) 9461 composeString(t, "Library", "usage", element.getUsageElement(), -1); 9462 if (element.hasCopyrightElement()) 9463 composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1); 9464 if (element.hasApprovalDateElement()) 9465 composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1); 9466 if (element.hasLastReviewDateElement()) 9467 composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1); 9468 if (element.hasEffectivePeriod()) 9469 composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1); 9470 for (int i = 0; i < element.getTopic().size(); i++) 9471 composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i); 9472 for (int i = 0; i < element.getAuthor().size(); i++) 9473 composeContactDetail(t, "Library", "author", element.getAuthor().get(i), i); 9474 for (int i = 0; i < element.getEditor().size(); i++) 9475 composeContactDetail(t, "Library", "editor", element.getEditor().get(i), i); 9476 for (int i = 0; i < element.getReviewer().size(); i++) 9477 composeContactDetail(t, "Library", "reviewer", element.getReviewer().get(i), i); 9478 for (int i = 0; i < element.getEndorser().size(); i++) 9479 composeContactDetail(t, "Library", "endorser", element.getEndorser().get(i), i); 9480 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 9481 composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i); 9482 for (int i = 0; i < element.getParameter().size(); i++) 9483 composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i); 9484 for (int i = 0; i < element.getDataRequirement().size(); i++) 9485 composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i); 9486 for (int i = 0; i < element.getContent().size(); i++) 9487 composeAttachment(t, "Library", "content", element.getContent().get(i), i); 9488 } 9489 9490 protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) { 9491 if (element == null) 9492 return; 9493 Complex t; 9494 if (Utilities.noString(parentType)) 9495 t = parent; 9496 else { 9497 t = parent.predicate("fhir:"+parentType+'.'+name); 9498 } 9499 composeDomainResource(t, "Linkage", name, element, index); 9500 if (element.hasActiveElement()) 9501 composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1); 9502 if (element.hasAuthor()) 9503 composeReference(t, "Linkage", "author", element.getAuthor(), -1); 9504 for (int i = 0; i < element.getItem().size(); i++) 9505 composeLinkageLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i); 9506 } 9507 9508 protected void composeLinkageLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) { 9509 if (element == null) 9510 return; 9511 Complex t; 9512 if (Utilities.noString(parentType)) 9513 t = parent; 9514 else { 9515 t = parent.predicate("fhir:"+parentType+'.'+name); 9516 } 9517 composeBackboneElement(t, "item", name, element, index); 9518 if (element.hasTypeElement()) 9519 composeEnum(t, "Linkage", "type", element.getTypeElement(), -1); 9520 if (element.hasResource()) 9521 composeReference(t, "Linkage", "resource", element.getResource(), -1); 9522 } 9523 9524 protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) { 9525 if (element == null) 9526 return; 9527 Complex t; 9528 if (Utilities.noString(parentType)) 9529 t = parent; 9530 else { 9531 t = parent.predicate("fhir:"+parentType+'.'+name); 9532 } 9533 composeDomainResource(t, "List", name, element, index); 9534 for (int i = 0; i < element.getIdentifier().size(); i++) 9535 composeIdentifier(t, "List", "identifier", element.getIdentifier().get(i), i); 9536 if (element.hasStatusElement()) 9537 composeEnum(t, "List", "status", element.getStatusElement(), -1); 9538 if (element.hasModeElement()) 9539 composeEnum(t, "List", "mode", element.getModeElement(), -1); 9540 if (element.hasTitleElement()) 9541 composeString(t, "List", "title", element.getTitleElement(), -1); 9542 if (element.hasCode()) 9543 composeCodeableConcept(t, "List", "code", element.getCode(), -1); 9544 if (element.hasSubject()) 9545 composeReference(t, "List", "subject", element.getSubject(), -1); 9546 if (element.hasEncounter()) 9547 composeReference(t, "List", "encounter", element.getEncounter(), -1); 9548 if (element.hasDateElement()) 9549 composeDateTime(t, "List", "date", element.getDateElement(), -1); 9550 if (element.hasSource()) 9551 composeReference(t, "List", "source", element.getSource(), -1); 9552 if (element.hasOrderedBy()) 9553 composeCodeableConcept(t, "List", "orderedBy", element.getOrderedBy(), -1); 9554 for (int i = 0; i < element.getNote().size(); i++) 9555 composeAnnotation(t, "List", "note", element.getNote().get(i), i); 9556 for (int i = 0; i < element.getEntry().size(); i++) 9557 composeListResourceListEntryComponent(t, "List", "entry", element.getEntry().get(i), i); 9558 if (element.hasEmptyReason()) 9559 composeCodeableConcept(t, "List", "emptyReason", element.getEmptyReason(), -1); 9560 } 9561 9562 protected void composeListResourceListEntryComponent(Complex parent, String parentType, String name, ListResource.ListEntryComponent element, int index) { 9563 if (element == null) 9564 return; 9565 Complex t; 9566 if (Utilities.noString(parentType)) 9567 t = parent; 9568 else { 9569 t = parent.predicate("fhir:"+parentType+'.'+name); 9570 } 9571 composeBackboneElement(t, "entry", name, element, index); 9572 if (element.hasFlag()) 9573 composeCodeableConcept(t, "List", "flag", element.getFlag(), -1); 9574 if (element.hasDeletedElement()) 9575 composeBoolean(t, "List", "deleted", element.getDeletedElement(), -1); 9576 if (element.hasDateElement()) 9577 composeDateTime(t, "List", "date", element.getDateElement(), -1); 9578 if (element.hasItem()) 9579 composeReference(t, "List", "item", element.getItem(), -1); 9580 } 9581 9582 protected void composeLocation(Complex parent, String parentType, String name, Location element, int index) { 9583 if (element == null) 9584 return; 9585 Complex t; 9586 if (Utilities.noString(parentType)) 9587 t = parent; 9588 else { 9589 t = parent.predicate("fhir:"+parentType+'.'+name); 9590 } 9591 composeDomainResource(t, "Location", name, element, index); 9592 for (int i = 0; i < element.getIdentifier().size(); i++) 9593 composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i); 9594 if (element.hasStatusElement()) 9595 composeEnum(t, "Location", "status", element.getStatusElement(), -1); 9596 if (element.hasOperationalStatus()) 9597 composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1); 9598 if (element.hasNameElement()) 9599 composeString(t, "Location", "name", element.getNameElement(), -1); 9600 for (int i = 0; i < element.getAlias().size(); i++) 9601 composeString(t, "Location", "alias", element.getAlias().get(i), i); 9602 if (element.hasDescriptionElement()) 9603 composeString(t, "Location", "description", element.getDescriptionElement(), -1); 9604 if (element.hasModeElement()) 9605 composeEnum(t, "Location", "mode", element.getModeElement(), -1); 9606 for (int i = 0; i < element.getType().size(); i++) 9607 composeCodeableConcept(t, "Location", "type", element.getType().get(i), i); 9608 for (int i = 0; i < element.getTelecom().size(); i++) 9609 composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i); 9610 if (element.hasAddress()) 9611 composeAddress(t, "Location", "address", element.getAddress(), -1); 9612 if (element.hasPhysicalType()) 9613 composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1); 9614 if (element.hasPosition()) 9615 composeLocationLocationPositionComponent(t, "Location", "position", element.getPosition(), -1); 9616 if (element.hasManagingOrganization()) 9617 composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1); 9618 if (element.hasPartOf()) 9619 composeReference(t, "Location", "partOf", element.getPartOf(), -1); 9620 for (int i = 0; i < element.getHoursOfOperation().size(); i++) 9621 composeLocationLocationHoursOfOperationComponent(t, "Location", "hoursOfOperation", element.getHoursOfOperation().get(i), i); 9622 if (element.hasAvailabilityExceptionsElement()) 9623 composeString(t, "Location", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 9624 for (int i = 0; i < element.getEndpoint().size(); i++) 9625 composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i); 9626 } 9627 9628 protected void composeLocationLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) { 9629 if (element == null) 9630 return; 9631 Complex t; 9632 if (Utilities.noString(parentType)) 9633 t = parent; 9634 else { 9635 t = parent.predicate("fhir:"+parentType+'.'+name); 9636 } 9637 composeBackboneElement(t, "position", name, element, index); 9638 if (element.hasLongitudeElement()) 9639 composeDecimal(t, "Location", "longitude", element.getLongitudeElement(), -1); 9640 if (element.hasLatitudeElement()) 9641 composeDecimal(t, "Location", "latitude", element.getLatitudeElement(), -1); 9642 if (element.hasAltitudeElement()) 9643 composeDecimal(t, "Location", "altitude", element.getAltitudeElement(), -1); 9644 } 9645 9646 protected void composeLocationLocationHoursOfOperationComponent(Complex parent, String parentType, String name, Location.LocationHoursOfOperationComponent element, int index) { 9647 if (element == null) 9648 return; 9649 Complex t; 9650 if (Utilities.noString(parentType)) 9651 t = parent; 9652 else { 9653 t = parent.predicate("fhir:"+parentType+'.'+name); 9654 } 9655 composeBackboneElement(t, "hoursOfOperation", name, element, index); 9656 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 9657 composeEnum(t, "Location", "daysOfWeek", element.getDaysOfWeek().get(i), i); 9658 if (element.hasAllDayElement()) 9659 composeBoolean(t, "Location", "allDay", element.getAllDayElement(), -1); 9660 if (element.hasOpeningTimeElement()) 9661 composeTime(t, "Location", "openingTime", element.getOpeningTimeElement(), -1); 9662 if (element.hasClosingTimeElement()) 9663 composeTime(t, "Location", "closingTime", element.getClosingTimeElement(), -1); 9664 } 9665 9666 protected void composeMeasure(Complex parent, String parentType, String name, Measure element, int index) { 9667 if (element == null) 9668 return; 9669 Complex t; 9670 if (Utilities.noString(parentType)) 9671 t = parent; 9672 else { 9673 t = parent.predicate("fhir:"+parentType+'.'+name); 9674 } 9675 composeDomainResource(t, "Measure", name, element, index); 9676 if (element.hasUrlElement()) 9677 composeUri(t, "Measure", "url", element.getUrlElement(), -1); 9678 for (int i = 0; i < element.getIdentifier().size(); i++) 9679 composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i); 9680 if (element.hasVersionElement()) 9681 composeString(t, "Measure", "version", element.getVersionElement(), -1); 9682 if (element.hasNameElement()) 9683 composeString(t, "Measure", "name", element.getNameElement(), -1); 9684 if (element.hasTitleElement()) 9685 composeString(t, "Measure", "title", element.getTitleElement(), -1); 9686 if (element.hasSubtitleElement()) 9687 composeString(t, "Measure", "subtitle", element.getSubtitleElement(), -1); 9688 if (element.hasStatusElement()) 9689 composeEnum(t, "Measure", "status", element.getStatusElement(), -1); 9690 if (element.hasExperimentalElement()) 9691 composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1); 9692 if (element.hasSubject()) 9693 composeType(t, "Measure", "subject", element.getSubject(), -1); 9694 if (element.hasDateElement()) 9695 composeDateTime(t, "Measure", "date", element.getDateElement(), -1); 9696 if (element.hasPublisherElement()) 9697 composeString(t, "Measure", "publisher", element.getPublisherElement(), -1); 9698 for (int i = 0; i < element.getContact().size(); i++) 9699 composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i); 9700 if (element.hasDescriptionElement()) 9701 composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1); 9702 for (int i = 0; i < element.getUseContext().size(); i++) 9703 composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i); 9704 for (int i = 0; i < element.getJurisdiction().size(); i++) 9705 composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i); 9706 if (element.hasPurposeElement()) 9707 composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1); 9708 if (element.hasUsageElement()) 9709 composeString(t, "Measure", "usage", element.getUsageElement(), -1); 9710 if (element.hasCopyrightElement()) 9711 composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1); 9712 if (element.hasApprovalDateElement()) 9713 composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1); 9714 if (element.hasLastReviewDateElement()) 9715 composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1); 9716 if (element.hasEffectivePeriod()) 9717 composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1); 9718 for (int i = 0; i < element.getTopic().size(); i++) 9719 composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i); 9720 for (int i = 0; i < element.getAuthor().size(); i++) 9721 composeContactDetail(t, "Measure", "author", element.getAuthor().get(i), i); 9722 for (int i = 0; i < element.getEditor().size(); i++) 9723 composeContactDetail(t, "Measure", "editor", element.getEditor().get(i), i); 9724 for (int i = 0; i < element.getReviewer().size(); i++) 9725 composeContactDetail(t, "Measure", "reviewer", element.getReviewer().get(i), i); 9726 for (int i = 0; i < element.getEndorser().size(); i++) 9727 composeContactDetail(t, "Measure", "endorser", element.getEndorser().get(i), i); 9728 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 9729 composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i); 9730 for (int i = 0; i < element.getLibrary().size(); i++) 9731 composeCanonical(t, "Measure", "library", element.getLibrary().get(i), i); 9732 if (element.hasDisclaimerElement()) 9733 composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1); 9734 if (element.hasScoring()) 9735 composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1); 9736 if (element.hasCompositeScoring()) 9737 composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1); 9738 for (int i = 0; i < element.getType().size(); i++) 9739 composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i); 9740 if (element.hasRiskAdjustmentElement()) 9741 composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1); 9742 if (element.hasRateAggregationElement()) 9743 composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1); 9744 if (element.hasRationaleElement()) 9745 composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1); 9746 if (element.hasClinicalRecommendationStatementElement()) 9747 composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1); 9748 if (element.hasImprovementNotation()) 9749 composeCodeableConcept(t, "Measure", "improvementNotation", element.getImprovementNotation(), -1); 9750 for (int i = 0; i < element.getDefinition().size(); i++) 9751 composeMarkdown(t, "Measure", "definition", element.getDefinition().get(i), i); 9752 if (element.hasGuidanceElement()) 9753 composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1); 9754 for (int i = 0; i < element.getGroup().size(); i++) 9755 composeMeasureMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i); 9756 for (int i = 0; i < element.getSupplementalData().size(); i++) 9757 composeMeasureMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i); 9758 } 9759 9760 protected void composeMeasureMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) { 9761 if (element == null) 9762 return; 9763 Complex t; 9764 if (Utilities.noString(parentType)) 9765 t = parent; 9766 else { 9767 t = parent.predicate("fhir:"+parentType+'.'+name); 9768 } 9769 composeBackboneElement(t, "group", name, element, index); 9770 if (element.hasCode()) 9771 composeCodeableConcept(t, "Measure", "code", element.getCode(), -1); 9772 if (element.hasDescriptionElement()) 9773 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 9774 for (int i = 0; i < element.getPopulation().size(); i++) 9775 composeMeasureMeasureGroupPopulationComponent(t, "Measure", "population", element.getPopulation().get(i), i); 9776 for (int i = 0; i < element.getStratifier().size(); i++) 9777 composeMeasureMeasureGroupStratifierComponent(t, "Measure", "stratifier", element.getStratifier().get(i), i); 9778 } 9779 9780 protected void composeMeasureMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) { 9781 if (element == null) 9782 return; 9783 Complex t; 9784 if (Utilities.noString(parentType)) 9785 t = parent; 9786 else { 9787 t = parent.predicate("fhir:"+parentType+'.'+name); 9788 } 9789 composeBackboneElement(t, "population", name, element, index); 9790 if (element.hasCode()) 9791 composeCodeableConcept(t, "Measure", "code", element.getCode(), -1); 9792 if (element.hasDescriptionElement()) 9793 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 9794 if (element.hasCriteria()) 9795 composeExpression(t, "Measure", "criteria", element.getCriteria(), -1); 9796 } 9797 9798 protected void composeMeasureMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) { 9799 if (element == null) 9800 return; 9801 Complex t; 9802 if (Utilities.noString(parentType)) 9803 t = parent; 9804 else { 9805 t = parent.predicate("fhir:"+parentType+'.'+name); 9806 } 9807 composeBackboneElement(t, "stratifier", name, element, index); 9808 if (element.hasCode()) 9809 composeCodeableConcept(t, "Measure", "code", element.getCode(), -1); 9810 if (element.hasDescriptionElement()) 9811 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 9812 if (element.hasCriteria()) 9813 composeExpression(t, "Measure", "criteria", element.getCriteria(), -1); 9814 for (int i = 0; i < element.getComponent().size(); i++) 9815 composeMeasureMeasureGroupStratifierComponentComponent(t, "Measure", "component", element.getComponent().get(i), i); 9816 } 9817 9818 protected void composeMeasureMeasureGroupStratifierComponentComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponentComponent element, int index) { 9819 if (element == null) 9820 return; 9821 Complex t; 9822 if (Utilities.noString(parentType)) 9823 t = parent; 9824 else { 9825 t = parent.predicate("fhir:"+parentType+'.'+name); 9826 } 9827 composeBackboneElement(t, "component", name, element, index); 9828 if (element.hasCode()) 9829 composeCodeableConcept(t, "Measure", "code", element.getCode(), -1); 9830 if (element.hasDescriptionElement()) 9831 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 9832 if (element.hasCriteria()) 9833 composeExpression(t, "Measure", "criteria", element.getCriteria(), -1); 9834 } 9835 9836 protected void composeMeasureMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) { 9837 if (element == null) 9838 return; 9839 Complex t; 9840 if (Utilities.noString(parentType)) 9841 t = parent; 9842 else { 9843 t = parent.predicate("fhir:"+parentType+'.'+name); 9844 } 9845 composeBackboneElement(t, "supplementalData", name, element, index); 9846 if (element.hasCode()) 9847 composeCodeableConcept(t, "Measure", "code", element.getCode(), -1); 9848 for (int i = 0; i < element.getUsage().size(); i++) 9849 composeCodeableConcept(t, "Measure", "usage", element.getUsage().get(i), i); 9850 if (element.hasDescriptionElement()) 9851 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 9852 if (element.hasCriteria()) 9853 composeExpression(t, "Measure", "criteria", element.getCriteria(), -1); 9854 } 9855 9856 protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport element, int index) { 9857 if (element == null) 9858 return; 9859 Complex t; 9860 if (Utilities.noString(parentType)) 9861 t = parent; 9862 else { 9863 t = parent.predicate("fhir:"+parentType+'.'+name); 9864 } 9865 composeDomainResource(t, "MeasureReport", name, element, index); 9866 for (int i = 0; i < element.getIdentifier().size(); i++) 9867 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier().get(i), i); 9868 if (element.hasStatusElement()) 9869 composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1); 9870 if (element.hasTypeElement()) 9871 composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1); 9872 if (element.hasMeasureElement()) 9873 composeCanonical(t, "MeasureReport", "measure", element.getMeasureElement(), -1); 9874 if (element.hasSubject()) 9875 composeReference(t, "MeasureReport", "subject", element.getSubject(), -1); 9876 if (element.hasDateElement()) 9877 composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1); 9878 if (element.hasReporter()) 9879 composeReference(t, "MeasureReport", "reporter", element.getReporter(), -1); 9880 if (element.hasPeriod()) 9881 composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1); 9882 if (element.hasImprovementNotation()) 9883 composeCodeableConcept(t, "MeasureReport", "improvementNotation", element.getImprovementNotation(), -1); 9884 for (int i = 0; i < element.getGroup().size(); i++) 9885 composeMeasureReportMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i); 9886 for (int i = 0; i < element.getEvaluatedResource().size(); i++) 9887 composeReference(t, "MeasureReport", "evaluatedResource", element.getEvaluatedResource().get(i), i); 9888 } 9889 9890 protected void composeMeasureReportMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) { 9891 if (element == null) 9892 return; 9893 Complex t; 9894 if (Utilities.noString(parentType)) 9895 t = parent; 9896 else { 9897 t = parent.predicate("fhir:"+parentType+'.'+name); 9898 } 9899 composeBackboneElement(t, "group", name, element, index); 9900 if (element.hasCode()) 9901 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 9902 for (int i = 0; i < element.getPopulation().size(); i++) 9903 composeMeasureReportMeasureReportGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 9904 if (element.hasMeasureScore()) 9905 composeQuantity(t, "MeasureReport", "measureScore", element.getMeasureScore(), -1); 9906 for (int i = 0; i < element.getStratifier().size(); i++) 9907 composeMeasureReportMeasureReportGroupStratifierComponent(t, "MeasureReport", "stratifier", element.getStratifier().get(i), i); 9908 } 9909 9910 protected void composeMeasureReportMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent element, int index) { 9911 if (element == null) 9912 return; 9913 Complex t; 9914 if (Utilities.noString(parentType)) 9915 t = parent; 9916 else { 9917 t = parent.predicate("fhir:"+parentType+'.'+name); 9918 } 9919 composeBackboneElement(t, "population", name, element, index); 9920 if (element.hasCode()) 9921 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 9922 if (element.hasCountElement()) 9923 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 9924 if (element.hasSubjectResults()) 9925 composeReference(t, "MeasureReport", "subjectResults", element.getSubjectResults(), -1); 9926 } 9927 9928 protected void composeMeasureReportMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent element, int index) { 9929 if (element == null) 9930 return; 9931 Complex t; 9932 if (Utilities.noString(parentType)) 9933 t = parent; 9934 else { 9935 t = parent.predicate("fhir:"+parentType+'.'+name); 9936 } 9937 composeBackboneElement(t, "stratifier", name, element, index); 9938 for (int i = 0; i < element.getCode().size(); i++) 9939 composeCodeableConcept(t, "MeasureReport", "code", element.getCode().get(i), i); 9940 for (int i = 0; i < element.getStratum().size(); i++) 9941 composeMeasureReportStratifierGroupComponent(t, "MeasureReport", "stratum", element.getStratum().get(i), i); 9942 } 9943 9944 protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent element, int index) { 9945 if (element == null) 9946 return; 9947 Complex t; 9948 if (Utilities.noString(parentType)) 9949 t = parent; 9950 else { 9951 t = parent.predicate("fhir:"+parentType+'.'+name); 9952 } 9953 composeBackboneElement(t, "stratum", name, element, index); 9954 if (element.hasValue()) 9955 composeCodeableConcept(t, "MeasureReport", "value", element.getValue(), -1); 9956 for (int i = 0; i < element.getComponent().size(); i++) 9957 composeMeasureReportStratifierGroupComponentComponent(t, "MeasureReport", "component", element.getComponent().get(i), i); 9958 for (int i = 0; i < element.getPopulation().size(); i++) 9959 composeMeasureReportStratifierGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 9960 if (element.hasMeasureScore()) 9961 composeQuantity(t, "MeasureReport", "measureScore", element.getMeasureScore(), -1); 9962 } 9963 9964 protected void composeMeasureReportStratifierGroupComponentComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponentComponent element, int index) { 9965 if (element == null) 9966 return; 9967 Complex t; 9968 if (Utilities.noString(parentType)) 9969 t = parent; 9970 else { 9971 t = parent.predicate("fhir:"+parentType+'.'+name); 9972 } 9973 composeBackboneElement(t, "component", name, element, index); 9974 if (element.hasCode()) 9975 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 9976 if (element.hasValue()) 9977 composeCodeableConcept(t, "MeasureReport", "value", element.getValue(), -1); 9978 } 9979 9980 protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent element, int index) { 9981 if (element == null) 9982 return; 9983 Complex t; 9984 if (Utilities.noString(parentType)) 9985 t = parent; 9986 else { 9987 t = parent.predicate("fhir:"+parentType+'.'+name); 9988 } 9989 composeBackboneElement(t, "population", name, element, index); 9990 if (element.hasCode()) 9991 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 9992 if (element.hasCountElement()) 9993 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 9994 if (element.hasSubjectResults()) 9995 composeReference(t, "MeasureReport", "subjectResults", element.getSubjectResults(), -1); 9996 } 9997 9998 protected void composeMedia(Complex parent, String parentType, String name, Media element, int index) { 9999 if (element == null) 10000 return; 10001 Complex t; 10002 if (Utilities.noString(parentType)) 10003 t = parent; 10004 else { 10005 t = parent.predicate("fhir:"+parentType+'.'+name); 10006 } 10007 composeDomainResource(t, "Media", name, element, index); 10008 for (int i = 0; i < element.getIdentifier().size(); i++) 10009 composeIdentifier(t, "Media", "identifier", element.getIdentifier().get(i), i); 10010 for (int i = 0; i < element.getBasedOn().size(); i++) 10011 composeReference(t, "Media", "basedOn", element.getBasedOn().get(i), i); 10012 for (int i = 0; i < element.getPartOf().size(); i++) 10013 composeReference(t, "Media", "partOf", element.getPartOf().get(i), i); 10014 if (element.hasStatusElement()) 10015 composeEnum(t, "Media", "status", element.getStatusElement(), -1); 10016 if (element.hasType()) 10017 composeCodeableConcept(t, "Media", "type", element.getType(), -1); 10018 if (element.hasModality()) 10019 composeCodeableConcept(t, "Media", "modality", element.getModality(), -1); 10020 if (element.hasView()) 10021 composeCodeableConcept(t, "Media", "view", element.getView(), -1); 10022 if (element.hasSubject()) 10023 composeReference(t, "Media", "subject", element.getSubject(), -1); 10024 if (element.hasEncounter()) 10025 composeReference(t, "Media", "encounter", element.getEncounter(), -1); 10026 if (element.hasCreated()) 10027 composeType(t, "Media", "created", element.getCreated(), -1); 10028 if (element.hasIssuedElement()) 10029 composeInstant(t, "Media", "issued", element.getIssuedElement(), -1); 10030 if (element.hasOperator()) 10031 composeReference(t, "Media", "operator", element.getOperator(), -1); 10032 for (int i = 0; i < element.getReasonCode().size(); i++) 10033 composeCodeableConcept(t, "Media", "reasonCode", element.getReasonCode().get(i), i); 10034 if (element.hasBodySite()) 10035 composeCodeableConcept(t, "Media", "bodySite", element.getBodySite(), -1); 10036 if (element.hasDeviceNameElement()) 10037 composeString(t, "Media", "deviceName", element.getDeviceNameElement(), -1); 10038 if (element.hasDevice()) 10039 composeReference(t, "Media", "device", element.getDevice(), -1); 10040 if (element.hasHeightElement()) 10041 composePositiveInt(t, "Media", "height", element.getHeightElement(), -1); 10042 if (element.hasWidthElement()) 10043 composePositiveInt(t, "Media", "width", element.getWidthElement(), -1); 10044 if (element.hasFramesElement()) 10045 composePositiveInt(t, "Media", "frames", element.getFramesElement(), -1); 10046 if (element.hasDurationElement()) 10047 composeDecimal(t, "Media", "duration", element.getDurationElement(), -1); 10048 if (element.hasContent()) 10049 composeAttachment(t, "Media", "content", element.getContent(), -1); 10050 for (int i = 0; i < element.getNote().size(); i++) 10051 composeAnnotation(t, "Media", "note", element.getNote().get(i), i); 10052 } 10053 10054 protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) { 10055 if (element == null) 10056 return; 10057 Complex t; 10058 if (Utilities.noString(parentType)) 10059 t = parent; 10060 else { 10061 t = parent.predicate("fhir:"+parentType+'.'+name); 10062 } 10063 composeDomainResource(t, "Medication", name, element, index); 10064 for (int i = 0; i < element.getIdentifier().size(); i++) 10065 composeIdentifier(t, "Medication", "identifier", element.getIdentifier().get(i), i); 10066 if (element.hasCode()) 10067 composeCodeableConcept(t, "Medication", "code", element.getCode(), -1); 10068 if (element.hasStatusElement()) 10069 composeEnum(t, "Medication", "status", element.getStatusElement(), -1); 10070 if (element.hasManufacturer()) 10071 composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1); 10072 if (element.hasForm()) 10073 composeCodeableConcept(t, "Medication", "form", element.getForm(), -1); 10074 if (element.hasAmount()) 10075 composeRatio(t, "Medication", "amount", element.getAmount(), -1); 10076 for (int i = 0; i < element.getIngredient().size(); i++) 10077 composeMedicationMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i); 10078 if (element.hasBatch()) 10079 composeMedicationMedicationBatchComponent(t, "Medication", "batch", element.getBatch(), -1); 10080 } 10081 10082 protected void composeMedicationMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent element, int index) { 10083 if (element == null) 10084 return; 10085 Complex t; 10086 if (Utilities.noString(parentType)) 10087 t = parent; 10088 else { 10089 t = parent.predicate("fhir:"+parentType+'.'+name); 10090 } 10091 composeBackboneElement(t, "ingredient", name, element, index); 10092 if (element.hasItem()) 10093 composeType(t, "Medication", "item", element.getItem(), -1); 10094 if (element.hasIsActiveElement()) 10095 composeBoolean(t, "Medication", "isActive", element.getIsActiveElement(), -1); 10096 if (element.hasStrength()) 10097 composeRatio(t, "Medication", "strength", element.getStrength(), -1); 10098 } 10099 10100 protected void composeMedicationMedicationBatchComponent(Complex parent, String parentType, String name, Medication.MedicationBatchComponent element, int index) { 10101 if (element == null) 10102 return; 10103 Complex t; 10104 if (Utilities.noString(parentType)) 10105 t = parent; 10106 else { 10107 t = parent.predicate("fhir:"+parentType+'.'+name); 10108 } 10109 composeBackboneElement(t, "batch", name, element, index); 10110 if (element.hasLotNumberElement()) 10111 composeString(t, "Medication", "lotNumber", element.getLotNumberElement(), -1); 10112 if (element.hasExpirationDateElement()) 10113 composeDateTime(t, "Medication", "expirationDate", element.getExpirationDateElement(), -1); 10114 } 10115 10116 protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) { 10117 if (element == null) 10118 return; 10119 Complex t; 10120 if (Utilities.noString(parentType)) 10121 t = parent; 10122 else { 10123 t = parent.predicate("fhir:"+parentType+'.'+name); 10124 } 10125 composeDomainResource(t, "MedicationAdministration", name, element, index); 10126 for (int i = 0; i < element.getIdentifier().size(); i++) 10127 composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i); 10128 for (int i = 0; i < element.getInstantiates().size(); i++) 10129 composeUri(t, "MedicationAdministration", "instantiates", element.getInstantiates().get(i), i); 10130 for (int i = 0; i < element.getPartOf().size(); i++) 10131 composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i); 10132 if (element.hasStatusElement()) 10133 composeCode(t, "MedicationAdministration", "status", element.getStatusElement(), -1); 10134 for (int i = 0; i < element.getStatusReason().size(); i++) 10135 composeCodeableConcept(t, "MedicationAdministration", "statusReason", element.getStatusReason().get(i), i); 10136 if (element.hasCategory()) 10137 composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory(), -1); 10138 if (element.hasMedication()) 10139 composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1); 10140 if (element.hasSubject()) 10141 composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1); 10142 if (element.hasContext()) 10143 composeReference(t, "MedicationAdministration", "context", element.getContext(), -1); 10144 for (int i = 0; i < element.getSupportingInformation().size(); i++) 10145 composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i); 10146 if (element.hasEffective()) 10147 composeType(t, "MedicationAdministration", "effective", element.getEffective(), -1); 10148 for (int i = 0; i < element.getPerformer().size(); i++) 10149 composeMedicationAdministrationMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i); 10150 for (int i = 0; i < element.getReasonCode().size(); i++) 10151 composeCodeableConcept(t, "MedicationAdministration", "reasonCode", element.getReasonCode().get(i), i); 10152 for (int i = 0; i < element.getReasonReference().size(); i++) 10153 composeReference(t, "MedicationAdministration", "reasonReference", element.getReasonReference().get(i), i); 10154 if (element.hasRequest()) 10155 composeReference(t, "MedicationAdministration", "request", element.getRequest(), -1); 10156 for (int i = 0; i < element.getDevice().size(); i++) 10157 composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i); 10158 for (int i = 0; i < element.getNote().size(); i++) 10159 composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i); 10160 if (element.hasDosage()) 10161 composeMedicationAdministrationMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1); 10162 for (int i = 0; i < element.getEventHistory().size(); i++) 10163 composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i); 10164 } 10165 10166 protected void composeMedicationAdministrationMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent element, int index) { 10167 if (element == null) 10168 return; 10169 Complex t; 10170 if (Utilities.noString(parentType)) 10171 t = parent; 10172 else { 10173 t = parent.predicate("fhir:"+parentType+'.'+name); 10174 } 10175 composeBackboneElement(t, "performer", name, element, index); 10176 if (element.hasFunction()) 10177 composeCodeableConcept(t, "MedicationAdministration", "function", element.getFunction(), -1); 10178 if (element.hasActor()) 10179 composeReference(t, "MedicationAdministration", "actor", element.getActor(), -1); 10180 } 10181 10182 protected void composeMedicationAdministrationMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent element, int index) { 10183 if (element == null) 10184 return; 10185 Complex t; 10186 if (Utilities.noString(parentType)) 10187 t = parent; 10188 else { 10189 t = parent.predicate("fhir:"+parentType+'.'+name); 10190 } 10191 composeBackboneElement(t, "dosage", name, element, index); 10192 if (element.hasTextElement()) 10193 composeString(t, "MedicationAdministration", "text", element.getTextElement(), -1); 10194 if (element.hasSite()) 10195 composeCodeableConcept(t, "MedicationAdministration", "site", element.getSite(), -1); 10196 if (element.hasRoute()) 10197 composeCodeableConcept(t, "MedicationAdministration", "route", element.getRoute(), -1); 10198 if (element.hasMethod()) 10199 composeCodeableConcept(t, "MedicationAdministration", "method", element.getMethod(), -1); 10200 if (element.hasDose()) 10201 composeQuantity(t, "MedicationAdministration", "dose", element.getDose(), -1); 10202 if (element.hasRate()) 10203 composeType(t, "MedicationAdministration", "rate", element.getRate(), -1); 10204 } 10205 10206 protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) { 10207 if (element == null) 10208 return; 10209 Complex t; 10210 if (Utilities.noString(parentType)) 10211 t = parent; 10212 else { 10213 t = parent.predicate("fhir:"+parentType+'.'+name); 10214 } 10215 composeDomainResource(t, "MedicationDispense", name, element, index); 10216 for (int i = 0; i < element.getIdentifier().size(); i++) 10217 composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i); 10218 for (int i = 0; i < element.getPartOf().size(); i++) 10219 composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i); 10220 if (element.hasStatusElement()) 10221 composeCode(t, "MedicationDispense", "status", element.getStatusElement(), -1); 10222 if (element.hasStatusReason()) 10223 composeType(t, "MedicationDispense", "statusReason", element.getStatusReason(), -1); 10224 if (element.hasCategory()) 10225 composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory(), -1); 10226 if (element.hasMedication()) 10227 composeType(t, "MedicationDispense", "medication", element.getMedication(), -1); 10228 if (element.hasSubject()) 10229 composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1); 10230 if (element.hasContext()) 10231 composeReference(t, "MedicationDispense", "context", element.getContext(), -1); 10232 for (int i = 0; i < element.getSupportingInformation().size(); i++) 10233 composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i); 10234 for (int i = 0; i < element.getPerformer().size(); i++) 10235 composeMedicationDispenseMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i); 10236 if (element.hasLocation()) 10237 composeReference(t, "MedicationDispense", "location", element.getLocation(), -1); 10238 for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) 10239 composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i); 10240 if (element.hasType()) 10241 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 10242 if (element.hasQuantity()) 10243 composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1); 10244 if (element.hasDaysSupply()) 10245 composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1); 10246 if (element.hasWhenPreparedElement()) 10247 composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1); 10248 if (element.hasWhenHandedOverElement()) 10249 composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1); 10250 if (element.hasDestination()) 10251 composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1); 10252 for (int i = 0; i < element.getReceiver().size(); i++) 10253 composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i); 10254 for (int i = 0; i < element.getNote().size(); i++) 10255 composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i); 10256 for (int i = 0; i < element.getDosageInstruction().size(); i++) 10257 composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i); 10258 if (element.hasSubstitution()) 10259 composeMedicationDispenseMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1); 10260 for (int i = 0; i < element.getDetectedIssue().size(); i++) 10261 composeReference(t, "MedicationDispense", "detectedIssue", element.getDetectedIssue().get(i), i); 10262 for (int i = 0; i < element.getEventHistory().size(); i++) 10263 composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i); 10264 } 10265 10266 protected void composeMedicationDispenseMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent element, int index) { 10267 if (element == null) 10268 return; 10269 Complex t; 10270 if (Utilities.noString(parentType)) 10271 t = parent; 10272 else { 10273 t = parent.predicate("fhir:"+parentType+'.'+name); 10274 } 10275 composeBackboneElement(t, "performer", name, element, index); 10276 if (element.hasFunction()) 10277 composeCodeableConcept(t, "MedicationDispense", "function", element.getFunction(), -1); 10278 if (element.hasActor()) 10279 composeReference(t, "MedicationDispense", "actor", element.getActor(), -1); 10280 } 10281 10282 protected void composeMedicationDispenseMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) { 10283 if (element == null) 10284 return; 10285 Complex t; 10286 if (Utilities.noString(parentType)) 10287 t = parent; 10288 else { 10289 t = parent.predicate("fhir:"+parentType+'.'+name); 10290 } 10291 composeBackboneElement(t, "substitution", name, element, index); 10292 if (element.hasWasSubstitutedElement()) 10293 composeBoolean(t, "MedicationDispense", "wasSubstituted", element.getWasSubstitutedElement(), -1); 10294 if (element.hasType()) 10295 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 10296 for (int i = 0; i < element.getReason().size(); i++) 10297 composeCodeableConcept(t, "MedicationDispense", "reason", element.getReason().get(i), i); 10298 for (int i = 0; i < element.getResponsibleParty().size(); i++) 10299 composeReference(t, "MedicationDispense", "responsibleParty", element.getResponsibleParty().get(i), i); 10300 } 10301 10302 protected void composeMedicationKnowledge(Complex parent, String parentType, String name, MedicationKnowledge element, int index) { 10303 if (element == null) 10304 return; 10305 Complex t; 10306 if (Utilities.noString(parentType)) 10307 t = parent; 10308 else { 10309 t = parent.predicate("fhir:"+parentType+'.'+name); 10310 } 10311 composeDomainResource(t, "MedicationKnowledge", name, element, index); 10312 if (element.hasCode()) 10313 composeCodeableConcept(t, "MedicationKnowledge", "code", element.getCode(), -1); 10314 if (element.hasStatusElement()) 10315 composeCode(t, "MedicationKnowledge", "status", element.getStatusElement(), -1); 10316 if (element.hasManufacturer()) 10317 composeReference(t, "MedicationKnowledge", "manufacturer", element.getManufacturer(), -1); 10318 if (element.hasDoseForm()) 10319 composeCodeableConcept(t, "MedicationKnowledge", "doseForm", element.getDoseForm(), -1); 10320 if (element.hasAmount()) 10321 composeQuantity(t, "MedicationKnowledge", "amount", element.getAmount(), -1); 10322 for (int i = 0; i < element.getSynonym().size(); i++) 10323 composeString(t, "MedicationKnowledge", "synonym", element.getSynonym().get(i), i); 10324 for (int i = 0; i < element.getRelatedMedicationKnowledge().size(); i++) 10325 composeMedicationKnowledgeMedicationKnowledgeRelatedMedicationKnowledgeComponent(t, "MedicationKnowledge", "relatedMedicationKnowledge", element.getRelatedMedicationKnowledge().get(i), i); 10326 for (int i = 0; i < element.getAssociatedMedication().size(); i++) 10327 composeReference(t, "MedicationKnowledge", "associatedMedication", element.getAssociatedMedication().get(i), i); 10328 for (int i = 0; i < element.getProductType().size(); i++) 10329 composeCodeableConcept(t, "MedicationKnowledge", "productType", element.getProductType().get(i), i); 10330 for (int i = 0; i < element.getMonograph().size(); i++) 10331 composeMedicationKnowledgeMedicationKnowledgeMonographComponent(t, "MedicationKnowledge", "monograph", element.getMonograph().get(i), i); 10332 for (int i = 0; i < element.getIngredient().size(); i++) 10333 composeMedicationKnowledgeMedicationKnowledgeIngredientComponent(t, "MedicationKnowledge", "ingredient", element.getIngredient().get(i), i); 10334 if (element.hasPreparationInstructionElement()) 10335 composeMarkdown(t, "MedicationKnowledge", "preparationInstruction", element.getPreparationInstructionElement(), -1); 10336 for (int i = 0; i < element.getIntendedRoute().size(); i++) 10337 composeCodeableConcept(t, "MedicationKnowledge", "intendedRoute", element.getIntendedRoute().get(i), i); 10338 for (int i = 0; i < element.getCost().size(); i++) 10339 composeMedicationKnowledgeMedicationKnowledgeCostComponent(t, "MedicationKnowledge", "cost", element.getCost().get(i), i); 10340 for (int i = 0; i < element.getMonitoringProgram().size(); i++) 10341 composeMedicationKnowledgeMedicationKnowledgeMonitoringProgramComponent(t, "MedicationKnowledge", "monitoringProgram", element.getMonitoringProgram().get(i), i); 10342 for (int i = 0; i < element.getAdministrationGuidelines().size(); i++) 10343 composeMedicationKnowledgeMedicationKnowledgeAdministrationGuidelinesComponent(t, "MedicationKnowledge", "administrationGuidelines", element.getAdministrationGuidelines().get(i), i); 10344 for (int i = 0; i < element.getMedicineClassification().size(); i++) 10345 composeMedicationKnowledgeMedicationKnowledgeMedicineClassificationComponent(t, "MedicationKnowledge", "medicineClassification", element.getMedicineClassification().get(i), i); 10346 if (element.hasPackaging()) 10347 composeMedicationKnowledgeMedicationKnowledgePackagingComponent(t, "MedicationKnowledge", "packaging", element.getPackaging(), -1); 10348 for (int i = 0; i < element.getDrugCharacteristic().size(); i++) 10349 composeMedicationKnowledgeMedicationKnowledgeDrugCharacteristicComponent(t, "MedicationKnowledge", "drugCharacteristic", element.getDrugCharacteristic().get(i), i); 10350 for (int i = 0; i < element.getContraindication().size(); i++) 10351 composeReference(t, "MedicationKnowledge", "contraindication", element.getContraindication().get(i), i); 10352 for (int i = 0; i < element.getRegulatory().size(); i++) 10353 composeMedicationKnowledgeMedicationKnowledgeRegulatoryComponent(t, "MedicationKnowledge", "regulatory", element.getRegulatory().get(i), i); 10354 for (int i = 0; i < element.getKinetics().size(); i++) 10355 composeMedicationKnowledgeMedicationKnowledgeKineticsComponent(t, "MedicationKnowledge", "kinetics", element.getKinetics().get(i), i); 10356 } 10357 10358 protected void composeMedicationKnowledgeMedicationKnowledgeRelatedMedicationKnowledgeComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRelatedMedicationKnowledgeComponent element, int index) { 10359 if (element == null) 10360 return; 10361 Complex t; 10362 if (Utilities.noString(parentType)) 10363 t = parent; 10364 else { 10365 t = parent.predicate("fhir:"+parentType+'.'+name); 10366 } 10367 composeBackboneElement(t, "relatedMedicationKnowledge", name, element, index); 10368 if (element.hasType()) 10369 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10370 for (int i = 0; i < element.getReference().size(); i++) 10371 composeReference(t, "MedicationKnowledge", "reference", element.getReference().get(i), i); 10372 } 10373 10374 protected void composeMedicationKnowledgeMedicationKnowledgeMonographComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonographComponent element, int index) { 10375 if (element == null) 10376 return; 10377 Complex t; 10378 if (Utilities.noString(parentType)) 10379 t = parent; 10380 else { 10381 t = parent.predicate("fhir:"+parentType+'.'+name); 10382 } 10383 composeBackboneElement(t, "monograph", name, element, index); 10384 if (element.hasType()) 10385 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10386 if (element.hasSource()) 10387 composeReference(t, "MedicationKnowledge", "source", element.getSource(), -1); 10388 } 10389 10390 protected void composeMedicationKnowledgeMedicationKnowledgeIngredientComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeIngredientComponent element, int index) { 10391 if (element == null) 10392 return; 10393 Complex t; 10394 if (Utilities.noString(parentType)) 10395 t = parent; 10396 else { 10397 t = parent.predicate("fhir:"+parentType+'.'+name); 10398 } 10399 composeBackboneElement(t, "ingredient", name, element, index); 10400 if (element.hasItem()) 10401 composeType(t, "MedicationKnowledge", "item", element.getItem(), -1); 10402 if (element.hasIsActiveElement()) 10403 composeBoolean(t, "MedicationKnowledge", "isActive", element.getIsActiveElement(), -1); 10404 if (element.hasStrength()) 10405 composeRatio(t, "MedicationKnowledge", "strength", element.getStrength(), -1); 10406 } 10407 10408 protected void composeMedicationKnowledgeMedicationKnowledgeCostComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeCostComponent element, int index) { 10409 if (element == null) 10410 return; 10411 Complex t; 10412 if (Utilities.noString(parentType)) 10413 t = parent; 10414 else { 10415 t = parent.predicate("fhir:"+parentType+'.'+name); 10416 } 10417 composeBackboneElement(t, "cost", name, element, index); 10418 if (element.hasType()) 10419 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10420 if (element.hasSourceElement()) 10421 composeString(t, "MedicationKnowledge", "source", element.getSourceElement(), -1); 10422 if (element.hasCost()) 10423 composeMoney(t, "MedicationKnowledge", "cost", element.getCost(), -1); 10424 } 10425 10426 protected void composeMedicationKnowledgeMedicationKnowledgeMonitoringProgramComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonitoringProgramComponent element, int index) { 10427 if (element == null) 10428 return; 10429 Complex t; 10430 if (Utilities.noString(parentType)) 10431 t = parent; 10432 else { 10433 t = parent.predicate("fhir:"+parentType+'.'+name); 10434 } 10435 composeBackboneElement(t, "monitoringProgram", name, element, index); 10436 if (element.hasType()) 10437 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10438 if (element.hasNameElement()) 10439 composeString(t, "MedicationKnowledge", "name", element.getNameElement(), -1); 10440 } 10441 10442 protected void composeMedicationKnowledgeMedicationKnowledgeAdministrationGuidelinesComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelinesComponent element, int index) { 10443 if (element == null) 10444 return; 10445 Complex t; 10446 if (Utilities.noString(parentType)) 10447 t = parent; 10448 else { 10449 t = parent.predicate("fhir:"+parentType+'.'+name); 10450 } 10451 composeBackboneElement(t, "administrationGuidelines", name, element, index); 10452 for (int i = 0; i < element.getDosage().size(); i++) 10453 composeMedicationKnowledgeMedicationKnowledgeAdministrationGuidelinesDosageComponent(t, "MedicationKnowledge", "dosage", element.getDosage().get(i), i); 10454 if (element.hasIndication()) 10455 composeType(t, "MedicationKnowledge", "indication", element.getIndication(), -1); 10456 for (int i = 0; i < element.getPatientCharacteristics().size(); i++) 10457 composeMedicationKnowledgeMedicationKnowledgeAdministrationGuidelinesPatientCharacteristicsComponent(t, "MedicationKnowledge", "patientCharacteristics", element.getPatientCharacteristics().get(i), i); 10458 } 10459 10460 protected void composeMedicationKnowledgeMedicationKnowledgeAdministrationGuidelinesDosageComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelinesDosageComponent element, int index) { 10461 if (element == null) 10462 return; 10463 Complex t; 10464 if (Utilities.noString(parentType)) 10465 t = parent; 10466 else { 10467 t = parent.predicate("fhir:"+parentType+'.'+name); 10468 } 10469 composeBackboneElement(t, "dosage", name, element, index); 10470 if (element.hasType()) 10471 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10472 for (int i = 0; i < element.getDosage().size(); i++) 10473 composeDosage(t, "MedicationKnowledge", "dosage", element.getDosage().get(i), i); 10474 } 10475 10476 protected void composeMedicationKnowledgeMedicationKnowledgeAdministrationGuidelinesPatientCharacteristicsComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelinesPatientCharacteristicsComponent element, int index) { 10477 if (element == null) 10478 return; 10479 Complex t; 10480 if (Utilities.noString(parentType)) 10481 t = parent; 10482 else { 10483 t = parent.predicate("fhir:"+parentType+'.'+name); 10484 } 10485 composeBackboneElement(t, "patientCharacteristics", name, element, index); 10486 if (element.hasCharacteristic()) 10487 composeType(t, "MedicationKnowledge", "characteristic", element.getCharacteristic(), -1); 10488 for (int i = 0; i < element.getValue().size(); i++) 10489 composeString(t, "MedicationKnowledge", "value", element.getValue().get(i), i); 10490 } 10491 10492 protected void composeMedicationKnowledgeMedicationKnowledgeMedicineClassificationComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMedicineClassificationComponent element, int index) { 10493 if (element == null) 10494 return; 10495 Complex t; 10496 if (Utilities.noString(parentType)) 10497 t = parent; 10498 else { 10499 t = parent.predicate("fhir:"+parentType+'.'+name); 10500 } 10501 composeBackboneElement(t, "medicineClassification", name, element, index); 10502 if (element.hasType()) 10503 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10504 for (int i = 0; i < element.getClassification().size(); i++) 10505 composeCodeableConcept(t, "MedicationKnowledge", "classification", element.getClassification().get(i), i); 10506 } 10507 10508 protected void composeMedicationKnowledgeMedicationKnowledgePackagingComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgePackagingComponent element, int index) { 10509 if (element == null) 10510 return; 10511 Complex t; 10512 if (Utilities.noString(parentType)) 10513 t = parent; 10514 else { 10515 t = parent.predicate("fhir:"+parentType+'.'+name); 10516 } 10517 composeBackboneElement(t, "packaging", name, element, index); 10518 if (element.hasType()) 10519 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10520 if (element.hasQuantity()) 10521 composeQuantity(t, "MedicationKnowledge", "quantity", element.getQuantity(), -1); 10522 } 10523 10524 protected void composeMedicationKnowledgeMedicationKnowledgeDrugCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeDrugCharacteristicComponent element, int index) { 10525 if (element == null) 10526 return; 10527 Complex t; 10528 if (Utilities.noString(parentType)) 10529 t = parent; 10530 else { 10531 t = parent.predicate("fhir:"+parentType+'.'+name); 10532 } 10533 composeBackboneElement(t, "drugCharacteristic", name, element, index); 10534 if (element.hasType()) 10535 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10536 if (element.hasValue()) 10537 composeType(t, "MedicationKnowledge", "value", element.getValue(), -1); 10538 } 10539 10540 protected void composeMedicationKnowledgeMedicationKnowledgeRegulatoryComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryComponent element, int index) { 10541 if (element == null) 10542 return; 10543 Complex t; 10544 if (Utilities.noString(parentType)) 10545 t = parent; 10546 else { 10547 t = parent.predicate("fhir:"+parentType+'.'+name); 10548 } 10549 composeBackboneElement(t, "regulatory", name, element, index); 10550 if (element.hasRegulatoryAuthority()) 10551 composeReference(t, "MedicationKnowledge", "regulatoryAuthority", element.getRegulatoryAuthority(), -1); 10552 for (int i = 0; i < element.getSubstitution().size(); i++) 10553 composeMedicationKnowledgeMedicationKnowledgeRegulatorySubstitutionComponent(t, "MedicationKnowledge", "substitution", element.getSubstitution().get(i), i); 10554 for (int i = 0; i < element.getSchedule().size(); i++) 10555 composeMedicationKnowledgeMedicationKnowledgeRegulatoryScheduleComponent(t, "MedicationKnowledge", "schedule", element.getSchedule().get(i), i); 10556 if (element.hasMaxDispense()) 10557 composeMedicationKnowledgeMedicationKnowledgeRegulatoryMaxDispenseComponent(t, "MedicationKnowledge", "maxDispense", element.getMaxDispense(), -1); 10558 } 10559 10560 protected void composeMedicationKnowledgeMedicationKnowledgeRegulatorySubstitutionComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatorySubstitutionComponent element, int index) { 10561 if (element == null) 10562 return; 10563 Complex t; 10564 if (Utilities.noString(parentType)) 10565 t = parent; 10566 else { 10567 t = parent.predicate("fhir:"+parentType+'.'+name); 10568 } 10569 composeBackboneElement(t, "substitution", name, element, index); 10570 if (element.hasType()) 10571 composeCodeableConcept(t, "MedicationKnowledge", "type", element.getType(), -1); 10572 if (element.hasAllowedElement()) 10573 composeBoolean(t, "MedicationKnowledge", "allowed", element.getAllowedElement(), -1); 10574 } 10575 10576 protected void composeMedicationKnowledgeMedicationKnowledgeRegulatoryScheduleComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryScheduleComponent element, int index) { 10577 if (element == null) 10578 return; 10579 Complex t; 10580 if (Utilities.noString(parentType)) 10581 t = parent; 10582 else { 10583 t = parent.predicate("fhir:"+parentType+'.'+name); 10584 } 10585 composeBackboneElement(t, "schedule", name, element, index); 10586 if (element.hasSchedule()) 10587 composeCodeableConcept(t, "MedicationKnowledge", "schedule", element.getSchedule(), -1); 10588 } 10589 10590 protected void composeMedicationKnowledgeMedicationKnowledgeRegulatoryMaxDispenseComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryMaxDispenseComponent element, int index) { 10591 if (element == null) 10592 return; 10593 Complex t; 10594 if (Utilities.noString(parentType)) 10595 t = parent; 10596 else { 10597 t = parent.predicate("fhir:"+parentType+'.'+name); 10598 } 10599 composeBackboneElement(t, "maxDispense", name, element, index); 10600 if (element.hasQuantity()) 10601 composeQuantity(t, "MedicationKnowledge", "quantity", element.getQuantity(), -1); 10602 if (element.hasPeriod()) 10603 composeDuration(t, "MedicationKnowledge", "period", element.getPeriod(), -1); 10604 } 10605 10606 protected void composeMedicationKnowledgeMedicationKnowledgeKineticsComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeKineticsComponent element, int index) { 10607 if (element == null) 10608 return; 10609 Complex t; 10610 if (Utilities.noString(parentType)) 10611 t = parent; 10612 else { 10613 t = parent.predicate("fhir:"+parentType+'.'+name); 10614 } 10615 composeBackboneElement(t, "kinetics", name, element, index); 10616 for (int i = 0; i < element.getAreaUnderCurve().size(); i++) 10617 composeQuantity(t, "MedicationKnowledge", "areaUnderCurve", element.getAreaUnderCurve().get(i), i); 10618 for (int i = 0; i < element.getLethalDose50().size(); i++) 10619 composeQuantity(t, "MedicationKnowledge", "lethalDose50", element.getLethalDose50().get(i), i); 10620 if (element.hasHalfLifePeriod()) 10621 composeDuration(t, "MedicationKnowledge", "halfLifePeriod", element.getHalfLifePeriod(), -1); 10622 } 10623 10624 protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest element, int index) { 10625 if (element == null) 10626 return; 10627 Complex t; 10628 if (Utilities.noString(parentType)) 10629 t = parent; 10630 else { 10631 t = parent.predicate("fhir:"+parentType+'.'+name); 10632 } 10633 composeDomainResource(t, "MedicationRequest", name, element, index); 10634 for (int i = 0; i < element.getIdentifier().size(); i++) 10635 composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i); 10636 if (element.hasStatusElement()) 10637 composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1); 10638 if (element.hasStatusReason()) 10639 composeCodeableConcept(t, "MedicationRequest", "statusReason", element.getStatusReason(), -1); 10640 if (element.hasIntentElement()) 10641 composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1); 10642 for (int i = 0; i < element.getCategory().size(); i++) 10643 composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory().get(i), i); 10644 if (element.hasPriorityElement()) 10645 composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1); 10646 if (element.hasDoNotPerformElement()) 10647 composeBoolean(t, "MedicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 10648 if (element.hasReported()) 10649 composeType(t, "MedicationRequest", "reported", element.getReported(), -1); 10650 if (element.hasMedication()) 10651 composeType(t, "MedicationRequest", "medication", element.getMedication(), -1); 10652 if (element.hasSubject()) 10653 composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1); 10654 if (element.hasEncounter()) 10655 composeReference(t, "MedicationRequest", "encounter", element.getEncounter(), -1); 10656 for (int i = 0; i < element.getSupportingInformation().size(); i++) 10657 composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i); 10658 if (element.hasAuthoredOnElement()) 10659 composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 10660 if (element.hasRequester()) 10661 composeReference(t, "MedicationRequest", "requester", element.getRequester(), -1); 10662 if (element.hasPerformer()) 10663 composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1); 10664 if (element.hasPerformerType()) 10665 composeCodeableConcept(t, "MedicationRequest", "performerType", element.getPerformerType(), -1); 10666 if (element.hasRecorder()) 10667 composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1); 10668 for (int i = 0; i < element.getReasonCode().size(); i++) 10669 composeCodeableConcept(t, "MedicationRequest", "reasonCode", element.getReasonCode().get(i), i); 10670 for (int i = 0; i < element.getReasonReference().size(); i++) 10671 composeReference(t, "MedicationRequest", "reasonReference", element.getReasonReference().get(i), i); 10672 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 10673 composeCanonical(t, "MedicationRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 10674 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 10675 composeUri(t, "MedicationRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i); 10676 for (int i = 0; i < element.getBasedOn().size(); i++) 10677 composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i); 10678 if (element.hasGroupIdentifier()) 10679 composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 10680 if (element.hasCourseOfTherapyType()) 10681 composeCodeableConcept(t, "MedicationRequest", "courseOfTherapyType", element.getCourseOfTherapyType(), -1); 10682 for (int i = 0; i < element.getInsurance().size(); i++) 10683 composeReference(t, "MedicationRequest", "insurance", element.getInsurance().get(i), i); 10684 for (int i = 0; i < element.getNote().size(); i++) 10685 composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i); 10686 for (int i = 0; i < element.getDosageInstruction().size(); i++) 10687 composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i); 10688 if (element.hasDispenseRequest()) 10689 composeMedicationRequestMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1); 10690 if (element.hasSubstitution()) 10691 composeMedicationRequestMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1); 10692 if (element.hasPriorPrescription()) 10693 composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1); 10694 for (int i = 0; i < element.getDetectedIssue().size(); i++) 10695 composeReference(t, "MedicationRequest", "detectedIssue", element.getDetectedIssue().get(i), i); 10696 for (int i = 0; i < element.getEventHistory().size(); i++) 10697 composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i); 10698 } 10699 10700 protected void composeMedicationRequestMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent element, int index) { 10701 if (element == null) 10702 return; 10703 Complex t; 10704 if (Utilities.noString(parentType)) 10705 t = parent; 10706 else { 10707 t = parent.predicate("fhir:"+parentType+'.'+name); 10708 } 10709 composeBackboneElement(t, "dispenseRequest", name, element, index); 10710 if (element.hasInitialFill()) 10711 composeMedicationRequestMedicationRequestDispenseRequestInitialFillComponent(t, "MedicationRequest", "initialFill", element.getInitialFill(), -1); 10712 if (element.hasDispenseInterval()) 10713 composeDuration(t, "MedicationRequest", "dispenseInterval", element.getDispenseInterval(), -1); 10714 if (element.hasValidityPeriod()) 10715 composePeriod(t, "MedicationRequest", "validityPeriod", element.getValidityPeriod(), -1); 10716 if (element.hasNumberOfRepeatsAllowedElement()) 10717 composeUnsignedInt(t, "MedicationRequest", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1); 10718 if (element.hasQuantity()) 10719 composeQuantity(t, "MedicationRequest", "quantity", element.getQuantity(), -1); 10720 if (element.hasExpectedSupplyDuration()) 10721 composeDuration(t, "MedicationRequest", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1); 10722 if (element.hasPerformer()) 10723 composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1); 10724 } 10725 10726 protected void composeMedicationRequestMedicationRequestDispenseRequestInitialFillComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestInitialFillComponent element, int index) { 10727 if (element == null) 10728 return; 10729 Complex t; 10730 if (Utilities.noString(parentType)) 10731 t = parent; 10732 else { 10733 t = parent.predicate("fhir:"+parentType+'.'+name); 10734 } 10735 composeBackboneElement(t, "initialFill", name, element, index); 10736 if (element.hasQuantity()) 10737 composeQuantity(t, "MedicationRequest", "quantity", element.getQuantity(), -1); 10738 if (element.hasDuration()) 10739 composeDuration(t, "MedicationRequest", "duration", element.getDuration(), -1); 10740 } 10741 10742 protected void composeMedicationRequestMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent element, int index) { 10743 if (element == null) 10744 return; 10745 Complex t; 10746 if (Utilities.noString(parentType)) 10747 t = parent; 10748 else { 10749 t = parent.predicate("fhir:"+parentType+'.'+name); 10750 } 10751 composeBackboneElement(t, "substitution", name, element, index); 10752 if (element.hasAllowed()) 10753 composeType(t, "MedicationRequest", "allowed", element.getAllowed(), -1); 10754 if (element.hasReason()) 10755 composeCodeableConcept(t, "MedicationRequest", "reason", element.getReason(), -1); 10756 } 10757 10758 protected void composeMedicationStatement(Complex parent, String parentType, String name, MedicationStatement element, int index) { 10759 if (element == null) 10760 return; 10761 Complex t; 10762 if (Utilities.noString(parentType)) 10763 t = parent; 10764 else { 10765 t = parent.predicate("fhir:"+parentType+'.'+name); 10766 } 10767 composeDomainResource(t, "MedicationStatement", name, element, index); 10768 for (int i = 0; i < element.getIdentifier().size(); i++) 10769 composeIdentifier(t, "MedicationStatement", "identifier", element.getIdentifier().get(i), i); 10770 for (int i = 0; i < element.getBasedOn().size(); i++) 10771 composeReference(t, "MedicationStatement", "basedOn", element.getBasedOn().get(i), i); 10772 for (int i = 0; i < element.getPartOf().size(); i++) 10773 composeReference(t, "MedicationStatement", "partOf", element.getPartOf().get(i), i); 10774 if (element.hasStatusElement()) 10775 composeEnum(t, "MedicationStatement", "status", element.getStatusElement(), -1); 10776 for (int i = 0; i < element.getStatusReason().size(); i++) 10777 composeCodeableConcept(t, "MedicationStatement", "statusReason", element.getStatusReason().get(i), i); 10778 if (element.hasCategory()) 10779 composeCodeableConcept(t, "MedicationStatement", "category", element.getCategory(), -1); 10780 if (element.hasMedication()) 10781 composeType(t, "MedicationStatement", "medication", element.getMedication(), -1); 10782 if (element.hasSubject()) 10783 composeReference(t, "MedicationStatement", "subject", element.getSubject(), -1); 10784 if (element.hasContext()) 10785 composeReference(t, "MedicationStatement", "context", element.getContext(), -1); 10786 if (element.hasEffective()) 10787 composeType(t, "MedicationStatement", "effective", element.getEffective(), -1); 10788 if (element.hasDateAssertedElement()) 10789 composeDateTime(t, "MedicationStatement", "dateAsserted", element.getDateAssertedElement(), -1); 10790 if (element.hasInformationSource()) 10791 composeReference(t, "MedicationStatement", "informationSource", element.getInformationSource(), -1); 10792 for (int i = 0; i < element.getDerivedFrom().size(); i++) 10793 composeReference(t, "MedicationStatement", "derivedFrom", element.getDerivedFrom().get(i), i); 10794 for (int i = 0; i < element.getReasonCode().size(); i++) 10795 composeCodeableConcept(t, "MedicationStatement", "reasonCode", element.getReasonCode().get(i), i); 10796 for (int i = 0; i < element.getReasonReference().size(); i++) 10797 composeReference(t, "MedicationStatement", "reasonReference", element.getReasonReference().get(i), i); 10798 for (int i = 0; i < element.getNote().size(); i++) 10799 composeAnnotation(t, "MedicationStatement", "note", element.getNote().get(i), i); 10800 for (int i = 0; i < element.getDosage().size(); i++) 10801 composeDosage(t, "MedicationStatement", "dosage", element.getDosage().get(i), i); 10802 } 10803 10804 protected void composeMedicinalProduct(Complex parent, String parentType, String name, MedicinalProduct element, int index) { 10805 if (element == null) 10806 return; 10807 Complex t; 10808 if (Utilities.noString(parentType)) 10809 t = parent; 10810 else { 10811 t = parent.predicate("fhir:"+parentType+'.'+name); 10812 } 10813 composeDomainResource(t, "MedicinalProduct", name, element, index); 10814 for (int i = 0; i < element.getIdentifier().size(); i++) 10815 composeIdentifier(t, "MedicinalProduct", "identifier", element.getIdentifier().get(i), i); 10816 if (element.hasType()) 10817 composeCodeableConcept(t, "MedicinalProduct", "type", element.getType(), -1); 10818 if (element.hasDomain()) 10819 composeCoding(t, "MedicinalProduct", "domain", element.getDomain(), -1); 10820 if (element.hasCombinedPharmaceuticalDoseForm()) 10821 composeCodeableConcept(t, "MedicinalProduct", "combinedPharmaceuticalDoseForm", element.getCombinedPharmaceuticalDoseForm(), -1); 10822 if (element.hasLegalStatusOfSupply()) 10823 composeCodeableConcept(t, "MedicinalProduct", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1); 10824 if (element.hasAdditionalMonitoringIndicator()) 10825 composeCodeableConcept(t, "MedicinalProduct", "additionalMonitoringIndicator", element.getAdditionalMonitoringIndicator(), -1); 10826 for (int i = 0; i < element.getSpecialMeasures().size(); i++) 10827 composeString(t, "MedicinalProduct", "specialMeasures", element.getSpecialMeasures().get(i), i); 10828 if (element.hasPaediatricUseIndicator()) 10829 composeCodeableConcept(t, "MedicinalProduct", "paediatricUseIndicator", element.getPaediatricUseIndicator(), -1); 10830 for (int i = 0; i < element.getProductClassification().size(); i++) 10831 composeCodeableConcept(t, "MedicinalProduct", "productClassification", element.getProductClassification().get(i), i); 10832 for (int i = 0; i < element.getMarketingStatus().size(); i++) 10833 composeMarketingStatus(t, "MedicinalProduct", "marketingStatus", element.getMarketingStatus().get(i), i); 10834 for (int i = 0; i < element.getPharmaceuticalProduct().size(); i++) 10835 composeReference(t, "MedicinalProduct", "pharmaceuticalProduct", element.getPharmaceuticalProduct().get(i), i); 10836 for (int i = 0; i < element.getPackagedMedicinalProduct().size(); i++) 10837 composeReference(t, "MedicinalProduct", "packagedMedicinalProduct", element.getPackagedMedicinalProduct().get(i), i); 10838 for (int i = 0; i < element.getAttachedDocument().size(); i++) 10839 composeReference(t, "MedicinalProduct", "attachedDocument", element.getAttachedDocument().get(i), i); 10840 for (int i = 0; i < element.getMasterFile().size(); i++) 10841 composeReference(t, "MedicinalProduct", "masterFile", element.getMasterFile().get(i), i); 10842 for (int i = 0; i < element.getContact().size(); i++) 10843 composeReference(t, "MedicinalProduct", "contact", element.getContact().get(i), i); 10844 for (int i = 0; i < element.getClinicalTrial().size(); i++) 10845 composeReference(t, "MedicinalProduct", "clinicalTrial", element.getClinicalTrial().get(i), i); 10846 for (int i = 0; i < element.getName().size(); i++) 10847 composeMedicinalProductMedicinalProductNameComponent(t, "MedicinalProduct", "name", element.getName().get(i), i); 10848 for (int i = 0; i < element.getCrossReference().size(); i++) 10849 composeIdentifier(t, "MedicinalProduct", "crossReference", element.getCrossReference().get(i), i); 10850 for (int i = 0; i < element.getManufacturingBusinessOperation().size(); i++) 10851 composeMedicinalProductMedicinalProductManufacturingBusinessOperationComponent(t, "MedicinalProduct", "manufacturingBusinessOperation", element.getManufacturingBusinessOperation().get(i), i); 10852 for (int i = 0; i < element.getSpecialDesignation().size(); i++) 10853 composeMedicinalProductMedicinalProductSpecialDesignationComponent(t, "MedicinalProduct", "specialDesignation", element.getSpecialDesignation().get(i), i); 10854 } 10855 10856 protected void composeMedicinalProductMedicinalProductNameComponent(Complex parent, String parentType, String name, MedicinalProduct.MedicinalProductNameComponent element, int index) { 10857 if (element == null) 10858 return; 10859 Complex t; 10860 if (Utilities.noString(parentType)) 10861 t = parent; 10862 else { 10863 t = parent.predicate("fhir:"+parentType+'.'+name); 10864 } 10865 composeBackboneElement(t, "name", name, element, index); 10866 if (element.hasProductNameElement()) 10867 composeString(t, "MedicinalProduct", "productName", element.getProductNameElement(), -1); 10868 for (int i = 0; i < element.getNamePart().size(); i++) 10869 composeMedicinalProductMedicinalProductNameNamePartComponent(t, "MedicinalProduct", "namePart", element.getNamePart().get(i), i); 10870 for (int i = 0; i < element.getCountryLanguage().size(); i++) 10871 composeMedicinalProductMedicinalProductNameCountryLanguageComponent(t, "MedicinalProduct", "countryLanguage", element.getCountryLanguage().get(i), i); 10872 } 10873 10874 protected void composeMedicinalProductMedicinalProductNameNamePartComponent(Complex parent, String parentType, String name, MedicinalProduct.MedicinalProductNameNamePartComponent element, int index) { 10875 if (element == null) 10876 return; 10877 Complex t; 10878 if (Utilities.noString(parentType)) 10879 t = parent; 10880 else { 10881 t = parent.predicate("fhir:"+parentType+'.'+name); 10882 } 10883 composeBackboneElement(t, "namePart", name, element, index); 10884 if (element.hasPartElement()) 10885 composeString(t, "MedicinalProduct", "part", element.getPartElement(), -1); 10886 if (element.hasType()) 10887 composeCoding(t, "MedicinalProduct", "type", element.getType(), -1); 10888 } 10889 10890 protected void composeMedicinalProductMedicinalProductNameCountryLanguageComponent(Complex parent, String parentType, String name, MedicinalProduct.MedicinalProductNameCountryLanguageComponent element, int index) { 10891 if (element == null) 10892 return; 10893 Complex t; 10894 if (Utilities.noString(parentType)) 10895 t = parent; 10896 else { 10897 t = parent.predicate("fhir:"+parentType+'.'+name); 10898 } 10899 composeBackboneElement(t, "countryLanguage", name, element, index); 10900 if (element.hasCountry()) 10901 composeCodeableConcept(t, "MedicinalProduct", "country", element.getCountry(), -1); 10902 if (element.hasJurisdiction()) 10903 composeCodeableConcept(t, "MedicinalProduct", "jurisdiction", element.getJurisdiction(), -1); 10904 if (element.hasLanguage()) 10905 composeCodeableConcept(t, "MedicinalProduct", "language", element.getLanguage(), -1); 10906 } 10907 10908 protected void composeMedicinalProductMedicinalProductManufacturingBusinessOperationComponent(Complex parent, String parentType, String name, MedicinalProduct.MedicinalProductManufacturingBusinessOperationComponent element, int index) { 10909 if (element == null) 10910 return; 10911 Complex t; 10912 if (Utilities.noString(parentType)) 10913 t = parent; 10914 else { 10915 t = parent.predicate("fhir:"+parentType+'.'+name); 10916 } 10917 composeBackboneElement(t, "manufacturingBusinessOperation", name, element, index); 10918 if (element.hasOperationType()) 10919 composeCodeableConcept(t, "MedicinalProduct", "operationType", element.getOperationType(), -1); 10920 if (element.hasAuthorisationReferenceNumber()) 10921 composeIdentifier(t, "MedicinalProduct", "authorisationReferenceNumber", element.getAuthorisationReferenceNumber(), -1); 10922 if (element.hasEffectiveDateElement()) 10923 composeDateTime(t, "MedicinalProduct", "effectiveDate", element.getEffectiveDateElement(), -1); 10924 if (element.hasConfidentialityIndicator()) 10925 composeCodeableConcept(t, "MedicinalProduct", "confidentialityIndicator", element.getConfidentialityIndicator(), -1); 10926 for (int i = 0; i < element.getManufacturer().size(); i++) 10927 composeReference(t, "MedicinalProduct", "manufacturer", element.getManufacturer().get(i), i); 10928 if (element.hasRegulator()) 10929 composeReference(t, "MedicinalProduct", "regulator", element.getRegulator(), -1); 10930 } 10931 10932 protected void composeMedicinalProductMedicinalProductSpecialDesignationComponent(Complex parent, String parentType, String name, MedicinalProduct.MedicinalProductSpecialDesignationComponent element, int index) { 10933 if (element == null) 10934 return; 10935 Complex t; 10936 if (Utilities.noString(parentType)) 10937 t = parent; 10938 else { 10939 t = parent.predicate("fhir:"+parentType+'.'+name); 10940 } 10941 composeBackboneElement(t, "specialDesignation", name, element, index); 10942 for (int i = 0; i < element.getIdentifier().size(); i++) 10943 composeIdentifier(t, "MedicinalProduct", "identifier", element.getIdentifier().get(i), i); 10944 if (element.hasType()) 10945 composeCodeableConcept(t, "MedicinalProduct", "type", element.getType(), -1); 10946 if (element.hasIntendedUse()) 10947 composeCodeableConcept(t, "MedicinalProduct", "intendedUse", element.getIntendedUse(), -1); 10948 if (element.hasIndication()) 10949 composeType(t, "MedicinalProduct", "indication", element.getIndication(), -1); 10950 if (element.hasStatus()) 10951 composeCodeableConcept(t, "MedicinalProduct", "status", element.getStatus(), -1); 10952 if (element.hasDateElement()) 10953 composeDateTime(t, "MedicinalProduct", "date", element.getDateElement(), -1); 10954 if (element.hasSpecies()) 10955 composeCodeableConcept(t, "MedicinalProduct", "species", element.getSpecies(), -1); 10956 } 10957 10958 protected void composeMedicinalProductAuthorization(Complex parent, String parentType, String name, MedicinalProductAuthorization element, int index) { 10959 if (element == null) 10960 return; 10961 Complex t; 10962 if (Utilities.noString(parentType)) 10963 t = parent; 10964 else { 10965 t = parent.predicate("fhir:"+parentType+'.'+name); 10966 } 10967 composeDomainResource(t, "MedicinalProductAuthorization", name, element, index); 10968 for (int i = 0; i < element.getIdentifier().size(); i++) 10969 composeIdentifier(t, "MedicinalProductAuthorization", "identifier", element.getIdentifier().get(i), i); 10970 if (element.hasSubject()) 10971 composeReference(t, "MedicinalProductAuthorization", "subject", element.getSubject(), -1); 10972 for (int i = 0; i < element.getCountry().size(); i++) 10973 composeCodeableConcept(t, "MedicinalProductAuthorization", "country", element.getCountry().get(i), i); 10974 for (int i = 0; i < element.getJurisdiction().size(); i++) 10975 composeCodeableConcept(t, "MedicinalProductAuthorization", "jurisdiction", element.getJurisdiction().get(i), i); 10976 if (element.hasStatus()) 10977 composeCodeableConcept(t, "MedicinalProductAuthorization", "status", element.getStatus(), -1); 10978 if (element.hasStatusDateElement()) 10979 composeDateTime(t, "MedicinalProductAuthorization", "statusDate", element.getStatusDateElement(), -1); 10980 if (element.hasRestoreDateElement()) 10981 composeDateTime(t, "MedicinalProductAuthorization", "restoreDate", element.getRestoreDateElement(), -1); 10982 if (element.hasValidityPeriod()) 10983 composePeriod(t, "MedicinalProductAuthorization", "validityPeriod", element.getValidityPeriod(), -1); 10984 if (element.hasDataExclusivityPeriod()) 10985 composePeriod(t, "MedicinalProductAuthorization", "dataExclusivityPeriod", element.getDataExclusivityPeriod(), -1); 10986 if (element.hasDateOfFirstAuthorizationElement()) 10987 composeDateTime(t, "MedicinalProductAuthorization", "dateOfFirstAuthorization", element.getDateOfFirstAuthorizationElement(), -1); 10988 if (element.hasInternationalBirthDateElement()) 10989 composeDateTime(t, "MedicinalProductAuthorization", "internationalBirthDate", element.getInternationalBirthDateElement(), -1); 10990 if (element.hasLegalBasis()) 10991 composeCodeableConcept(t, "MedicinalProductAuthorization", "legalBasis", element.getLegalBasis(), -1); 10992 for (int i = 0; i < element.getJurisdictionalAuthorization().size(); i++) 10993 composeMedicinalProductAuthorizationMedicinalProductAuthorizationJurisdictionalAuthorizationComponent(t, "MedicinalProductAuthorization", "jurisdictionalAuthorization", element.getJurisdictionalAuthorization().get(i), i); 10994 if (element.hasHolder()) 10995 composeReference(t, "MedicinalProductAuthorization", "holder", element.getHolder(), -1); 10996 if (element.hasRegulator()) 10997 composeReference(t, "MedicinalProductAuthorization", "regulator", element.getRegulator(), -1); 10998 if (element.hasProcedure()) 10999 composeMedicinalProductAuthorizationMedicinalProductAuthorizationProcedureComponent(t, "MedicinalProductAuthorization", "procedure", element.getProcedure(), -1); 11000 } 11001 11002 protected void composeMedicinalProductAuthorizationMedicinalProductAuthorizationJurisdictionalAuthorizationComponent(Complex parent, String parentType, String name, MedicinalProductAuthorization.MedicinalProductAuthorizationJurisdictionalAuthorizationComponent element, int index) { 11003 if (element == null) 11004 return; 11005 Complex t; 11006 if (Utilities.noString(parentType)) 11007 t = parent; 11008 else { 11009 t = parent.predicate("fhir:"+parentType+'.'+name); 11010 } 11011 composeBackboneElement(t, "jurisdictionalAuthorization", name, element, index); 11012 for (int i = 0; i < element.getIdentifier().size(); i++) 11013 composeIdentifier(t, "MedicinalProductAuthorization", "identifier", element.getIdentifier().get(i), i); 11014 if (element.hasCountry()) 11015 composeCodeableConcept(t, "MedicinalProductAuthorization", "country", element.getCountry(), -1); 11016 for (int i = 0; i < element.getJurisdiction().size(); i++) 11017 composeCodeableConcept(t, "MedicinalProductAuthorization", "jurisdiction", element.getJurisdiction().get(i), i); 11018 if (element.hasLegalStatusOfSupply()) 11019 composeCodeableConcept(t, "MedicinalProductAuthorization", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1); 11020 if (element.hasValidityPeriod()) 11021 composePeriod(t, "MedicinalProductAuthorization", "validityPeriod", element.getValidityPeriod(), -1); 11022 } 11023 11024 protected void composeMedicinalProductAuthorizationMedicinalProductAuthorizationProcedureComponent(Complex parent, String parentType, String name, MedicinalProductAuthorization.MedicinalProductAuthorizationProcedureComponent element, int index) { 11025 if (element == null) 11026 return; 11027 Complex t; 11028 if (Utilities.noString(parentType)) 11029 t = parent; 11030 else { 11031 t = parent.predicate("fhir:"+parentType+'.'+name); 11032 } 11033 composeBackboneElement(t, "procedure", name, element, index); 11034 if (element.hasIdentifier()) 11035 composeIdentifier(t, "MedicinalProductAuthorization", "identifier", element.getIdentifier(), -1); 11036 if (element.hasType()) 11037 composeCodeableConcept(t, "MedicinalProductAuthorization", "type", element.getType(), -1); 11038 if (element.hasDate()) 11039 composeType(t, "MedicinalProductAuthorization", "date", element.getDate(), -1); 11040 for (int i = 0; i < element.getApplication().size(); i++) 11041 composeMedicinalProductAuthorizationMedicinalProductAuthorizationProcedureComponent(t, "MedicinalProductAuthorization", "application", element.getApplication().get(i), i); 11042 } 11043 11044 protected void composeMedicinalProductContraindication(Complex parent, String parentType, String name, MedicinalProductContraindication element, int index) { 11045 if (element == null) 11046 return; 11047 Complex t; 11048 if (Utilities.noString(parentType)) 11049 t = parent; 11050 else { 11051 t = parent.predicate("fhir:"+parentType+'.'+name); 11052 } 11053 composeDomainResource(t, "MedicinalProductContraindication", name, element, index); 11054 for (int i = 0; i < element.getSubject().size(); i++) 11055 composeReference(t, "MedicinalProductContraindication", "subject", element.getSubject().get(i), i); 11056 if (element.hasDisease()) 11057 composeCodeableConcept(t, "MedicinalProductContraindication", "disease", element.getDisease(), -1); 11058 if (element.hasDiseaseStatus()) 11059 composeCodeableConcept(t, "MedicinalProductContraindication", "diseaseStatus", element.getDiseaseStatus(), -1); 11060 for (int i = 0; i < element.getComorbidity().size(); i++) 11061 composeCodeableConcept(t, "MedicinalProductContraindication", "comorbidity", element.getComorbidity().get(i), i); 11062 for (int i = 0; i < element.getTherapeuticIndication().size(); i++) 11063 composeReference(t, "MedicinalProductContraindication", "therapeuticIndication", element.getTherapeuticIndication().get(i), i); 11064 for (int i = 0; i < element.getOtherTherapy().size(); i++) 11065 composeMedicinalProductContraindicationMedicinalProductContraindicationOtherTherapyComponent(t, "MedicinalProductContraindication", "otherTherapy", element.getOtherTherapy().get(i), i); 11066 for (int i = 0; i < element.getPopulation().size(); i++) 11067 composePopulation(t, "MedicinalProductContraindication", "population", element.getPopulation().get(i), i); 11068 } 11069 11070 protected void composeMedicinalProductContraindicationMedicinalProductContraindicationOtherTherapyComponent(Complex parent, String parentType, String name, MedicinalProductContraindication.MedicinalProductContraindicationOtherTherapyComponent element, int index) { 11071 if (element == null) 11072 return; 11073 Complex t; 11074 if (Utilities.noString(parentType)) 11075 t = parent; 11076 else { 11077 t = parent.predicate("fhir:"+parentType+'.'+name); 11078 } 11079 composeBackboneElement(t, "otherTherapy", name, element, index); 11080 if (element.hasTherapyRelationshipType()) 11081 composeCodeableConcept(t, "MedicinalProductContraindication", "therapyRelationshipType", element.getTherapyRelationshipType(), -1); 11082 if (element.hasMedication()) 11083 composeType(t, "MedicinalProductContraindication", "medication", element.getMedication(), -1); 11084 } 11085 11086 protected void composeMedicinalProductIndication(Complex parent, String parentType, String name, MedicinalProductIndication element, int index) { 11087 if (element == null) 11088 return; 11089 Complex t; 11090 if (Utilities.noString(parentType)) 11091 t = parent; 11092 else { 11093 t = parent.predicate("fhir:"+parentType+'.'+name); 11094 } 11095 composeDomainResource(t, "MedicinalProductIndication", name, element, index); 11096 for (int i = 0; i < element.getSubject().size(); i++) 11097 composeReference(t, "MedicinalProductIndication", "subject", element.getSubject().get(i), i); 11098 if (element.hasDiseaseSymptomProcedure()) 11099 composeCodeableConcept(t, "MedicinalProductIndication", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1); 11100 if (element.hasDiseaseStatus()) 11101 composeCodeableConcept(t, "MedicinalProductIndication", "diseaseStatus", element.getDiseaseStatus(), -1); 11102 for (int i = 0; i < element.getComorbidity().size(); i++) 11103 composeCodeableConcept(t, "MedicinalProductIndication", "comorbidity", element.getComorbidity().get(i), i); 11104 if (element.hasIntendedEffect()) 11105 composeCodeableConcept(t, "MedicinalProductIndication", "intendedEffect", element.getIntendedEffect(), -1); 11106 if (element.hasDuration()) 11107 composeQuantity(t, "MedicinalProductIndication", "duration", element.getDuration(), -1); 11108 for (int i = 0; i < element.getOtherTherapy().size(); i++) 11109 composeMedicinalProductIndicationMedicinalProductIndicationOtherTherapyComponent(t, "MedicinalProductIndication", "otherTherapy", element.getOtherTherapy().get(i), i); 11110 for (int i = 0; i < element.getUndesirableEffect().size(); i++) 11111 composeReference(t, "MedicinalProductIndication", "undesirableEffect", element.getUndesirableEffect().get(i), i); 11112 for (int i = 0; i < element.getPopulation().size(); i++) 11113 composePopulation(t, "MedicinalProductIndication", "population", element.getPopulation().get(i), i); 11114 } 11115 11116 protected void composeMedicinalProductIndicationMedicinalProductIndicationOtherTherapyComponent(Complex parent, String parentType, String name, MedicinalProductIndication.MedicinalProductIndicationOtherTherapyComponent element, int index) { 11117 if (element == null) 11118 return; 11119 Complex t; 11120 if (Utilities.noString(parentType)) 11121 t = parent; 11122 else { 11123 t = parent.predicate("fhir:"+parentType+'.'+name); 11124 } 11125 composeBackboneElement(t, "otherTherapy", name, element, index); 11126 if (element.hasTherapyRelationshipType()) 11127 composeCodeableConcept(t, "MedicinalProductIndication", "therapyRelationshipType", element.getTherapyRelationshipType(), -1); 11128 if (element.hasMedication()) 11129 composeType(t, "MedicinalProductIndication", "medication", element.getMedication(), -1); 11130 } 11131 11132 protected void composeMedicinalProductIngredient(Complex parent, String parentType, String name, MedicinalProductIngredient element, int index) { 11133 if (element == null) 11134 return; 11135 Complex t; 11136 if (Utilities.noString(parentType)) 11137 t = parent; 11138 else { 11139 t = parent.predicate("fhir:"+parentType+'.'+name); 11140 } 11141 composeDomainResource(t, "MedicinalProductIngredient", name, element, index); 11142 if (element.hasIdentifier()) 11143 composeIdentifier(t, "MedicinalProductIngredient", "identifier", element.getIdentifier(), -1); 11144 if (element.hasRole()) 11145 composeCodeableConcept(t, "MedicinalProductIngredient", "role", element.getRole(), -1); 11146 if (element.hasAllergenicIndicatorElement()) 11147 composeBoolean(t, "MedicinalProductIngredient", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1); 11148 for (int i = 0; i < element.getManufacturer().size(); i++) 11149 composeReference(t, "MedicinalProductIngredient", "manufacturer", element.getManufacturer().get(i), i); 11150 for (int i = 0; i < element.getSpecifiedSubstance().size(); i++) 11151 composeMedicinalProductIngredientMedicinalProductIngredientSpecifiedSubstanceComponent(t, "MedicinalProductIngredient", "specifiedSubstance", element.getSpecifiedSubstance().get(i), i); 11152 if (element.hasSubstance()) 11153 composeMedicinalProductIngredientMedicinalProductIngredientSubstanceComponent(t, "MedicinalProductIngredient", "substance", element.getSubstance(), -1); 11154 } 11155 11156 protected void composeMedicinalProductIngredientMedicinalProductIngredientSpecifiedSubstanceComponent(Complex parent, String parentType, String name, MedicinalProductIngredient.MedicinalProductIngredientSpecifiedSubstanceComponent element, int index) { 11157 if (element == null) 11158 return; 11159 Complex t; 11160 if (Utilities.noString(parentType)) 11161 t = parent; 11162 else { 11163 t = parent.predicate("fhir:"+parentType+'.'+name); 11164 } 11165 composeBackboneElement(t, "specifiedSubstance", name, element, index); 11166 if (element.hasCode()) 11167 composeCodeableConcept(t, "MedicinalProductIngredient", "code", element.getCode(), -1); 11168 if (element.hasGroup()) 11169 composeCodeableConcept(t, "MedicinalProductIngredient", "group", element.getGroup(), -1); 11170 if (element.hasConfidentiality()) 11171 composeCodeableConcept(t, "MedicinalProductIngredient", "confidentiality", element.getConfidentiality(), -1); 11172 for (int i = 0; i < element.getStrength().size(); i++) 11173 composeMedicinalProductIngredientMedicinalProductIngredientSpecifiedSubstanceStrengthComponent(t, "MedicinalProductIngredient", "strength", element.getStrength().get(i), i); 11174 } 11175 11176 protected void composeMedicinalProductIngredientMedicinalProductIngredientSpecifiedSubstanceStrengthComponent(Complex parent, String parentType, String name, MedicinalProductIngredient.MedicinalProductIngredientSpecifiedSubstanceStrengthComponent element, int index) { 11177 if (element == null) 11178 return; 11179 Complex t; 11180 if (Utilities.noString(parentType)) 11181 t = parent; 11182 else { 11183 t = parent.predicate("fhir:"+parentType+'.'+name); 11184 } 11185 composeBackboneElement(t, "strength", name, element, index); 11186 if (element.hasPresentation()) 11187 composeRatio(t, "MedicinalProductIngredient", "presentation", element.getPresentation(), -1); 11188 if (element.hasPresentationLowLimit()) 11189 composeRatio(t, "MedicinalProductIngredient", "presentationLowLimit", element.getPresentationLowLimit(), -1); 11190 if (element.hasConcentration()) 11191 composeRatio(t, "MedicinalProductIngredient", "concentration", element.getConcentration(), -1); 11192 if (element.hasConcentrationLowLimit()) 11193 composeRatio(t, "MedicinalProductIngredient", "concentrationLowLimit", element.getConcentrationLowLimit(), -1); 11194 if (element.hasMeasurementPointElement()) 11195 composeString(t, "MedicinalProductIngredient", "measurementPoint", element.getMeasurementPointElement(), -1); 11196 for (int i = 0; i < element.getCountry().size(); i++) 11197 composeCodeableConcept(t, "MedicinalProductIngredient", "country", element.getCountry().get(i), i); 11198 for (int i = 0; i < element.getReferenceStrength().size(); i++) 11199 composeMedicinalProductIngredientMedicinalProductIngredientSpecifiedSubstanceStrengthReferenceStrengthComponent(t, "MedicinalProductIngredient", "referenceStrength", element.getReferenceStrength().get(i), i); 11200 } 11201 11202 protected void composeMedicinalProductIngredientMedicinalProductIngredientSpecifiedSubstanceStrengthReferenceStrengthComponent(Complex parent, String parentType, String name, MedicinalProductIngredient.MedicinalProductIngredientSpecifiedSubstanceStrengthReferenceStrengthComponent element, int index) { 11203 if (element == null) 11204 return; 11205 Complex t; 11206 if (Utilities.noString(parentType)) 11207 t = parent; 11208 else { 11209 t = parent.predicate("fhir:"+parentType+'.'+name); 11210 } 11211 composeBackboneElement(t, "referenceStrength", name, element, index); 11212 if (element.hasSubstance()) 11213 composeCodeableConcept(t, "MedicinalProductIngredient", "substance", element.getSubstance(), -1); 11214 if (element.hasStrength()) 11215 composeRatio(t, "MedicinalProductIngredient", "strength", element.getStrength(), -1); 11216 if (element.hasStrengthLowLimit()) 11217 composeRatio(t, "MedicinalProductIngredient", "strengthLowLimit", element.getStrengthLowLimit(), -1); 11218 if (element.hasMeasurementPointElement()) 11219 composeString(t, "MedicinalProductIngredient", "measurementPoint", element.getMeasurementPointElement(), -1); 11220 for (int i = 0; i < element.getCountry().size(); i++) 11221 composeCodeableConcept(t, "MedicinalProductIngredient", "country", element.getCountry().get(i), i); 11222 } 11223 11224 protected void composeMedicinalProductIngredientMedicinalProductIngredientSubstanceComponent(Complex parent, String parentType, String name, MedicinalProductIngredient.MedicinalProductIngredientSubstanceComponent element, int index) { 11225 if (element == null) 11226 return; 11227 Complex t; 11228 if (Utilities.noString(parentType)) 11229 t = parent; 11230 else { 11231 t = parent.predicate("fhir:"+parentType+'.'+name); 11232 } 11233 composeBackboneElement(t, "substance", name, element, index); 11234 if (element.hasCode()) 11235 composeCodeableConcept(t, "MedicinalProductIngredient", "code", element.getCode(), -1); 11236 for (int i = 0; i < element.getStrength().size(); i++) 11237 composeMedicinalProductIngredientMedicinalProductIngredientSpecifiedSubstanceStrengthComponent(t, "MedicinalProductIngredient", "strength", element.getStrength().get(i), i); 11238 } 11239 11240 protected void composeMedicinalProductInteraction(Complex parent, String parentType, String name, MedicinalProductInteraction element, int index) { 11241 if (element == null) 11242 return; 11243 Complex t; 11244 if (Utilities.noString(parentType)) 11245 t = parent; 11246 else { 11247 t = parent.predicate("fhir:"+parentType+'.'+name); 11248 } 11249 composeDomainResource(t, "MedicinalProductInteraction", name, element, index); 11250 for (int i = 0; i < element.getSubject().size(); i++) 11251 composeReference(t, "MedicinalProductInteraction", "subject", element.getSubject().get(i), i); 11252 if (element.hasDescriptionElement()) 11253 composeString(t, "MedicinalProductInteraction", "description", element.getDescriptionElement(), -1); 11254 for (int i = 0; i < element.getInteractant().size(); i++) 11255 composeMedicinalProductInteractionMedicinalProductInteractionInteractantComponent(t, "MedicinalProductInteraction", "interactant", element.getInteractant().get(i), i); 11256 if (element.hasType()) 11257 composeCodeableConcept(t, "MedicinalProductInteraction", "type", element.getType(), -1); 11258 if (element.hasEffect()) 11259 composeCodeableConcept(t, "MedicinalProductInteraction", "effect", element.getEffect(), -1); 11260 if (element.hasIncidence()) 11261 composeCodeableConcept(t, "MedicinalProductInteraction", "incidence", element.getIncidence(), -1); 11262 if (element.hasManagement()) 11263 composeCodeableConcept(t, "MedicinalProductInteraction", "management", element.getManagement(), -1); 11264 } 11265 11266 protected void composeMedicinalProductInteractionMedicinalProductInteractionInteractantComponent(Complex parent, String parentType, String name, MedicinalProductInteraction.MedicinalProductInteractionInteractantComponent element, int index) { 11267 if (element == null) 11268 return; 11269 Complex t; 11270 if (Utilities.noString(parentType)) 11271 t = parent; 11272 else { 11273 t = parent.predicate("fhir:"+parentType+'.'+name); 11274 } 11275 composeBackboneElement(t, "interactant", name, element, index); 11276 if (element.hasItem()) 11277 composeType(t, "MedicinalProductInteraction", "item", element.getItem(), -1); 11278 } 11279 11280 protected void composeMedicinalProductManufactured(Complex parent, String parentType, String name, MedicinalProductManufactured element, int index) { 11281 if (element == null) 11282 return; 11283 Complex t; 11284 if (Utilities.noString(parentType)) 11285 t = parent; 11286 else { 11287 t = parent.predicate("fhir:"+parentType+'.'+name); 11288 } 11289 composeDomainResource(t, "MedicinalProductManufactured", name, element, index); 11290 if (element.hasManufacturedDoseForm()) 11291 composeCodeableConcept(t, "MedicinalProductManufactured", "manufacturedDoseForm", element.getManufacturedDoseForm(), -1); 11292 if (element.hasUnitOfPresentation()) 11293 composeCodeableConcept(t, "MedicinalProductManufactured", "unitOfPresentation", element.getUnitOfPresentation(), -1); 11294 if (element.hasQuantity()) 11295 composeQuantity(t, "MedicinalProductManufactured", "quantity", element.getQuantity(), -1); 11296 for (int i = 0; i < element.getManufacturer().size(); i++) 11297 composeReference(t, "MedicinalProductManufactured", "manufacturer", element.getManufacturer().get(i), i); 11298 for (int i = 0; i < element.getIngredient().size(); i++) 11299 composeReference(t, "MedicinalProductManufactured", "ingredient", element.getIngredient().get(i), i); 11300 if (element.hasPhysicalCharacteristics()) 11301 composeProdCharacteristic(t, "MedicinalProductManufactured", "physicalCharacteristics", element.getPhysicalCharacteristics(), -1); 11302 for (int i = 0; i < element.getOtherCharacteristics().size(); i++) 11303 composeCodeableConcept(t, "MedicinalProductManufactured", "otherCharacteristics", element.getOtherCharacteristics().get(i), i); 11304 } 11305 11306 protected void composeMedicinalProductPackaged(Complex parent, String parentType, String name, MedicinalProductPackaged element, int index) { 11307 if (element == null) 11308 return; 11309 Complex t; 11310 if (Utilities.noString(parentType)) 11311 t = parent; 11312 else { 11313 t = parent.predicate("fhir:"+parentType+'.'+name); 11314 } 11315 composeDomainResource(t, "MedicinalProductPackaged", name, element, index); 11316 for (int i = 0; i < element.getIdentifier().size(); i++) 11317 composeIdentifier(t, "MedicinalProductPackaged", "identifier", element.getIdentifier().get(i), i); 11318 for (int i = 0; i < element.getSubject().size(); i++) 11319 composeReference(t, "MedicinalProductPackaged", "subject", element.getSubject().get(i), i); 11320 if (element.hasDescriptionElement()) 11321 composeString(t, "MedicinalProductPackaged", "description", element.getDescriptionElement(), -1); 11322 if (element.hasLegalStatusOfSupply()) 11323 composeCodeableConcept(t, "MedicinalProductPackaged", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1); 11324 for (int i = 0; i < element.getMarketingStatus().size(); i++) 11325 composeMarketingStatus(t, "MedicinalProductPackaged", "marketingStatus", element.getMarketingStatus().get(i), i); 11326 if (element.hasMarketingAuthorization()) 11327 composeReference(t, "MedicinalProductPackaged", "marketingAuthorization", element.getMarketingAuthorization(), -1); 11328 for (int i = 0; i < element.getManufacturer().size(); i++) 11329 composeReference(t, "MedicinalProductPackaged", "manufacturer", element.getManufacturer().get(i), i); 11330 for (int i = 0; i < element.getBatchIdentifier().size(); i++) 11331 composeMedicinalProductPackagedMedicinalProductPackagedBatchIdentifierComponent(t, "MedicinalProductPackaged", "batchIdentifier", element.getBatchIdentifier().get(i), i); 11332 for (int i = 0; i < element.getPackageItem().size(); i++) 11333 composeMedicinalProductPackagedMedicinalProductPackagedPackageItemComponent(t, "MedicinalProductPackaged", "packageItem", element.getPackageItem().get(i), i); 11334 } 11335 11336 protected void composeMedicinalProductPackagedMedicinalProductPackagedBatchIdentifierComponent(Complex parent, String parentType, String name, MedicinalProductPackaged.MedicinalProductPackagedBatchIdentifierComponent element, int index) { 11337 if (element == null) 11338 return; 11339 Complex t; 11340 if (Utilities.noString(parentType)) 11341 t = parent; 11342 else { 11343 t = parent.predicate("fhir:"+parentType+'.'+name); 11344 } 11345 composeBackboneElement(t, "batchIdentifier", name, element, index); 11346 if (element.hasOuterPackaging()) 11347 composeIdentifier(t, "MedicinalProductPackaged", "outerPackaging", element.getOuterPackaging(), -1); 11348 if (element.hasImmediatePackaging()) 11349 composeIdentifier(t, "MedicinalProductPackaged", "immediatePackaging", element.getImmediatePackaging(), -1); 11350 } 11351 11352 protected void composeMedicinalProductPackagedMedicinalProductPackagedPackageItemComponent(Complex parent, String parentType, String name, MedicinalProductPackaged.MedicinalProductPackagedPackageItemComponent element, int index) { 11353 if (element == null) 11354 return; 11355 Complex t; 11356 if (Utilities.noString(parentType)) 11357 t = parent; 11358 else { 11359 t = parent.predicate("fhir:"+parentType+'.'+name); 11360 } 11361 composeBackboneElement(t, "packageItem", name, element, index); 11362 for (int i = 0; i < element.getIdentifier().size(); i++) 11363 composeIdentifier(t, "MedicinalProductPackaged", "identifier", element.getIdentifier().get(i), i); 11364 if (element.hasType()) 11365 composeCodeableConcept(t, "MedicinalProductPackaged", "type", element.getType(), -1); 11366 if (element.hasQuantity()) 11367 composeQuantity(t, "MedicinalProductPackaged", "quantity", element.getQuantity(), -1); 11368 for (int i = 0; i < element.getMaterial().size(); i++) 11369 composeCodeableConcept(t, "MedicinalProductPackaged", "material", element.getMaterial().get(i), i); 11370 for (int i = 0; i < element.getAlternateMaterial().size(); i++) 11371 composeCodeableConcept(t, "MedicinalProductPackaged", "alternateMaterial", element.getAlternateMaterial().get(i), i); 11372 for (int i = 0; i < element.getDevice().size(); i++) 11373 composeReference(t, "MedicinalProductPackaged", "device", element.getDevice().get(i), i); 11374 for (int i = 0; i < element.getManufacturedItem().size(); i++) 11375 composeReference(t, "MedicinalProductPackaged", "manufacturedItem", element.getManufacturedItem().get(i), i); 11376 for (int i = 0; i < element.getPackageItem().size(); i++) 11377 composeMedicinalProductPackagedMedicinalProductPackagedPackageItemComponent(t, "MedicinalProductPackaged", "packageItem", element.getPackageItem().get(i), i); 11378 if (element.hasPhysicalCharacteristics()) 11379 composeProdCharacteristic(t, "MedicinalProductPackaged", "physicalCharacteristics", element.getPhysicalCharacteristics(), -1); 11380 for (int i = 0; i < element.getOtherCharacteristics().size(); i++) 11381 composeCodeableConcept(t, "MedicinalProductPackaged", "otherCharacteristics", element.getOtherCharacteristics().get(i), i); 11382 for (int i = 0; i < element.getShelfLifeStorage().size(); i++) 11383 composeProductShelfLife(t, "MedicinalProductPackaged", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i); 11384 for (int i = 0; i < element.getManufacturer().size(); i++) 11385 composeReference(t, "MedicinalProductPackaged", "manufacturer", element.getManufacturer().get(i), i); 11386 } 11387 11388 protected void composeMedicinalProductPharmaceutical(Complex parent, String parentType, String name, MedicinalProductPharmaceutical element, int index) { 11389 if (element == null) 11390 return; 11391 Complex t; 11392 if (Utilities.noString(parentType)) 11393 t = parent; 11394 else { 11395 t = parent.predicate("fhir:"+parentType+'.'+name); 11396 } 11397 composeDomainResource(t, "MedicinalProductPharmaceutical", name, element, index); 11398 for (int i = 0; i < element.getIdentifier().size(); i++) 11399 composeIdentifier(t, "MedicinalProductPharmaceutical", "identifier", element.getIdentifier().get(i), i); 11400 if (element.hasAdministrableDoseForm()) 11401 composeCodeableConcept(t, "MedicinalProductPharmaceutical", "administrableDoseForm", element.getAdministrableDoseForm(), -1); 11402 if (element.hasUnitOfPresentation()) 11403 composeCodeableConcept(t, "MedicinalProductPharmaceutical", "unitOfPresentation", element.getUnitOfPresentation(), -1); 11404 for (int i = 0; i < element.getIngredient().size(); i++) 11405 composeReference(t, "MedicinalProductPharmaceutical", "ingredient", element.getIngredient().get(i), i); 11406 for (int i = 0; i < element.getDevice().size(); i++) 11407 composeReference(t, "MedicinalProductPharmaceutical", "device", element.getDevice().get(i), i); 11408 for (int i = 0; i < element.getCharacteristics().size(); i++) 11409 composeMedicinalProductPharmaceuticalMedicinalProductPharmaceuticalCharacteristicsComponent(t, "MedicinalProductPharmaceutical", "characteristics", element.getCharacteristics().get(i), i); 11410 for (int i = 0; i < element.getRouteOfAdministration().size(); i++) 11411 composeMedicinalProductPharmaceuticalMedicinalProductPharmaceuticalRouteOfAdministrationComponent(t, "MedicinalProductPharmaceutical", "routeOfAdministration", element.getRouteOfAdministration().get(i), i); 11412 } 11413 11414 protected void composeMedicinalProductPharmaceuticalMedicinalProductPharmaceuticalCharacteristicsComponent(Complex parent, String parentType, String name, MedicinalProductPharmaceutical.MedicinalProductPharmaceuticalCharacteristicsComponent element, int index) { 11415 if (element == null) 11416 return; 11417 Complex t; 11418 if (Utilities.noString(parentType)) 11419 t = parent; 11420 else { 11421 t = parent.predicate("fhir:"+parentType+'.'+name); 11422 } 11423 composeBackboneElement(t, "characteristics", name, element, index); 11424 if (element.hasCode()) 11425 composeCodeableConcept(t, "MedicinalProductPharmaceutical", "code", element.getCode(), -1); 11426 if (element.hasStatus()) 11427 composeCodeableConcept(t, "MedicinalProductPharmaceutical", "status", element.getStatus(), -1); 11428 } 11429 11430 protected void composeMedicinalProductPharmaceuticalMedicinalProductPharmaceuticalRouteOfAdministrationComponent(Complex parent, String parentType, String name, MedicinalProductPharmaceutical.MedicinalProductPharmaceuticalRouteOfAdministrationComponent element, int index) { 11431 if (element == null) 11432 return; 11433 Complex t; 11434 if (Utilities.noString(parentType)) 11435 t = parent; 11436 else { 11437 t = parent.predicate("fhir:"+parentType+'.'+name); 11438 } 11439 composeBackboneElement(t, "routeOfAdministration", name, element, index); 11440 if (element.hasCode()) 11441 composeCodeableConcept(t, "MedicinalProductPharmaceutical", "code", element.getCode(), -1); 11442 if (element.hasFirstDose()) 11443 composeQuantity(t, "MedicinalProductPharmaceutical", "firstDose", element.getFirstDose(), -1); 11444 if (element.hasMaxSingleDose()) 11445 composeQuantity(t, "MedicinalProductPharmaceutical", "maxSingleDose", element.getMaxSingleDose(), -1); 11446 if (element.hasMaxDosePerDay()) 11447 composeQuantity(t, "MedicinalProductPharmaceutical", "maxDosePerDay", element.getMaxDosePerDay(), -1); 11448 if (element.hasMaxDosePerTreatmentPeriod()) 11449 composeRatio(t, "MedicinalProductPharmaceutical", "maxDosePerTreatmentPeriod", element.getMaxDosePerTreatmentPeriod(), -1); 11450 if (element.hasMaxTreatmentPeriod()) 11451 composeDuration(t, "MedicinalProductPharmaceutical", "maxTreatmentPeriod", element.getMaxTreatmentPeriod(), -1); 11452 for (int i = 0; i < element.getTargetSpecies().size(); i++) 11453 composeMedicinalProductPharmaceuticalMedicinalProductPharmaceuticalRouteOfAdministrationTargetSpeciesComponent(t, "MedicinalProductPharmaceutical", "targetSpecies", element.getTargetSpecies().get(i), i); 11454 } 11455 11456 protected void composeMedicinalProductPharmaceuticalMedicinalProductPharmaceuticalRouteOfAdministrationTargetSpeciesComponent(Complex parent, String parentType, String name, MedicinalProductPharmaceutical.MedicinalProductPharmaceuticalRouteOfAdministrationTargetSpeciesComponent element, int index) { 11457 if (element == null) 11458 return; 11459 Complex t; 11460 if (Utilities.noString(parentType)) 11461 t = parent; 11462 else { 11463 t = parent.predicate("fhir:"+parentType+'.'+name); 11464 } 11465 composeBackboneElement(t, "targetSpecies", name, element, index); 11466 if (element.hasCode()) 11467 composeCodeableConcept(t, "MedicinalProductPharmaceutical", "code", element.getCode(), -1); 11468 for (int i = 0; i < element.getWithdrawalPeriod().size(); i++) 11469 composeMedicinalProductPharmaceuticalMedicinalProductPharmaceuticalRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(t, "MedicinalProductPharmaceutical", "withdrawalPeriod", element.getWithdrawalPeriod().get(i), i); 11470 } 11471 11472 protected void composeMedicinalProductPharmaceuticalMedicinalProductPharmaceuticalRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(Complex parent, String parentType, String name, MedicinalProductPharmaceutical.MedicinalProductPharmaceuticalRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent element, int index) { 11473 if (element == null) 11474 return; 11475 Complex t; 11476 if (Utilities.noString(parentType)) 11477 t = parent; 11478 else { 11479 t = parent.predicate("fhir:"+parentType+'.'+name); 11480 } 11481 composeBackboneElement(t, "withdrawalPeriod", name, element, index); 11482 if (element.hasTissue()) 11483 composeCodeableConcept(t, "MedicinalProductPharmaceutical", "tissue", element.getTissue(), -1); 11484 if (element.hasValue()) 11485 composeQuantity(t, "MedicinalProductPharmaceutical", "value", element.getValue(), -1); 11486 if (element.hasSupportingInformationElement()) 11487 composeString(t, "MedicinalProductPharmaceutical", "supportingInformation", element.getSupportingInformationElement(), -1); 11488 } 11489 11490 protected void composeMedicinalProductUndesirableEffect(Complex parent, String parentType, String name, MedicinalProductUndesirableEffect element, int index) { 11491 if (element == null) 11492 return; 11493 Complex t; 11494 if (Utilities.noString(parentType)) 11495 t = parent; 11496 else { 11497 t = parent.predicate("fhir:"+parentType+'.'+name); 11498 } 11499 composeDomainResource(t, "MedicinalProductUndesirableEffect", name, element, index); 11500 for (int i = 0; i < element.getSubject().size(); i++) 11501 composeReference(t, "MedicinalProductUndesirableEffect", "subject", element.getSubject().get(i), i); 11502 if (element.hasSymptomConditionEffect()) 11503 composeCodeableConcept(t, "MedicinalProductUndesirableEffect", "symptomConditionEffect", element.getSymptomConditionEffect(), -1); 11504 if (element.hasClassification()) 11505 composeCodeableConcept(t, "MedicinalProductUndesirableEffect", "classification", element.getClassification(), -1); 11506 if (element.hasFrequencyOfOccurrence()) 11507 composeCodeableConcept(t, "MedicinalProductUndesirableEffect", "frequencyOfOccurrence", element.getFrequencyOfOccurrence(), -1); 11508 for (int i = 0; i < element.getPopulation().size(); i++) 11509 composePopulation(t, "MedicinalProductUndesirableEffect", "population", element.getPopulation().get(i), i); 11510 } 11511 11512 protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition element, int index) { 11513 if (element == null) 11514 return; 11515 Complex t; 11516 if (Utilities.noString(parentType)) 11517 t = parent; 11518 else { 11519 t = parent.predicate("fhir:"+parentType+'.'+name); 11520 } 11521 composeDomainResource(t, "MessageDefinition", name, element, index); 11522 if (element.hasUrlElement()) 11523 composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1); 11524 for (int i = 0; i < element.getIdentifier().size(); i++) 11525 composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier().get(i), i); 11526 if (element.hasVersionElement()) 11527 composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1); 11528 if (element.hasNameElement()) 11529 composeString(t, "MessageDefinition", "name", element.getNameElement(), -1); 11530 if (element.hasTitleElement()) 11531 composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1); 11532 for (int i = 0; i < element.getReplaces().size(); i++) 11533 composeCanonical(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i); 11534 if (element.hasStatusElement()) 11535 composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1); 11536 if (element.hasExperimentalElement()) 11537 composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1); 11538 if (element.hasDateElement()) 11539 composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1); 11540 if (element.hasPublisherElement()) 11541 composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1); 11542 for (int i = 0; i < element.getContact().size(); i++) 11543 composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i); 11544 if (element.hasDescriptionElement()) 11545 composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1); 11546 for (int i = 0; i < element.getUseContext().size(); i++) 11547 composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i); 11548 for (int i = 0; i < element.getJurisdiction().size(); i++) 11549 composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 11550 if (element.hasPurposeElement()) 11551 composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1); 11552 if (element.hasCopyrightElement()) 11553 composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1); 11554 if (element.hasBaseElement()) 11555 composeCanonical(t, "MessageDefinition", "base", element.getBaseElement(), -1); 11556 for (int i = 0; i < element.getParent().size(); i++) 11557 composeCanonical(t, "MessageDefinition", "parent", element.getParent().get(i), i); 11558 if (element.hasEvent()) 11559 composeType(t, "MessageDefinition", "event", element.getEvent(), -1); 11560 if (element.hasCategoryElement()) 11561 composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1); 11562 for (int i = 0; i < element.getFocus().size(); i++) 11563 composeMessageDefinitionMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i); 11564 if (element.hasResponseRequiredElement()) 11565 composeEnum(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1); 11566 for (int i = 0; i < element.getAllowedResponse().size(); i++) 11567 composeMessageDefinitionMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i); 11568 for (int i = 0; i < element.getGraph().size(); i++) 11569 composeCanonical(t, "MessageDefinition", "graph", element.getGraph().get(i), i); 11570 } 11571 11572 protected void composeMessageDefinitionMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent element, int index) { 11573 if (element == null) 11574 return; 11575 Complex t; 11576 if (Utilities.noString(parentType)) 11577 t = parent; 11578 else { 11579 t = parent.predicate("fhir:"+parentType+'.'+name); 11580 } 11581 composeBackboneElement(t, "focus", name, element, index); 11582 if (element.hasCodeElement()) 11583 composeCode(t, "MessageDefinition", "code", element.getCodeElement(), -1); 11584 if (element.hasProfileElement()) 11585 composeCanonical(t, "MessageDefinition", "profile", element.getProfileElement(), -1); 11586 if (element.hasMinElement()) 11587 composeUnsignedInt(t, "MessageDefinition", "min", element.getMinElement(), -1); 11588 if (element.hasMaxElement()) 11589 composeString(t, "MessageDefinition", "max", element.getMaxElement(), -1); 11590 } 11591 11592 protected void composeMessageDefinitionMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent element, int index) { 11593 if (element == null) 11594 return; 11595 Complex t; 11596 if (Utilities.noString(parentType)) 11597 t = parent; 11598 else { 11599 t = parent.predicate("fhir:"+parentType+'.'+name); 11600 } 11601 composeBackboneElement(t, "allowedResponse", name, element, index); 11602 if (element.hasMessageElement()) 11603 composeCanonical(t, "MessageDefinition", "message", element.getMessageElement(), -1); 11604 if (element.hasSituationElement()) 11605 composeMarkdown(t, "MessageDefinition", "situation", element.getSituationElement(), -1); 11606 } 11607 11608 protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) { 11609 if (element == null) 11610 return; 11611 Complex t; 11612 if (Utilities.noString(parentType)) 11613 t = parent; 11614 else { 11615 t = parent.predicate("fhir:"+parentType+'.'+name); 11616 } 11617 composeDomainResource(t, "MessageHeader", name, element, index); 11618 if (element.hasEvent()) 11619 composeType(t, "MessageHeader", "event", element.getEvent(), -1); 11620 for (int i = 0; i < element.getDestination().size(); i++) 11621 composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i); 11622 if (element.hasSender()) 11623 composeReference(t, "MessageHeader", "sender", element.getSender(), -1); 11624 if (element.hasEnterer()) 11625 composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1); 11626 if (element.hasAuthor()) 11627 composeReference(t, "MessageHeader", "author", element.getAuthor(), -1); 11628 if (element.hasSource()) 11629 composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1); 11630 if (element.hasResponsible()) 11631 composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1); 11632 if (element.hasReason()) 11633 composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1); 11634 if (element.hasResponse()) 11635 composeMessageHeaderMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1); 11636 for (int i = 0; i < element.getFocus().size(); i++) 11637 composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i); 11638 if (element.hasDefinitionElement()) 11639 composeCanonical(t, "MessageHeader", "definition", element.getDefinitionElement(), -1); 11640 } 11641 11642 protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) { 11643 if (element == null) 11644 return; 11645 Complex t; 11646 if (Utilities.noString(parentType)) 11647 t = parent; 11648 else { 11649 t = parent.predicate("fhir:"+parentType+'.'+name); 11650 } 11651 composeBackboneElement(t, "destination", name, element, index); 11652 if (element.hasNameElement()) 11653 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 11654 if (element.hasTarget()) 11655 composeReference(t, "MessageHeader", "target", element.getTarget(), -1); 11656 if (element.hasEndpointElement()) 11657 composeUrl(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 11658 if (element.hasReceiver()) 11659 composeReference(t, "MessageHeader", "receiver", element.getReceiver(), -1); 11660 } 11661 11662 protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) { 11663 if (element == null) 11664 return; 11665 Complex t; 11666 if (Utilities.noString(parentType)) 11667 t = parent; 11668 else { 11669 t = parent.predicate("fhir:"+parentType+'.'+name); 11670 } 11671 composeBackboneElement(t, "source", name, element, index); 11672 if (element.hasNameElement()) 11673 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 11674 if (element.hasSoftwareElement()) 11675 composeString(t, "MessageHeader", "software", element.getSoftwareElement(), -1); 11676 if (element.hasVersionElement()) 11677 composeString(t, "MessageHeader", "version", element.getVersionElement(), -1); 11678 if (element.hasContact()) 11679 composeContactPoint(t, "MessageHeader", "contact", element.getContact(), -1); 11680 if (element.hasEndpointElement()) 11681 composeUrl(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 11682 } 11683 11684 protected void composeMessageHeaderMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) { 11685 if (element == null) 11686 return; 11687 Complex t; 11688 if (Utilities.noString(parentType)) 11689 t = parent; 11690 else { 11691 t = parent.predicate("fhir:"+parentType+'.'+name); 11692 } 11693 composeBackboneElement(t, "response", name, element, index); 11694 if (element.hasIdentifierElement()) 11695 composeId(t, "MessageHeader", "identifier", element.getIdentifierElement(), -1); 11696 if (element.hasCodeElement()) 11697 composeEnum(t, "MessageHeader", "code", element.getCodeElement(), -1); 11698 if (element.hasDetails()) 11699 composeReference(t, "MessageHeader", "details", element.getDetails(), -1); 11700 } 11701 11702 protected void composeMolecularSequence(Complex parent, String parentType, String name, MolecularSequence element, int index) { 11703 if (element == null) 11704 return; 11705 Complex t; 11706 if (Utilities.noString(parentType)) 11707 t = parent; 11708 else { 11709 t = parent.predicate("fhir:"+parentType+'.'+name); 11710 } 11711 composeDomainResource(t, "MolecularSequence", name, element, index); 11712 for (int i = 0; i < element.getIdentifier().size(); i++) 11713 composeIdentifier(t, "MolecularSequence", "identifier", element.getIdentifier().get(i), i); 11714 if (element.hasTypeElement()) 11715 composeEnum(t, "MolecularSequence", "type", element.getTypeElement(), -1); 11716 if (element.hasCoordinateSystemElement()) 11717 composeInteger(t, "MolecularSequence", "coordinateSystem", element.getCoordinateSystemElement(), -1); 11718 if (element.hasPatient()) 11719 composeReference(t, "MolecularSequence", "patient", element.getPatient(), -1); 11720 if (element.hasSpecimen()) 11721 composeReference(t, "MolecularSequence", "specimen", element.getSpecimen(), -1); 11722 if (element.hasDevice()) 11723 composeReference(t, "MolecularSequence", "device", element.getDevice(), -1); 11724 if (element.hasPerformer()) 11725 composeReference(t, "MolecularSequence", "performer", element.getPerformer(), -1); 11726 if (element.hasQuantity()) 11727 composeQuantity(t, "MolecularSequence", "quantity", element.getQuantity(), -1); 11728 if (element.hasReferenceSeq()) 11729 composeMolecularSequenceMolecularSequenceReferenceSeqComponent(t, "MolecularSequence", "referenceSeq", element.getReferenceSeq(), -1); 11730 for (int i = 0; i < element.getVariant().size(); i++) 11731 composeMolecularSequenceMolecularSequenceVariantComponent(t, "MolecularSequence", "variant", element.getVariant().get(i), i); 11732 if (element.hasObservedSeqElement()) 11733 composeString(t, "MolecularSequence", "observedSeq", element.getObservedSeqElement(), -1); 11734 for (int i = 0; i < element.getQuality().size(); i++) 11735 composeMolecularSequenceMolecularSequenceQualityComponent(t, "MolecularSequence", "quality", element.getQuality().get(i), i); 11736 if (element.hasReadCoverageElement()) 11737 composeInteger(t, "MolecularSequence", "readCoverage", element.getReadCoverageElement(), -1); 11738 for (int i = 0; i < element.getRepository().size(); i++) 11739 composeMolecularSequenceMolecularSequenceRepositoryComponent(t, "MolecularSequence", "repository", element.getRepository().get(i), i); 11740 for (int i = 0; i < element.getPointer().size(); i++) 11741 composeReference(t, "MolecularSequence", "pointer", element.getPointer().get(i), i); 11742 for (int i = 0; i < element.getStructureVariant().size(); i++) 11743 composeMolecularSequenceMolecularSequenceStructureVariantComponent(t, "MolecularSequence", "structureVariant", element.getStructureVariant().get(i), i); 11744 } 11745 11746 protected void composeMolecularSequenceMolecularSequenceReferenceSeqComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceReferenceSeqComponent element, int index) { 11747 if (element == null) 11748 return; 11749 Complex t; 11750 if (Utilities.noString(parentType)) 11751 t = parent; 11752 else { 11753 t = parent.predicate("fhir:"+parentType+'.'+name); 11754 } 11755 composeBackboneElement(t, "referenceSeq", name, element, index); 11756 if (element.hasChromosome()) 11757 composeCodeableConcept(t, "MolecularSequence", "chromosome", element.getChromosome(), -1); 11758 if (element.hasGenomeBuildElement()) 11759 composeString(t, "MolecularSequence", "genomeBuild", element.getGenomeBuildElement(), -1); 11760 if (element.hasOrientationElement()) 11761 composeEnum(t, "MolecularSequence", "orientation", element.getOrientationElement(), -1); 11762 if (element.hasReferenceSeqId()) 11763 composeCodeableConcept(t, "MolecularSequence", "referenceSeqId", element.getReferenceSeqId(), -1); 11764 if (element.hasReferenceSeqPointer()) 11765 composeReference(t, "MolecularSequence", "referenceSeqPointer", element.getReferenceSeqPointer(), -1); 11766 if (element.hasReferenceSeqStringElement()) 11767 composeString(t, "MolecularSequence", "referenceSeqString", element.getReferenceSeqStringElement(), -1); 11768 if (element.hasStrandElement()) 11769 composeEnum(t, "MolecularSequence", "strand", element.getStrandElement(), -1); 11770 if (element.hasWindowStartElement()) 11771 composeInteger(t, "MolecularSequence", "windowStart", element.getWindowStartElement(), -1); 11772 if (element.hasWindowEndElement()) 11773 composeInteger(t, "MolecularSequence", "windowEnd", element.getWindowEndElement(), -1); 11774 } 11775 11776 protected void composeMolecularSequenceMolecularSequenceVariantComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceVariantComponent element, int index) { 11777 if (element == null) 11778 return; 11779 Complex t; 11780 if (Utilities.noString(parentType)) 11781 t = parent; 11782 else { 11783 t = parent.predicate("fhir:"+parentType+'.'+name); 11784 } 11785 composeBackboneElement(t, "variant", name, element, index); 11786 if (element.hasStartElement()) 11787 composeInteger(t, "MolecularSequence", "start", element.getStartElement(), -1); 11788 if (element.hasEndElement()) 11789 composeInteger(t, "MolecularSequence", "end", element.getEndElement(), -1); 11790 if (element.hasObservedAlleleElement()) 11791 composeString(t, "MolecularSequence", "observedAllele", element.getObservedAlleleElement(), -1); 11792 if (element.hasReferenceAlleleElement()) 11793 composeString(t, "MolecularSequence", "referenceAllele", element.getReferenceAlleleElement(), -1); 11794 if (element.hasCigarElement()) 11795 composeString(t, "MolecularSequence", "cigar", element.getCigarElement(), -1); 11796 if (element.hasVariantPointer()) 11797 composeReference(t, "MolecularSequence", "variantPointer", element.getVariantPointer(), -1); 11798 } 11799 11800 protected void composeMolecularSequenceMolecularSequenceQualityComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceQualityComponent element, int index) { 11801 if (element == null) 11802 return; 11803 Complex t; 11804 if (Utilities.noString(parentType)) 11805 t = parent; 11806 else { 11807 t = parent.predicate("fhir:"+parentType+'.'+name); 11808 } 11809 composeBackboneElement(t, "quality", name, element, index); 11810 if (element.hasTypeElement()) 11811 composeEnum(t, "MolecularSequence", "type", element.getTypeElement(), -1); 11812 if (element.hasStandardSequence()) 11813 composeCodeableConcept(t, "MolecularSequence", "standardSequence", element.getStandardSequence(), -1); 11814 if (element.hasStartElement()) 11815 composeInteger(t, "MolecularSequence", "start", element.getStartElement(), -1); 11816 if (element.hasEndElement()) 11817 composeInteger(t, "MolecularSequence", "end", element.getEndElement(), -1); 11818 if (element.hasScore()) 11819 composeQuantity(t, "MolecularSequence", "score", element.getScore(), -1); 11820 if (element.hasMethod()) 11821 composeCodeableConcept(t, "MolecularSequence", "method", element.getMethod(), -1); 11822 if (element.hasTruthTPElement()) 11823 composeDecimal(t, "MolecularSequence", "truthTP", element.getTruthTPElement(), -1); 11824 if (element.hasQueryTPElement()) 11825 composeDecimal(t, "MolecularSequence", "queryTP", element.getQueryTPElement(), -1); 11826 if (element.hasTruthFNElement()) 11827 composeDecimal(t, "MolecularSequence", "truthFN", element.getTruthFNElement(), -1); 11828 if (element.hasQueryFPElement()) 11829 composeDecimal(t, "MolecularSequence", "queryFP", element.getQueryFPElement(), -1); 11830 if (element.hasGtFPElement()) 11831 composeDecimal(t, "MolecularSequence", "gtFP", element.getGtFPElement(), -1); 11832 if (element.hasPrecisionElement()) 11833 composeDecimal(t, "MolecularSequence", "precision", element.getPrecisionElement(), -1); 11834 if (element.hasRecallElement()) 11835 composeDecimal(t, "MolecularSequence", "recall", element.getRecallElement(), -1); 11836 if (element.hasFScoreElement()) 11837 composeDecimal(t, "MolecularSequence", "fScore", element.getFScoreElement(), -1); 11838 if (element.hasRoc()) 11839 composeMolecularSequenceMolecularSequenceQualityRocComponent(t, "MolecularSequence", "roc", element.getRoc(), -1); 11840 } 11841 11842 protected void composeMolecularSequenceMolecularSequenceQualityRocComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceQualityRocComponent element, int index) { 11843 if (element == null) 11844 return; 11845 Complex t; 11846 if (Utilities.noString(parentType)) 11847 t = parent; 11848 else { 11849 t = parent.predicate("fhir:"+parentType+'.'+name); 11850 } 11851 composeBackboneElement(t, "roc", name, element, index); 11852 for (int i = 0; i < element.getScore().size(); i++) 11853 composeInteger(t, "MolecularSequence", "score", element.getScore().get(i), i); 11854 for (int i = 0; i < element.getNumTP().size(); i++) 11855 composeInteger(t, "MolecularSequence", "numTP", element.getNumTP().get(i), i); 11856 for (int i = 0; i < element.getNumFP().size(); i++) 11857 composeInteger(t, "MolecularSequence", "numFP", element.getNumFP().get(i), i); 11858 for (int i = 0; i < element.getNumFN().size(); i++) 11859 composeInteger(t, "MolecularSequence", "numFN", element.getNumFN().get(i), i); 11860 for (int i = 0; i < element.getPrecision().size(); i++) 11861 composeDecimal(t, "MolecularSequence", "precision", element.getPrecision().get(i), i); 11862 for (int i = 0; i < element.getSensitivity().size(); i++) 11863 composeDecimal(t, "MolecularSequence", "sensitivity", element.getSensitivity().get(i), i); 11864 for (int i = 0; i < element.getFMeasure().size(); i++) 11865 composeDecimal(t, "MolecularSequence", "fMeasure", element.getFMeasure().get(i), i); 11866 } 11867 11868 protected void composeMolecularSequenceMolecularSequenceRepositoryComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceRepositoryComponent element, int index) { 11869 if (element == null) 11870 return; 11871 Complex t; 11872 if (Utilities.noString(parentType)) 11873 t = parent; 11874 else { 11875 t = parent.predicate("fhir:"+parentType+'.'+name); 11876 } 11877 composeBackboneElement(t, "repository", name, element, index); 11878 if (element.hasTypeElement()) 11879 composeEnum(t, "MolecularSequence", "type", element.getTypeElement(), -1); 11880 if (element.hasUrlElement()) 11881 composeUri(t, "MolecularSequence", "url", element.getUrlElement(), -1); 11882 if (element.hasNameElement()) 11883 composeString(t, "MolecularSequence", "name", element.getNameElement(), -1); 11884 if (element.hasDatasetIdElement()) 11885 composeString(t, "MolecularSequence", "datasetId", element.getDatasetIdElement(), -1); 11886 if (element.hasVariantsetIdElement()) 11887 composeString(t, "MolecularSequence", "variantsetId", element.getVariantsetIdElement(), -1); 11888 if (element.hasReadsetIdElement()) 11889 composeString(t, "MolecularSequence", "readsetId", element.getReadsetIdElement(), -1); 11890 } 11891 11892 protected void composeMolecularSequenceMolecularSequenceStructureVariantComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantComponent element, int index) { 11893 if (element == null) 11894 return; 11895 Complex t; 11896 if (Utilities.noString(parentType)) 11897 t = parent; 11898 else { 11899 t = parent.predicate("fhir:"+parentType+'.'+name); 11900 } 11901 composeBackboneElement(t, "structureVariant", name, element, index); 11902 if (element.hasVariantType()) 11903 composeCodeableConcept(t, "MolecularSequence", "variantType", element.getVariantType(), -1); 11904 if (element.hasExactElement()) 11905 composeBoolean(t, "MolecularSequence", "exact", element.getExactElement(), -1); 11906 if (element.hasLengthElement()) 11907 composeInteger(t, "MolecularSequence", "length", element.getLengthElement(), -1); 11908 if (element.hasOuter()) 11909 composeMolecularSequenceMolecularSequenceStructureVariantOuterComponent(t, "MolecularSequence", "outer", element.getOuter(), -1); 11910 if (element.hasInner()) 11911 composeMolecularSequenceMolecularSequenceStructureVariantInnerComponent(t, "MolecularSequence", "inner", element.getInner(), -1); 11912 } 11913 11914 protected void composeMolecularSequenceMolecularSequenceStructureVariantOuterComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantOuterComponent element, int index) { 11915 if (element == null) 11916 return; 11917 Complex t; 11918 if (Utilities.noString(parentType)) 11919 t = parent; 11920 else { 11921 t = parent.predicate("fhir:"+parentType+'.'+name); 11922 } 11923 composeBackboneElement(t, "outer", name, element, index); 11924 if (element.hasStartElement()) 11925 composeInteger(t, "MolecularSequence", "start", element.getStartElement(), -1); 11926 if (element.hasEndElement()) 11927 composeInteger(t, "MolecularSequence", "end", element.getEndElement(), -1); 11928 } 11929 11930 protected void composeMolecularSequenceMolecularSequenceStructureVariantInnerComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantInnerComponent element, int index) { 11931 if (element == null) 11932 return; 11933 Complex t; 11934 if (Utilities.noString(parentType)) 11935 t = parent; 11936 else { 11937 t = parent.predicate("fhir:"+parentType+'.'+name); 11938 } 11939 composeBackboneElement(t, "inner", name, element, index); 11940 if (element.hasStartElement()) 11941 composeInteger(t, "MolecularSequence", "start", element.getStartElement(), -1); 11942 if (element.hasEndElement()) 11943 composeInteger(t, "MolecularSequence", "end", element.getEndElement(), -1); 11944 } 11945 11946 protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) { 11947 if (element == null) 11948 return; 11949 Complex t; 11950 if (Utilities.noString(parentType)) 11951 t = parent; 11952 else { 11953 t = parent.predicate("fhir:"+parentType+'.'+name); 11954 } 11955 composeDomainResource(t, "NamingSystem", name, element, index); 11956 if (element.hasNameElement()) 11957 composeString(t, "NamingSystem", "name", element.getNameElement(), -1); 11958 if (element.hasStatusElement()) 11959 composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1); 11960 if (element.hasKindElement()) 11961 composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1); 11962 if (element.hasDateElement()) 11963 composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1); 11964 if (element.hasPublisherElement()) 11965 composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1); 11966 for (int i = 0; i < element.getContact().size(); i++) 11967 composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i); 11968 if (element.hasResponsibleElement()) 11969 composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1); 11970 if (element.hasType()) 11971 composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1); 11972 if (element.hasDescriptionElement()) 11973 composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1); 11974 for (int i = 0; i < element.getUseContext().size(); i++) 11975 composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i); 11976 for (int i = 0; i < element.getJurisdiction().size(); i++) 11977 composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i); 11978 if (element.hasUsageElement()) 11979 composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1); 11980 for (int i = 0; i < element.getUniqueId().size(); i++) 11981 composeNamingSystemNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i); 11982 } 11983 11984 protected void composeNamingSystemNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) { 11985 if (element == null) 11986 return; 11987 Complex t; 11988 if (Utilities.noString(parentType)) 11989 t = parent; 11990 else { 11991 t = parent.predicate("fhir:"+parentType+'.'+name); 11992 } 11993 composeBackboneElement(t, "uniqueId", name, element, index); 11994 if (element.hasTypeElement()) 11995 composeEnum(t, "NamingSystem", "type", element.getTypeElement(), -1); 11996 if (element.hasValueElement()) 11997 composeString(t, "NamingSystem", "value", element.getValueElement(), -1); 11998 if (element.hasPreferredElement()) 11999 composeBoolean(t, "NamingSystem", "preferred", element.getPreferredElement(), -1); 12000 if (element.hasCommentElement()) 12001 composeString(t, "NamingSystem", "comment", element.getCommentElement(), -1); 12002 if (element.hasPeriod()) 12003 composePeriod(t, "NamingSystem", "period", element.getPeriod(), -1); 12004 } 12005 12006 protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder element, int index) { 12007 if (element == null) 12008 return; 12009 Complex t; 12010 if (Utilities.noString(parentType)) 12011 t = parent; 12012 else { 12013 t = parent.predicate("fhir:"+parentType+'.'+name); 12014 } 12015 composeDomainResource(t, "NutritionOrder", name, element, index); 12016 for (int i = 0; i < element.getIdentifier().size(); i++) 12017 composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i); 12018 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 12019 composeCanonical(t, "NutritionOrder", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 12020 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 12021 composeUri(t, "NutritionOrder", "instantiatesUri", element.getInstantiatesUri().get(i), i); 12022 for (int i = 0; i < element.getInstantiates().size(); i++) 12023 composeUri(t, "NutritionOrder", "instantiates", element.getInstantiates().get(i), i); 12024 if (element.hasStatusElement()) 12025 composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1); 12026 if (element.hasIntentElement()) 12027 composeEnum(t, "NutritionOrder", "intent", element.getIntentElement(), -1); 12028 if (element.hasPatient()) 12029 composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1); 12030 if (element.hasEncounter()) 12031 composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1); 12032 if (element.hasDateTimeElement()) 12033 composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1); 12034 if (element.hasOrderer()) 12035 composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1); 12036 for (int i = 0; i < element.getAllergyIntolerance().size(); i++) 12037 composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i); 12038 for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) 12039 composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i); 12040 for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) 12041 composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i); 12042 if (element.hasOralDiet()) 12043 composeNutritionOrderNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1); 12044 for (int i = 0; i < element.getSupplement().size(); i++) 12045 composeNutritionOrderNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i); 12046 if (element.hasEnteralFormula()) 12047 composeNutritionOrderNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1); 12048 for (int i = 0; i < element.getNote().size(); i++) 12049 composeAnnotation(t, "NutritionOrder", "note", element.getNote().get(i), i); 12050 } 12051 12052 protected void composeNutritionOrderNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent element, int index) { 12053 if (element == null) 12054 return; 12055 Complex t; 12056 if (Utilities.noString(parentType)) 12057 t = parent; 12058 else { 12059 t = parent.predicate("fhir:"+parentType+'.'+name); 12060 } 12061 composeBackboneElement(t, "oralDiet", name, element, index); 12062 for (int i = 0; i < element.getType().size(); i++) 12063 composeCodeableConcept(t, "NutritionOrder", "type", element.getType().get(i), i); 12064 for (int i = 0; i < element.getSchedule().size(); i++) 12065 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 12066 for (int i = 0; i < element.getNutrient().size(); i++) 12067 composeNutritionOrderNutritionOrderOralDietNutrientComponent(t, "NutritionOrder", "nutrient", element.getNutrient().get(i), i); 12068 for (int i = 0; i < element.getTexture().size(); i++) 12069 composeNutritionOrderNutritionOrderOralDietTextureComponent(t, "NutritionOrder", "texture", element.getTexture().get(i), i); 12070 for (int i = 0; i < element.getFluidConsistencyType().size(); i++) 12071 composeCodeableConcept(t, "NutritionOrder", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i); 12072 if (element.hasInstructionElement()) 12073 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 12074 } 12075 12076 protected void composeNutritionOrderNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) { 12077 if (element == null) 12078 return; 12079 Complex t; 12080 if (Utilities.noString(parentType)) 12081 t = parent; 12082 else { 12083 t = parent.predicate("fhir:"+parentType+'.'+name); 12084 } 12085 composeBackboneElement(t, "nutrient", name, element, index); 12086 if (element.hasModifier()) 12087 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 12088 if (element.hasAmount()) 12089 composeQuantity(t, "NutritionOrder", "amount", element.getAmount(), -1); 12090 } 12091 12092 protected void composeNutritionOrderNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) { 12093 if (element == null) 12094 return; 12095 Complex t; 12096 if (Utilities.noString(parentType)) 12097 t = parent; 12098 else { 12099 t = parent.predicate("fhir:"+parentType+'.'+name); 12100 } 12101 composeBackboneElement(t, "texture", name, element, index); 12102 if (element.hasModifier()) 12103 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 12104 if (element.hasFoodType()) 12105 composeCodeableConcept(t, "NutritionOrder", "foodType", element.getFoodType(), -1); 12106 } 12107 12108 protected void composeNutritionOrderNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) { 12109 if (element == null) 12110 return; 12111 Complex t; 12112 if (Utilities.noString(parentType)) 12113 t = parent; 12114 else { 12115 t = parent.predicate("fhir:"+parentType+'.'+name); 12116 } 12117 composeBackboneElement(t, "supplement", name, element, index); 12118 if (element.hasType()) 12119 composeCodeableConcept(t, "NutritionOrder", "type", element.getType(), -1); 12120 if (element.hasProductNameElement()) 12121 composeString(t, "NutritionOrder", "productName", element.getProductNameElement(), -1); 12122 for (int i = 0; i < element.getSchedule().size(); i++) 12123 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 12124 if (element.hasQuantity()) 12125 composeQuantity(t, "NutritionOrder", "quantity", element.getQuantity(), -1); 12126 if (element.hasInstructionElement()) 12127 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 12128 } 12129 12130 protected void composeNutritionOrderNutritionOrderEnteralFormulaComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaComponent element, int index) { 12131 if (element == null) 12132 return; 12133 Complex t; 12134 if (Utilities.noString(parentType)) 12135 t = parent; 12136 else { 12137 t = parent.predicate("fhir:"+parentType+'.'+name); 12138 } 12139 composeBackboneElement(t, "enteralFormula", name, element, index); 12140 if (element.hasBaseFormulaType()) 12141 composeCodeableConcept(t, "NutritionOrder", "baseFormulaType", element.getBaseFormulaType(), -1); 12142 if (element.hasBaseFormulaProductNameElement()) 12143 composeString(t, "NutritionOrder", "baseFormulaProductName", element.getBaseFormulaProductNameElement(), -1); 12144 if (element.hasAdditiveType()) 12145 composeCodeableConcept(t, "NutritionOrder", "additiveType", element.getAdditiveType(), -1); 12146 if (element.hasAdditiveProductNameElement()) 12147 composeString(t, "NutritionOrder", "additiveProductName", element.getAdditiveProductNameElement(), -1); 12148 if (element.hasCaloricDensity()) 12149 composeQuantity(t, "NutritionOrder", "caloricDensity", element.getCaloricDensity(), -1); 12150 if (element.hasRouteofAdministration()) 12151 composeCodeableConcept(t, "NutritionOrder", "routeofAdministration", element.getRouteofAdministration(), -1); 12152 for (int i = 0; i < element.getAdministration().size(); i++) 12153 composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(t, "NutritionOrder", "administration", element.getAdministration().get(i), i); 12154 if (element.hasMaxVolumeToDeliver()) 12155 composeQuantity(t, "NutritionOrder", "maxVolumeToDeliver", element.getMaxVolumeToDeliver(), -1); 12156 if (element.hasAdministrationInstructionElement()) 12157 composeString(t, "NutritionOrder", "administrationInstruction", element.getAdministrationInstructionElement(), -1); 12158 } 12159 12160 protected void composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element, int index) { 12161 if (element == null) 12162 return; 12163 Complex t; 12164 if (Utilities.noString(parentType)) 12165 t = parent; 12166 else { 12167 t = parent.predicate("fhir:"+parentType+'.'+name); 12168 } 12169 composeBackboneElement(t, "administration", name, element, index); 12170 if (element.hasSchedule()) 12171 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule(), -1); 12172 if (element.hasQuantity()) 12173 composeQuantity(t, "NutritionOrder", "quantity", element.getQuantity(), -1); 12174 if (element.hasRate()) 12175 composeType(t, "NutritionOrder", "rate", element.getRate(), -1); 12176 } 12177 12178 protected void composeObservation(Complex parent, String parentType, String name, Observation element, int index) { 12179 if (element == null) 12180 return; 12181 Complex t; 12182 if (Utilities.noString(parentType)) 12183 t = parent; 12184 else { 12185 t = parent.predicate("fhir:"+parentType+'.'+name); 12186 } 12187 composeDomainResource(t, "Observation", name, element, index); 12188 for (int i = 0; i < element.getIdentifier().size(); i++) 12189 composeIdentifier(t, "Observation", "identifier", element.getIdentifier().get(i), i); 12190 for (int i = 0; i < element.getBasedOn().size(); i++) 12191 composeReference(t, "Observation", "basedOn", element.getBasedOn().get(i), i); 12192 for (int i = 0; i < element.getPartOf().size(); i++) 12193 composeReference(t, "Observation", "partOf", element.getPartOf().get(i), i); 12194 if (element.hasStatusElement()) 12195 composeEnum(t, "Observation", "status", element.getStatusElement(), -1); 12196 for (int i = 0; i < element.getCategory().size(); i++) 12197 composeCodeableConcept(t, "Observation", "category", element.getCategory().get(i), i); 12198 if (element.hasCode()) 12199 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 12200 if (element.hasSubject()) 12201 composeReference(t, "Observation", "subject", element.getSubject(), -1); 12202 for (int i = 0; i < element.getFocus().size(); i++) 12203 composeReference(t, "Observation", "focus", element.getFocus().get(i), i); 12204 if (element.hasEncounter()) 12205 composeReference(t, "Observation", "encounter", element.getEncounter(), -1); 12206 if (element.hasEffective()) 12207 composeType(t, "Observation", "effective", element.getEffective(), -1); 12208 if (element.hasIssuedElement()) 12209 composeInstant(t, "Observation", "issued", element.getIssuedElement(), -1); 12210 for (int i = 0; i < element.getPerformer().size(); i++) 12211 composeReference(t, "Observation", "performer", element.getPerformer().get(i), i); 12212 if (element.hasValue()) 12213 composeType(t, "Observation", "value", element.getValue(), -1); 12214 if (element.hasDataAbsentReason()) 12215 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 12216 for (int i = 0; i < element.getInterpretation().size(); i++) 12217 composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation().get(i), i); 12218 for (int i = 0; i < element.getNote().size(); i++) 12219 composeAnnotation(t, "Observation", "note", element.getNote().get(i), i); 12220 if (element.hasBodySite()) 12221 composeCodeableConcept(t, "Observation", "bodySite", element.getBodySite(), -1); 12222 if (element.hasMethod()) 12223 composeCodeableConcept(t, "Observation", "method", element.getMethod(), -1); 12224 if (element.hasSpecimen()) 12225 composeReference(t, "Observation", "specimen", element.getSpecimen(), -1); 12226 if (element.hasDevice()) 12227 composeReference(t, "Observation", "device", element.getDevice(), -1); 12228 for (int i = 0; i < element.getReferenceRange().size(); i++) 12229 composeObservationObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 12230 for (int i = 0; i < element.getHasMember().size(); i++) 12231 composeReference(t, "Observation", "hasMember", element.getHasMember().get(i), i); 12232 for (int i = 0; i < element.getDerivedFrom().size(); i++) 12233 composeReference(t, "Observation", "derivedFrom", element.getDerivedFrom().get(i), i); 12234 for (int i = 0; i < element.getComponent().size(); i++) 12235 composeObservationObservationComponentComponent(t, "Observation", "component", element.getComponent().get(i), i); 12236 } 12237 12238 protected void composeObservationObservationReferenceRangeComponent(Complex parent, String parentType, String name, Observation.ObservationReferenceRangeComponent element, int index) { 12239 if (element == null) 12240 return; 12241 Complex t; 12242 if (Utilities.noString(parentType)) 12243 t = parent; 12244 else { 12245 t = parent.predicate("fhir:"+parentType+'.'+name); 12246 } 12247 composeBackboneElement(t, "referenceRange", name, element, index); 12248 if (element.hasLow()) 12249 composeQuantity(t, "Observation", "low", element.getLow(), -1); 12250 if (element.hasHigh()) 12251 composeQuantity(t, "Observation", "high", element.getHigh(), -1); 12252 if (element.hasType()) 12253 composeCodeableConcept(t, "Observation", "type", element.getType(), -1); 12254 for (int i = 0; i < element.getAppliesTo().size(); i++) 12255 composeCodeableConcept(t, "Observation", "appliesTo", element.getAppliesTo().get(i), i); 12256 if (element.hasAge()) 12257 composeRange(t, "Observation", "age", element.getAge(), -1); 12258 if (element.hasTextElement()) 12259 composeString(t, "Observation", "text", element.getTextElement(), -1); 12260 } 12261 12262 protected void composeObservationObservationComponentComponent(Complex parent, String parentType, String name, Observation.ObservationComponentComponent element, int index) { 12263 if (element == null) 12264 return; 12265 Complex t; 12266 if (Utilities.noString(parentType)) 12267 t = parent; 12268 else { 12269 t = parent.predicate("fhir:"+parentType+'.'+name); 12270 } 12271 composeBackboneElement(t, "component", name, element, index); 12272 if (element.hasCode()) 12273 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 12274 if (element.hasValue()) 12275 composeType(t, "Observation", "value", element.getValue(), -1); 12276 if (element.hasDataAbsentReason()) 12277 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 12278 for (int i = 0; i < element.getInterpretation().size(); i++) 12279 composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation().get(i), i); 12280 for (int i = 0; i < element.getReferenceRange().size(); i++) 12281 composeObservationObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 12282 } 12283 12284 protected void composeObservationDefinition(Complex parent, String parentType, String name, ObservationDefinition element, int index) { 12285 if (element == null) 12286 return; 12287 Complex t; 12288 if (Utilities.noString(parentType)) 12289 t = parent; 12290 else { 12291 t = parent.predicate("fhir:"+parentType+'.'+name); 12292 } 12293 composeDomainResource(t, "ObservationDefinition", name, element, index); 12294 for (int i = 0; i < element.getCategory().size(); i++) 12295 composeCodeableConcept(t, "ObservationDefinition", "category", element.getCategory().get(i), i); 12296 if (element.hasCode()) 12297 composeCodeableConcept(t, "ObservationDefinition", "code", element.getCode(), -1); 12298 for (int i = 0; i < element.getIdentifier().size(); i++) 12299 composeIdentifier(t, "ObservationDefinition", "identifier", element.getIdentifier().get(i), i); 12300 for (int i = 0; i < element.getPermittedDataType().size(); i++) 12301 composeEnum(t, "ObservationDefinition", "permittedDataType", element.getPermittedDataType().get(i), i); 12302 if (element.hasMultipleResultsAllowedElement()) 12303 composeBoolean(t, "ObservationDefinition", "multipleResultsAllowed", element.getMultipleResultsAllowedElement(), -1); 12304 if (element.hasMethod()) 12305 composeCodeableConcept(t, "ObservationDefinition", "method", element.getMethod(), -1); 12306 if (element.hasPreferredReportNameElement()) 12307 composeString(t, "ObservationDefinition", "preferredReportName", element.getPreferredReportNameElement(), -1); 12308 if (element.hasQuantitativeDetails()) 12309 composeObservationDefinitionObservationDefinitionQuantitativeDetailsComponent(t, "ObservationDefinition", "quantitativeDetails", element.getQuantitativeDetails(), -1); 12310 for (int i = 0; i < element.getQualifiedInterval().size(); i++) 12311 composeObservationDefinitionObservationDefinitionQualifiedIntervalComponent(t, "ObservationDefinition", "qualifiedInterval", element.getQualifiedInterval().get(i), i); 12312 if (element.hasValidCodedValueSet()) 12313 composeReference(t, "ObservationDefinition", "validCodedValueSet", element.getValidCodedValueSet(), -1); 12314 if (element.hasNormalCodedValueSet()) 12315 composeReference(t, "ObservationDefinition", "normalCodedValueSet", element.getNormalCodedValueSet(), -1); 12316 if (element.hasAbnormalCodedValueSet()) 12317 composeReference(t, "ObservationDefinition", "abnormalCodedValueSet", element.getAbnormalCodedValueSet(), -1); 12318 if (element.hasCriticalCodedValueSet()) 12319 composeReference(t, "ObservationDefinition", "criticalCodedValueSet", element.getCriticalCodedValueSet(), -1); 12320 } 12321 12322 protected void composeObservationDefinitionObservationDefinitionQuantitativeDetailsComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQuantitativeDetailsComponent element, int index) { 12323 if (element == null) 12324 return; 12325 Complex t; 12326 if (Utilities.noString(parentType)) 12327 t = parent; 12328 else { 12329 t = parent.predicate("fhir:"+parentType+'.'+name); 12330 } 12331 composeBackboneElement(t, "quantitativeDetails", name, element, index); 12332 if (element.hasCustomaryUnit()) 12333 composeCodeableConcept(t, "ObservationDefinition", "customaryUnit", element.getCustomaryUnit(), -1); 12334 if (element.hasUnit()) 12335 composeCodeableConcept(t, "ObservationDefinition", "unit", element.getUnit(), -1); 12336 if (element.hasConversionFactorElement()) 12337 composeDecimal(t, "ObservationDefinition", "conversionFactor", element.getConversionFactorElement(), -1); 12338 if (element.hasDecimalPrecisionElement()) 12339 composeInteger(t, "ObservationDefinition", "decimalPrecision", element.getDecimalPrecisionElement(), -1); 12340 } 12341 12342 protected void composeObservationDefinitionObservationDefinitionQualifiedIntervalComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQualifiedIntervalComponent element, int index) { 12343 if (element == null) 12344 return; 12345 Complex t; 12346 if (Utilities.noString(parentType)) 12347 t = parent; 12348 else { 12349 t = parent.predicate("fhir:"+parentType+'.'+name); 12350 } 12351 composeBackboneElement(t, "qualifiedInterval", name, element, index); 12352 if (element.hasCategoryElement()) 12353 composeEnum(t, "ObservationDefinition", "category", element.getCategoryElement(), -1); 12354 if (element.hasRange()) 12355 composeRange(t, "ObservationDefinition", "range", element.getRange(), -1); 12356 if (element.hasContext()) 12357 composeCodeableConcept(t, "ObservationDefinition", "context", element.getContext(), -1); 12358 for (int i = 0; i < element.getAppliesTo().size(); i++) 12359 composeCodeableConcept(t, "ObservationDefinition", "appliesTo", element.getAppliesTo().get(i), i); 12360 if (element.hasGenderElement()) 12361 composeEnum(t, "ObservationDefinition", "gender", element.getGenderElement(), -1); 12362 if (element.hasAge()) 12363 composeRange(t, "ObservationDefinition", "age", element.getAge(), -1); 12364 if (element.hasGestationalAge()) 12365 composeRange(t, "ObservationDefinition", "gestationalAge", element.getGestationalAge(), -1); 12366 if (element.hasConditionElement()) 12367 composeString(t, "ObservationDefinition", "condition", element.getConditionElement(), -1); 12368 } 12369 12370 protected void composeOperationDefinition(Complex parent, String parentType, String name, OperationDefinition element, int index) { 12371 if (element == null) 12372 return; 12373 Complex t; 12374 if (Utilities.noString(parentType)) 12375 t = parent; 12376 else { 12377 t = parent.predicate("fhir:"+parentType+'.'+name); 12378 } 12379 composeDomainResource(t, "OperationDefinition", name, element, index); 12380 if (element.hasUrlElement()) 12381 composeUri(t, "OperationDefinition", "url", element.getUrlElement(), -1); 12382 if (element.hasVersionElement()) 12383 composeString(t, "OperationDefinition", "version", element.getVersionElement(), -1); 12384 if (element.hasNameElement()) 12385 composeString(t, "OperationDefinition", "name", element.getNameElement(), -1); 12386 if (element.hasTitleElement()) 12387 composeString(t, "OperationDefinition", "title", element.getTitleElement(), -1); 12388 if (element.hasStatusElement()) 12389 composeEnum(t, "OperationDefinition", "status", element.getStatusElement(), -1); 12390 if (element.hasKindElement()) 12391 composeEnum(t, "OperationDefinition", "kind", element.getKindElement(), -1); 12392 if (element.hasExperimentalElement()) 12393 composeBoolean(t, "OperationDefinition", "experimental", element.getExperimentalElement(), -1); 12394 if (element.hasDateElement()) 12395 composeDateTime(t, "OperationDefinition", "date", element.getDateElement(), -1); 12396 if (element.hasPublisherElement()) 12397 composeString(t, "OperationDefinition", "publisher", element.getPublisherElement(), -1); 12398 for (int i = 0; i < element.getContact().size(); i++) 12399 composeContactDetail(t, "OperationDefinition", "contact", element.getContact().get(i), i); 12400 if (element.hasDescriptionElement()) 12401 composeMarkdown(t, "OperationDefinition", "description", element.getDescriptionElement(), -1); 12402 for (int i = 0; i < element.getUseContext().size(); i++) 12403 composeUsageContext(t, "OperationDefinition", "useContext", element.getUseContext().get(i), i); 12404 for (int i = 0; i < element.getJurisdiction().size(); i++) 12405 composeCodeableConcept(t, "OperationDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 12406 if (element.hasPurposeElement()) 12407 composeMarkdown(t, "OperationDefinition", "purpose", element.getPurposeElement(), -1); 12408 if (element.hasAffectsStateElement()) 12409 composeBoolean(t, "OperationDefinition", "affectsState", element.getAffectsStateElement(), -1); 12410 if (element.hasCodeElement()) 12411 composeCode(t, "OperationDefinition", "code", element.getCodeElement(), -1); 12412 if (element.hasCommentElement()) 12413 composeMarkdown(t, "OperationDefinition", "comment", element.getCommentElement(), -1); 12414 if (element.hasBaseElement()) 12415 composeCanonical(t, "OperationDefinition", "base", element.getBaseElement(), -1); 12416 for (int i = 0; i < element.getResource().size(); i++) 12417 composeCode(t, "OperationDefinition", "resource", element.getResource().get(i), i); 12418 if (element.hasSystemElement()) 12419 composeBoolean(t, "OperationDefinition", "system", element.getSystemElement(), -1); 12420 if (element.hasTypeElement()) 12421 composeBoolean(t, "OperationDefinition", "type", element.getTypeElement(), -1); 12422 if (element.hasInstanceElement()) 12423 composeBoolean(t, "OperationDefinition", "instance", element.getInstanceElement(), -1); 12424 if (element.hasInputProfileElement()) 12425 composeCanonical(t, "OperationDefinition", "inputProfile", element.getInputProfileElement(), -1); 12426 if (element.hasOutputProfileElement()) 12427 composeCanonical(t, "OperationDefinition", "outputProfile", element.getOutputProfileElement(), -1); 12428 for (int i = 0; i < element.getParameter().size(); i++) 12429 composeOperationDefinitionOperationDefinitionParameterComponent(t, "OperationDefinition", "parameter", element.getParameter().get(i), i); 12430 for (int i = 0; i < element.getOverload().size(); i++) 12431 composeOperationDefinitionOperationDefinitionOverloadComponent(t, "OperationDefinition", "overload", element.getOverload().get(i), i); 12432 } 12433 12434 protected void composeOperationDefinitionOperationDefinitionParameterComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterComponent element, int index) { 12435 if (element == null) 12436 return; 12437 Complex t; 12438 if (Utilities.noString(parentType)) 12439 t = parent; 12440 else { 12441 t = parent.predicate("fhir:"+parentType+'.'+name); 12442 } 12443 composeBackboneElement(t, "parameter", name, element, index); 12444 if (element.hasNameElement()) 12445 composeCode(t, "OperationDefinition", "name", element.getNameElement(), -1); 12446 if (element.hasUseElement()) 12447 composeEnum(t, "OperationDefinition", "use", element.getUseElement(), -1); 12448 if (element.hasMinElement()) 12449 composeInteger(t, "OperationDefinition", "min", element.getMinElement(), -1); 12450 if (element.hasMaxElement()) 12451 composeString(t, "OperationDefinition", "max", element.getMaxElement(), -1); 12452 if (element.hasDocumentationElement()) 12453 composeString(t, "OperationDefinition", "documentation", element.getDocumentationElement(), -1); 12454 if (element.hasTypeElement()) 12455 composeCode(t, "OperationDefinition", "type", element.getTypeElement(), -1); 12456 for (int i = 0; i < element.getTargetProfile().size(); i++) 12457 composeCanonical(t, "OperationDefinition", "targetProfile", element.getTargetProfile().get(i), i); 12458 if (element.hasSearchTypeElement()) 12459 composeEnum(t, "OperationDefinition", "searchType", element.getSearchTypeElement(), -1); 12460 if (element.hasBinding()) 12461 composeOperationDefinitionOperationDefinitionParameterBindingComponent(t, "OperationDefinition", "binding", element.getBinding(), -1); 12462 for (int i = 0; i < element.getReferencedFrom().size(); i++) 12463 composeOperationDefinitionOperationDefinitionParameterReferencedFromComponent(t, "OperationDefinition", "referencedFrom", element.getReferencedFrom().get(i), i); 12464 for (int i = 0; i < element.getPart().size(); i++) 12465 composeOperationDefinitionOperationDefinitionParameterComponent(t, "OperationDefinition", "part", element.getPart().get(i), i); 12466 } 12467 12468 protected void composeOperationDefinitionOperationDefinitionParameterBindingComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterBindingComponent element, int index) { 12469 if (element == null) 12470 return; 12471 Complex t; 12472 if (Utilities.noString(parentType)) 12473 t = parent; 12474 else { 12475 t = parent.predicate("fhir:"+parentType+'.'+name); 12476 } 12477 composeBackboneElement(t, "binding", name, element, index); 12478 if (element.hasStrengthElement()) 12479 composeEnum(t, "OperationDefinition", "strength", element.getStrengthElement(), -1); 12480 if (element.hasValueSetElement()) 12481 composeCanonical(t, "OperationDefinition", "valueSet", element.getValueSetElement(), -1); 12482 } 12483 12484 protected void composeOperationDefinitionOperationDefinitionParameterReferencedFromComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterReferencedFromComponent element, int index) { 12485 if (element == null) 12486 return; 12487 Complex t; 12488 if (Utilities.noString(parentType)) 12489 t = parent; 12490 else { 12491 t = parent.predicate("fhir:"+parentType+'.'+name); 12492 } 12493 composeBackboneElement(t, "referencedFrom", name, element, index); 12494 if (element.hasSourceElement()) 12495 composeString(t, "OperationDefinition", "source", element.getSourceElement(), -1); 12496 if (element.hasSourceIdElement()) 12497 composeString(t, "OperationDefinition", "sourceId", element.getSourceIdElement(), -1); 12498 } 12499 12500 protected void composeOperationDefinitionOperationDefinitionOverloadComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionOverloadComponent element, int index) { 12501 if (element == null) 12502 return; 12503 Complex t; 12504 if (Utilities.noString(parentType)) 12505 t = parent; 12506 else { 12507 t = parent.predicate("fhir:"+parentType+'.'+name); 12508 } 12509 composeBackboneElement(t, "overload", name, element, index); 12510 for (int i = 0; i < element.getParameterName().size(); i++) 12511 composeString(t, "OperationDefinition", "parameterName", element.getParameterName().get(i), i); 12512 if (element.hasCommentElement()) 12513 composeString(t, "OperationDefinition", "comment", element.getCommentElement(), -1); 12514 } 12515 12516 protected void composeOperationOutcome(Complex parent, String parentType, String name, OperationOutcome element, int index) { 12517 if (element == null) 12518 return; 12519 Complex t; 12520 if (Utilities.noString(parentType)) 12521 t = parent; 12522 else { 12523 t = parent.predicate("fhir:"+parentType+'.'+name); 12524 } 12525 composeDomainResource(t, "OperationOutcome", name, element, index); 12526 for (int i = 0; i < element.getIssue().size(); i++) 12527 composeOperationOutcomeOperationOutcomeIssueComponent(t, "OperationOutcome", "issue", element.getIssue().get(i), i); 12528 } 12529 12530 protected void composeOperationOutcomeOperationOutcomeIssueComponent(Complex parent, String parentType, String name, OperationOutcome.OperationOutcomeIssueComponent element, int index) { 12531 if (element == null) 12532 return; 12533 Complex t; 12534 if (Utilities.noString(parentType)) 12535 t = parent; 12536 else { 12537 t = parent.predicate("fhir:"+parentType+'.'+name); 12538 } 12539 composeBackboneElement(t, "issue", name, element, index); 12540 if (element.hasSeverityElement()) 12541 composeEnum(t, "OperationOutcome", "severity", element.getSeverityElement(), -1); 12542 if (element.hasCodeElement()) 12543 composeEnum(t, "OperationOutcome", "code", element.getCodeElement(), -1); 12544 if (element.hasDetails()) 12545 composeCodeableConcept(t, "OperationOutcome", "details", element.getDetails(), -1); 12546 if (element.hasDiagnosticsElement()) 12547 composeString(t, "OperationOutcome", "diagnostics", element.getDiagnosticsElement(), -1); 12548 for (int i = 0; i < element.getLocation().size(); i++) 12549 composeString(t, "OperationOutcome", "location", element.getLocation().get(i), i); 12550 for (int i = 0; i < element.getExpression().size(); i++) 12551 composeString(t, "OperationOutcome", "expression", element.getExpression().get(i), i); 12552 } 12553 12554 protected void composeOrganization(Complex parent, String parentType, String name, Organization element, int index) { 12555 if (element == null) 12556 return; 12557 Complex t; 12558 if (Utilities.noString(parentType)) 12559 t = parent; 12560 else { 12561 t = parent.predicate("fhir:"+parentType+'.'+name); 12562 } 12563 composeDomainResource(t, "Organization", name, element, index); 12564 for (int i = 0; i < element.getIdentifier().size(); i++) 12565 composeIdentifier(t, "Organization", "identifier", element.getIdentifier().get(i), i); 12566 if (element.hasActiveElement()) 12567 composeBoolean(t, "Organization", "active", element.getActiveElement(), -1); 12568 for (int i = 0; i < element.getType().size(); i++) 12569 composeCodeableConcept(t, "Organization", "type", element.getType().get(i), i); 12570 if (element.hasNameElement()) 12571 composeString(t, "Organization", "name", element.getNameElement(), -1); 12572 for (int i = 0; i < element.getAlias().size(); i++) 12573 composeString(t, "Organization", "alias", element.getAlias().get(i), i); 12574 for (int i = 0; i < element.getTelecom().size(); i++) 12575 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 12576 for (int i = 0; i < element.getAddress().size(); i++) 12577 composeAddress(t, "Organization", "address", element.getAddress().get(i), i); 12578 if (element.hasPartOf()) 12579 composeReference(t, "Organization", "partOf", element.getPartOf(), -1); 12580 for (int i = 0; i < element.getContact().size(); i++) 12581 composeOrganizationOrganizationContactComponent(t, "Organization", "contact", element.getContact().get(i), i); 12582 for (int i = 0; i < element.getEndpoint().size(); i++) 12583 composeReference(t, "Organization", "endpoint", element.getEndpoint().get(i), i); 12584 } 12585 12586 protected void composeOrganizationOrganizationContactComponent(Complex parent, String parentType, String name, Organization.OrganizationContactComponent element, int index) { 12587 if (element == null) 12588 return; 12589 Complex t; 12590 if (Utilities.noString(parentType)) 12591 t = parent; 12592 else { 12593 t = parent.predicate("fhir:"+parentType+'.'+name); 12594 } 12595 composeBackboneElement(t, "contact", name, element, index); 12596 if (element.hasPurpose()) 12597 composeCodeableConcept(t, "Organization", "purpose", element.getPurpose(), -1); 12598 if (element.hasName()) 12599 composeHumanName(t, "Organization", "name", element.getName(), -1); 12600 for (int i = 0; i < element.getTelecom().size(); i++) 12601 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 12602 if (element.hasAddress()) 12603 composeAddress(t, "Organization", "address", element.getAddress(), -1); 12604 } 12605 12606 protected void composeOrganizationAffiliation(Complex parent, String parentType, String name, OrganizationAffiliation element, int index) { 12607 if (element == null) 12608 return; 12609 Complex t; 12610 if (Utilities.noString(parentType)) 12611 t = parent; 12612 else { 12613 t = parent.predicate("fhir:"+parentType+'.'+name); 12614 } 12615 composeDomainResource(t, "OrganizationAffiliation", name, element, index); 12616 for (int i = 0; i < element.getIdentifier().size(); i++) 12617 composeIdentifier(t, "OrganizationAffiliation", "identifier", element.getIdentifier().get(i), i); 12618 if (element.hasActiveElement()) 12619 composeBoolean(t, "OrganizationAffiliation", "active", element.getActiveElement(), -1); 12620 if (element.hasPeriod()) 12621 composePeriod(t, "OrganizationAffiliation", "period", element.getPeriod(), -1); 12622 if (element.hasOrganization()) 12623 composeReference(t, "OrganizationAffiliation", "organization", element.getOrganization(), -1); 12624 if (element.hasParticipatingOrganization()) 12625 composeReference(t, "OrganizationAffiliation", "participatingOrganization", element.getParticipatingOrganization(), -1); 12626 for (int i = 0; i < element.getNetwork().size(); i++) 12627 composeReference(t, "OrganizationAffiliation", "network", element.getNetwork().get(i), i); 12628 for (int i = 0; i < element.getCode().size(); i++) 12629 composeCodeableConcept(t, "OrganizationAffiliation", "code", element.getCode().get(i), i); 12630 for (int i = 0; i < element.getSpecialty().size(); i++) 12631 composeCodeableConcept(t, "OrganizationAffiliation", "specialty", element.getSpecialty().get(i), i); 12632 for (int i = 0; i < element.getLocation().size(); i++) 12633 composeReference(t, "OrganizationAffiliation", "location", element.getLocation().get(i), i); 12634 for (int i = 0; i < element.getHealthcareService().size(); i++) 12635 composeReference(t, "OrganizationAffiliation", "healthcareService", element.getHealthcareService().get(i), i); 12636 for (int i = 0; i < element.getTelecom().size(); i++) 12637 composeContactPoint(t, "OrganizationAffiliation", "telecom", element.getTelecom().get(i), i); 12638 for (int i = 0; i < element.getEndpoint().size(); i++) 12639 composeReference(t, "OrganizationAffiliation", "endpoint", element.getEndpoint().get(i), i); 12640 } 12641 12642 protected void composePatient(Complex parent, String parentType, String name, Patient element, int index) { 12643 if (element == null) 12644 return; 12645 Complex t; 12646 if (Utilities.noString(parentType)) 12647 t = parent; 12648 else { 12649 t = parent.predicate("fhir:"+parentType+'.'+name); 12650 } 12651 composeDomainResource(t, "Patient", name, element, index); 12652 for (int i = 0; i < element.getIdentifier().size(); i++) 12653 composeIdentifier(t, "Patient", "identifier", element.getIdentifier().get(i), i); 12654 if (element.hasActiveElement()) 12655 composeBoolean(t, "Patient", "active", element.getActiveElement(), -1); 12656 for (int i = 0; i < element.getName().size(); i++) 12657 composeHumanName(t, "Patient", "name", element.getName().get(i), i); 12658 for (int i = 0; i < element.getTelecom().size(); i++) 12659 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 12660 if (element.hasGenderElement()) 12661 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 12662 if (element.hasBirthDateElement()) 12663 composeDate(t, "Patient", "birthDate", element.getBirthDateElement(), -1); 12664 if (element.hasDeceased()) 12665 composeType(t, "Patient", "deceased", element.getDeceased(), -1); 12666 for (int i = 0; i < element.getAddress().size(); i++) 12667 composeAddress(t, "Patient", "address", element.getAddress().get(i), i); 12668 if (element.hasMaritalStatus()) 12669 composeCodeableConcept(t, "Patient", "maritalStatus", element.getMaritalStatus(), -1); 12670 if (element.hasMultipleBirth()) 12671 composeType(t, "Patient", "multipleBirth", element.getMultipleBirth(), -1); 12672 for (int i = 0; i < element.getPhoto().size(); i++) 12673 composeAttachment(t, "Patient", "photo", element.getPhoto().get(i), i); 12674 for (int i = 0; i < element.getContact().size(); i++) 12675 composePatientContactComponent(t, "Patient", "contact", element.getContact().get(i), i); 12676 for (int i = 0; i < element.getCommunication().size(); i++) 12677 composePatientPatientCommunicationComponent(t, "Patient", "communication", element.getCommunication().get(i), i); 12678 for (int i = 0; i < element.getGeneralPractitioner().size(); i++) 12679 composeReference(t, "Patient", "generalPractitioner", element.getGeneralPractitioner().get(i), i); 12680 if (element.hasManagingOrganization()) 12681 composeReference(t, "Patient", "managingOrganization", element.getManagingOrganization(), -1); 12682 for (int i = 0; i < element.getLink().size(); i++) 12683 composePatientPatientLinkComponent(t, "Patient", "link", element.getLink().get(i), i); 12684 } 12685 12686 protected void composePatientContactComponent(Complex parent, String parentType, String name, Patient.ContactComponent element, int index) { 12687 if (element == null) 12688 return; 12689 Complex t; 12690 if (Utilities.noString(parentType)) 12691 t = parent; 12692 else { 12693 t = parent.predicate("fhir:"+parentType+'.'+name); 12694 } 12695 composeBackboneElement(t, "contact", name, element, index); 12696 for (int i = 0; i < element.getRelationship().size(); i++) 12697 composeCodeableConcept(t, "Patient", "relationship", element.getRelationship().get(i), i); 12698 if (element.hasName()) 12699 composeHumanName(t, "Patient", "name", element.getName(), -1); 12700 for (int i = 0; i < element.getTelecom().size(); i++) 12701 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 12702 if (element.hasAddress()) 12703 composeAddress(t, "Patient", "address", element.getAddress(), -1); 12704 if (element.hasGenderElement()) 12705 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 12706 if (element.hasOrganization()) 12707 composeReference(t, "Patient", "organization", element.getOrganization(), -1); 12708 if (element.hasPeriod()) 12709 composePeriod(t, "Patient", "period", element.getPeriod(), -1); 12710 } 12711 12712 protected void composePatientPatientCommunicationComponent(Complex parent, String parentType, String name, Patient.PatientCommunicationComponent element, int index) { 12713 if (element == null) 12714 return; 12715 Complex t; 12716 if (Utilities.noString(parentType)) 12717 t = parent; 12718 else { 12719 t = parent.predicate("fhir:"+parentType+'.'+name); 12720 } 12721 composeBackboneElement(t, "communication", name, element, index); 12722 if (element.hasLanguage()) 12723 composeCodeableConcept(t, "Patient", "language", element.getLanguage(), -1); 12724 if (element.hasPreferredElement()) 12725 composeBoolean(t, "Patient", "preferred", element.getPreferredElement(), -1); 12726 } 12727 12728 protected void composePatientPatientLinkComponent(Complex parent, String parentType, String name, Patient.PatientLinkComponent element, int index) { 12729 if (element == null) 12730 return; 12731 Complex t; 12732 if (Utilities.noString(parentType)) 12733 t = parent; 12734 else { 12735 t = parent.predicate("fhir:"+parentType+'.'+name); 12736 } 12737 composeBackboneElement(t, "link", name, element, index); 12738 if (element.hasOther()) 12739 composeReference(t, "Patient", "other", element.getOther(), -1); 12740 if (element.hasTypeElement()) 12741 composeEnum(t, "Patient", "type", element.getTypeElement(), -1); 12742 } 12743 12744 protected void composePaymentNotice(Complex parent, String parentType, String name, PaymentNotice element, int index) { 12745 if (element == null) 12746 return; 12747 Complex t; 12748 if (Utilities.noString(parentType)) 12749 t = parent; 12750 else { 12751 t = parent.predicate("fhir:"+parentType+'.'+name); 12752 } 12753 composeDomainResource(t, "PaymentNotice", name, element, index); 12754 for (int i = 0; i < element.getIdentifier().size(); i++) 12755 composeIdentifier(t, "PaymentNotice", "identifier", element.getIdentifier().get(i), i); 12756 if (element.hasStatusElement()) 12757 composeEnum(t, "PaymentNotice", "status", element.getStatusElement(), -1); 12758 if (element.hasRequest()) 12759 composeReference(t, "PaymentNotice", "request", element.getRequest(), -1); 12760 if (element.hasResponse()) 12761 composeReference(t, "PaymentNotice", "response", element.getResponse(), -1); 12762 if (element.hasCreatedElement()) 12763 composeDateTime(t, "PaymentNotice", "created", element.getCreatedElement(), -1); 12764 if (element.hasProvider()) 12765 composeReference(t, "PaymentNotice", "provider", element.getProvider(), -1); 12766 if (element.hasPayment()) 12767 composeReference(t, "PaymentNotice", "payment", element.getPayment(), -1); 12768 if (element.hasPaymentDateElement()) 12769 composeDate(t, "PaymentNotice", "paymentDate", element.getPaymentDateElement(), -1); 12770 if (element.hasPayee()) 12771 composeReference(t, "PaymentNotice", "payee", element.getPayee(), -1); 12772 if (element.hasRecipient()) 12773 composeReference(t, "PaymentNotice", "recipient", element.getRecipient(), -1); 12774 if (element.hasAmount()) 12775 composeMoney(t, "PaymentNotice", "amount", element.getAmount(), -1); 12776 if (element.hasPaymentStatus()) 12777 composeCodeableConcept(t, "PaymentNotice", "paymentStatus", element.getPaymentStatus(), -1); 12778 } 12779 12780 protected void composePaymentReconciliation(Complex parent, String parentType, String name, PaymentReconciliation element, int index) { 12781 if (element == null) 12782 return; 12783 Complex t; 12784 if (Utilities.noString(parentType)) 12785 t = parent; 12786 else { 12787 t = parent.predicate("fhir:"+parentType+'.'+name); 12788 } 12789 composeDomainResource(t, "PaymentReconciliation", name, element, index); 12790 for (int i = 0; i < element.getIdentifier().size(); i++) 12791 composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier().get(i), i); 12792 if (element.hasStatusElement()) 12793 composeEnum(t, "PaymentReconciliation", "status", element.getStatusElement(), -1); 12794 if (element.hasPeriod()) 12795 composePeriod(t, "PaymentReconciliation", "period", element.getPeriod(), -1); 12796 if (element.hasCreatedElement()) 12797 composeDateTime(t, "PaymentReconciliation", "created", element.getCreatedElement(), -1); 12798 if (element.hasPaymentIssuer()) 12799 composeReference(t, "PaymentReconciliation", "paymentIssuer", element.getPaymentIssuer(), -1); 12800 if (element.hasRequest()) 12801 composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1); 12802 if (element.hasRequestor()) 12803 composeReference(t, "PaymentReconciliation", "requestor", element.getRequestor(), -1); 12804 if (element.hasOutcomeElement()) 12805 composeEnum(t, "PaymentReconciliation", "outcome", element.getOutcomeElement(), -1); 12806 if (element.hasDispositionElement()) 12807 composeString(t, "PaymentReconciliation", "disposition", element.getDispositionElement(), -1); 12808 if (element.hasPaymentDateElement()) 12809 composeDate(t, "PaymentReconciliation", "paymentDate", element.getPaymentDateElement(), -1); 12810 if (element.hasPaymentAmount()) 12811 composeMoney(t, "PaymentReconciliation", "paymentAmount", element.getPaymentAmount(), -1); 12812 if (element.hasPaymentIdentifier()) 12813 composeIdentifier(t, "PaymentReconciliation", "paymentIdentifier", element.getPaymentIdentifier(), -1); 12814 for (int i = 0; i < element.getDetail().size(); i++) 12815 composePaymentReconciliationDetailsComponent(t, "PaymentReconciliation", "detail", element.getDetail().get(i), i); 12816 if (element.hasFormCode()) 12817 composeCodeableConcept(t, "PaymentReconciliation", "formCode", element.getFormCode(), -1); 12818 for (int i = 0; i < element.getProcessNote().size(); i++) 12819 composePaymentReconciliationNotesComponent(t, "PaymentReconciliation", "processNote", element.getProcessNote().get(i), i); 12820 } 12821 12822 protected void composePaymentReconciliationDetailsComponent(Complex parent, String parentType, String name, PaymentReconciliation.DetailsComponent element, int index) { 12823 if (element == null) 12824 return; 12825 Complex t; 12826 if (Utilities.noString(parentType)) 12827 t = parent; 12828 else { 12829 t = parent.predicate("fhir:"+parentType+'.'+name); 12830 } 12831 composeBackboneElement(t, "detail", name, element, index); 12832 if (element.hasIdentifier()) 12833 composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier(), -1); 12834 if (element.hasPredecessor()) 12835 composeIdentifier(t, "PaymentReconciliation", "predecessor", element.getPredecessor(), -1); 12836 if (element.hasType()) 12837 composeCodeableConcept(t, "PaymentReconciliation", "type", element.getType(), -1); 12838 if (element.hasRequest()) 12839 composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1); 12840 if (element.hasSubmitter()) 12841 composeReference(t, "PaymentReconciliation", "submitter", element.getSubmitter(), -1); 12842 if (element.hasResponse()) 12843 composeReference(t, "PaymentReconciliation", "response", element.getResponse(), -1); 12844 if (element.hasDateElement()) 12845 composeDate(t, "PaymentReconciliation", "date", element.getDateElement(), -1); 12846 if (element.hasResponsible()) 12847 composeReference(t, "PaymentReconciliation", "responsible", element.getResponsible(), -1); 12848 if (element.hasPayee()) 12849 composeReference(t, "PaymentReconciliation", "payee", element.getPayee(), -1); 12850 if (element.hasAmount()) 12851 composeMoney(t, "PaymentReconciliation", "amount", element.getAmount(), -1); 12852 } 12853 12854 protected void composePaymentReconciliationNotesComponent(Complex parent, String parentType, String name, PaymentReconciliation.NotesComponent element, int index) { 12855 if (element == null) 12856 return; 12857 Complex t; 12858 if (Utilities.noString(parentType)) 12859 t = parent; 12860 else { 12861 t = parent.predicate("fhir:"+parentType+'.'+name); 12862 } 12863 composeBackboneElement(t, "processNote", name, element, index); 12864 if (element.hasTypeElement()) 12865 composeEnum(t, "PaymentReconciliation", "type", element.getTypeElement(), -1); 12866 if (element.hasTextElement()) 12867 composeString(t, "PaymentReconciliation", "text", element.getTextElement(), -1); 12868 } 12869 12870 protected void composePerson(Complex parent, String parentType, String name, Person element, int index) { 12871 if (element == null) 12872 return; 12873 Complex t; 12874 if (Utilities.noString(parentType)) 12875 t = parent; 12876 else { 12877 t = parent.predicate("fhir:"+parentType+'.'+name); 12878 } 12879 composeDomainResource(t, "Person", name, element, index); 12880 for (int i = 0; i < element.getIdentifier().size(); i++) 12881 composeIdentifier(t, "Person", "identifier", element.getIdentifier().get(i), i); 12882 for (int i = 0; i < element.getName().size(); i++) 12883 composeHumanName(t, "Person", "name", element.getName().get(i), i); 12884 for (int i = 0; i < element.getTelecom().size(); i++) 12885 composeContactPoint(t, "Person", "telecom", element.getTelecom().get(i), i); 12886 if (element.hasGenderElement()) 12887 composeEnum(t, "Person", "gender", element.getGenderElement(), -1); 12888 if (element.hasBirthDateElement()) 12889 composeDate(t, "Person", "birthDate", element.getBirthDateElement(), -1); 12890 for (int i = 0; i < element.getAddress().size(); i++) 12891 composeAddress(t, "Person", "address", element.getAddress().get(i), i); 12892 if (element.hasPhoto()) 12893 composeAttachment(t, "Person", "photo", element.getPhoto(), -1); 12894 if (element.hasManagingOrganization()) 12895 composeReference(t, "Person", "managingOrganization", element.getManagingOrganization(), -1); 12896 if (element.hasActiveElement()) 12897 composeBoolean(t, "Person", "active", element.getActiveElement(), -1); 12898 for (int i = 0; i < element.getLink().size(); i++) 12899 composePersonPersonLinkComponent(t, "Person", "link", element.getLink().get(i), i); 12900 } 12901 12902 protected void composePersonPersonLinkComponent(Complex parent, String parentType, String name, Person.PersonLinkComponent element, int index) { 12903 if (element == null) 12904 return; 12905 Complex t; 12906 if (Utilities.noString(parentType)) 12907 t = parent; 12908 else { 12909 t = parent.predicate("fhir:"+parentType+'.'+name); 12910 } 12911 composeBackboneElement(t, "link", name, element, index); 12912 if (element.hasTarget()) 12913 composeReference(t, "Person", "target", element.getTarget(), -1); 12914 if (element.hasAssuranceElement()) 12915 composeEnum(t, "Person", "assurance", element.getAssuranceElement(), -1); 12916 } 12917 12918 protected void composePlanDefinition(Complex parent, String parentType, String name, PlanDefinition element, int index) { 12919 if (element == null) 12920 return; 12921 Complex t; 12922 if (Utilities.noString(parentType)) 12923 t = parent; 12924 else { 12925 t = parent.predicate("fhir:"+parentType+'.'+name); 12926 } 12927 composeDomainResource(t, "PlanDefinition", name, element, index); 12928 if (element.hasUrlElement()) 12929 composeUri(t, "PlanDefinition", "url", element.getUrlElement(), -1); 12930 for (int i = 0; i < element.getIdentifier().size(); i++) 12931 composeIdentifier(t, "PlanDefinition", "identifier", element.getIdentifier().get(i), i); 12932 if (element.hasVersionElement()) 12933 composeString(t, "PlanDefinition", "version", element.getVersionElement(), -1); 12934 if (element.hasNameElement()) 12935 composeString(t, "PlanDefinition", "name", element.getNameElement(), -1); 12936 if (element.hasTitleElement()) 12937 composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1); 12938 if (element.hasSubtitleElement()) 12939 composeString(t, "PlanDefinition", "subtitle", element.getSubtitleElement(), -1); 12940 if (element.hasType()) 12941 composeCodeableConcept(t, "PlanDefinition", "type", element.getType(), -1); 12942 if (element.hasStatusElement()) 12943 composeEnum(t, "PlanDefinition", "status", element.getStatusElement(), -1); 12944 if (element.hasExperimentalElement()) 12945 composeBoolean(t, "PlanDefinition", "experimental", element.getExperimentalElement(), -1); 12946 if (element.hasSubject()) 12947 composeType(t, "PlanDefinition", "subject", element.getSubject(), -1); 12948 if (element.hasDateElement()) 12949 composeDateTime(t, "PlanDefinition", "date", element.getDateElement(), -1); 12950 if (element.hasPublisherElement()) 12951 composeString(t, "PlanDefinition", "publisher", element.getPublisherElement(), -1); 12952 for (int i = 0; i < element.getContact().size(); i++) 12953 composeContactDetail(t, "PlanDefinition", "contact", element.getContact().get(i), i); 12954 if (element.hasDescriptionElement()) 12955 composeMarkdown(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 12956 for (int i = 0; i < element.getUseContext().size(); i++) 12957 composeUsageContext(t, "PlanDefinition", "useContext", element.getUseContext().get(i), i); 12958 for (int i = 0; i < element.getJurisdiction().size(); i++) 12959 composeCodeableConcept(t, "PlanDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 12960 if (element.hasPurposeElement()) 12961 composeMarkdown(t, "PlanDefinition", "purpose", element.getPurposeElement(), -1); 12962 if (element.hasUsageElement()) 12963 composeString(t, "PlanDefinition", "usage", element.getUsageElement(), -1); 12964 if (element.hasCopyrightElement()) 12965 composeMarkdown(t, "PlanDefinition", "copyright", element.getCopyrightElement(), -1); 12966 if (element.hasApprovalDateElement()) 12967 composeDate(t, "PlanDefinition", "approvalDate", element.getApprovalDateElement(), -1); 12968 if (element.hasLastReviewDateElement()) 12969 composeDate(t, "PlanDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 12970 if (element.hasEffectivePeriod()) 12971 composePeriod(t, "PlanDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 12972 for (int i = 0; i < element.getTopic().size(); i++) 12973 composeCodeableConcept(t, "PlanDefinition", "topic", element.getTopic().get(i), i); 12974 for (int i = 0; i < element.getAuthor().size(); i++) 12975 composeContactDetail(t, "PlanDefinition", "author", element.getAuthor().get(i), i); 12976 for (int i = 0; i < element.getEditor().size(); i++) 12977 composeContactDetail(t, "PlanDefinition", "editor", element.getEditor().get(i), i); 12978 for (int i = 0; i < element.getReviewer().size(); i++) 12979 composeContactDetail(t, "PlanDefinition", "reviewer", element.getReviewer().get(i), i); 12980 for (int i = 0; i < element.getEndorser().size(); i++) 12981 composeContactDetail(t, "PlanDefinition", "endorser", element.getEndorser().get(i), i); 12982 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 12983 composeRelatedArtifact(t, "PlanDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 12984 for (int i = 0; i < element.getLibrary().size(); i++) 12985 composeCanonical(t, "PlanDefinition", "library", element.getLibrary().get(i), i); 12986 for (int i = 0; i < element.getGoal().size(); i++) 12987 composePlanDefinitionPlanDefinitionGoalComponent(t, "PlanDefinition", "goal", element.getGoal().get(i), i); 12988 for (int i = 0; i < element.getAction().size(); i++) 12989 composePlanDefinitionPlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i); 12990 } 12991 12992 protected void composePlanDefinitionPlanDefinitionGoalComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalComponent element, int index) { 12993 if (element == null) 12994 return; 12995 Complex t; 12996 if (Utilities.noString(parentType)) 12997 t = parent; 12998 else { 12999 t = parent.predicate("fhir:"+parentType+'.'+name); 13000 } 13001 composeBackboneElement(t, "goal", name, element, index); 13002 if (element.hasCategory()) 13003 composeCodeableConcept(t, "PlanDefinition", "category", element.getCategory(), -1); 13004 if (element.hasDescription()) 13005 composeCodeableConcept(t, "PlanDefinition", "description", element.getDescription(), -1); 13006 if (element.hasPriority()) 13007 composeCodeableConcept(t, "PlanDefinition", "priority", element.getPriority(), -1); 13008 if (element.hasStart()) 13009 composeCodeableConcept(t, "PlanDefinition", "start", element.getStart(), -1); 13010 for (int i = 0; i < element.getAddresses().size(); i++) 13011 composeCodeableConcept(t, "PlanDefinition", "addresses", element.getAddresses().get(i), i); 13012 for (int i = 0; i < element.getDocumentation().size(); i++) 13013 composeRelatedArtifact(t, "PlanDefinition", "documentation", element.getDocumentation().get(i), i); 13014 for (int i = 0; i < element.getTarget().size(); i++) 13015 composePlanDefinitionPlanDefinitionGoalTargetComponent(t, "PlanDefinition", "target", element.getTarget().get(i), i); 13016 } 13017 13018 protected void composePlanDefinitionPlanDefinitionGoalTargetComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalTargetComponent element, int index) { 13019 if (element == null) 13020 return; 13021 Complex t; 13022 if (Utilities.noString(parentType)) 13023 t = parent; 13024 else { 13025 t = parent.predicate("fhir:"+parentType+'.'+name); 13026 } 13027 composeBackboneElement(t, "target", name, element, index); 13028 if (element.hasMeasure()) 13029 composeCodeableConcept(t, "PlanDefinition", "measure", element.getMeasure(), -1); 13030 if (element.hasDetail()) 13031 composeType(t, "PlanDefinition", "detail", element.getDetail(), -1); 13032 if (element.hasDue()) 13033 composeDuration(t, "PlanDefinition", "due", element.getDue(), -1); 13034 } 13035 13036 protected void composePlanDefinitionPlanDefinitionActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionComponent element, int index) { 13037 if (element == null) 13038 return; 13039 Complex t; 13040 if (Utilities.noString(parentType)) 13041 t = parent; 13042 else { 13043 t = parent.predicate("fhir:"+parentType+'.'+name); 13044 } 13045 composeBackboneElement(t, "action", name, element, index); 13046 if (element.hasPrefixElement()) 13047 composeString(t, "PlanDefinition", "prefix", element.getPrefixElement(), -1); 13048 if (element.hasTitleElement()) 13049 composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1); 13050 if (element.hasDescriptionElement()) 13051 composeString(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 13052 if (element.hasTextEquivalentElement()) 13053 composeString(t, "PlanDefinition", "textEquivalent", element.getTextEquivalentElement(), -1); 13054 if (element.hasPriorityElement()) 13055 composeEnum(t, "PlanDefinition", "priority", element.getPriorityElement(), -1); 13056 for (int i = 0; i < element.getCode().size(); i++) 13057 composeCodeableConcept(t, "PlanDefinition", "code", element.getCode().get(i), i); 13058 for (int i = 0; i < element.getReason().size(); i++) 13059 composeCodeableConcept(t, "PlanDefinition", "reason", element.getReason().get(i), i); 13060 for (int i = 0; i < element.getDocumentation().size(); i++) 13061 composeRelatedArtifact(t, "PlanDefinition", "documentation", element.getDocumentation().get(i), i); 13062 for (int i = 0; i < element.getGoalId().size(); i++) 13063 composeId(t, "PlanDefinition", "goalId", element.getGoalId().get(i), i); 13064 if (element.hasSubject()) 13065 composeType(t, "PlanDefinition", "subject", element.getSubject(), -1); 13066 for (int i = 0; i < element.getTrigger().size(); i++) 13067 composeTriggerDefinition(t, "PlanDefinition", "trigger", element.getTrigger().get(i), i); 13068 for (int i = 0; i < element.getCondition().size(); i++) 13069 composePlanDefinitionPlanDefinitionActionConditionComponent(t, "PlanDefinition", "condition", element.getCondition().get(i), i); 13070 for (int i = 0; i < element.getInput().size(); i++) 13071 composeDataRequirement(t, "PlanDefinition", "input", element.getInput().get(i), i); 13072 for (int i = 0; i < element.getOutput().size(); i++) 13073 composeDataRequirement(t, "PlanDefinition", "output", element.getOutput().get(i), i); 13074 for (int i = 0; i < element.getRelatedAction().size(); i++) 13075 composePlanDefinitionPlanDefinitionActionRelatedActionComponent(t, "PlanDefinition", "relatedAction", element.getRelatedAction().get(i), i); 13076 if (element.hasTiming()) 13077 composeType(t, "PlanDefinition", "timing", element.getTiming(), -1); 13078 for (int i = 0; i < element.getParticipant().size(); i++) 13079 composePlanDefinitionPlanDefinitionActionParticipantComponent(t, "PlanDefinition", "participant", element.getParticipant().get(i), i); 13080 if (element.hasType()) 13081 composeCodeableConcept(t, "PlanDefinition", "type", element.getType(), -1); 13082 if (element.hasGroupingBehaviorElement()) 13083 composeEnum(t, "PlanDefinition", "groupingBehavior", element.getGroupingBehaviorElement(), -1); 13084 if (element.hasSelectionBehaviorElement()) 13085 composeEnum(t, "PlanDefinition", "selectionBehavior", element.getSelectionBehaviorElement(), -1); 13086 if (element.hasRequiredBehaviorElement()) 13087 composeEnum(t, "PlanDefinition", "requiredBehavior", element.getRequiredBehaviorElement(), -1); 13088 if (element.hasPrecheckBehaviorElement()) 13089 composeEnum(t, "PlanDefinition", "precheckBehavior", element.getPrecheckBehaviorElement(), -1); 13090 if (element.hasCardinalityBehaviorElement()) 13091 composeEnum(t, "PlanDefinition", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1); 13092 if (element.hasDefinition()) 13093 composeType(t, "PlanDefinition", "definition", element.getDefinition(), -1); 13094 if (element.hasTransformElement()) 13095 composeCanonical(t, "PlanDefinition", "transform", element.getTransformElement(), -1); 13096 for (int i = 0; i < element.getDynamicValue().size(); i++) 13097 composePlanDefinitionPlanDefinitionActionDynamicValueComponent(t, "PlanDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 13098 for (int i = 0; i < element.getAction().size(); i++) 13099 composePlanDefinitionPlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i); 13100 } 13101 13102 protected void composePlanDefinitionPlanDefinitionActionConditionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionConditionComponent element, int index) { 13103 if (element == null) 13104 return; 13105 Complex t; 13106 if (Utilities.noString(parentType)) 13107 t = parent; 13108 else { 13109 t = parent.predicate("fhir:"+parentType+'.'+name); 13110 } 13111 composeBackboneElement(t, "condition", name, element, index); 13112 if (element.hasKindElement()) 13113 composeEnum(t, "PlanDefinition", "kind", element.getKindElement(), -1); 13114 if (element.hasExpression()) 13115 composeExpression(t, "PlanDefinition", "expression", element.getExpression(), -1); 13116 } 13117 13118 protected void composePlanDefinitionPlanDefinitionActionRelatedActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionRelatedActionComponent element, int index) { 13119 if (element == null) 13120 return; 13121 Complex t; 13122 if (Utilities.noString(parentType)) 13123 t = parent; 13124 else { 13125 t = parent.predicate("fhir:"+parentType+'.'+name); 13126 } 13127 composeBackboneElement(t, "relatedAction", name, element, index); 13128 if (element.hasActionIdElement()) 13129 composeId(t, "PlanDefinition", "actionId", element.getActionIdElement(), -1); 13130 if (element.hasRelationshipElement()) 13131 composeEnum(t, "PlanDefinition", "relationship", element.getRelationshipElement(), -1); 13132 if (element.hasOffset()) 13133 composeType(t, "PlanDefinition", "offset", element.getOffset(), -1); 13134 } 13135 13136 protected void composePlanDefinitionPlanDefinitionActionParticipantComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionParticipantComponent element, int index) { 13137 if (element == null) 13138 return; 13139 Complex t; 13140 if (Utilities.noString(parentType)) 13141 t = parent; 13142 else { 13143 t = parent.predicate("fhir:"+parentType+'.'+name); 13144 } 13145 composeBackboneElement(t, "participant", name, element, index); 13146 if (element.hasTypeElement()) 13147 composeEnum(t, "PlanDefinition", "type", element.getTypeElement(), -1); 13148 if (element.hasRole()) 13149 composeCodeableConcept(t, "PlanDefinition", "role", element.getRole(), -1); 13150 } 13151 13152 protected void composePlanDefinitionPlanDefinitionActionDynamicValueComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionDynamicValueComponent element, int index) { 13153 if (element == null) 13154 return; 13155 Complex t; 13156 if (Utilities.noString(parentType)) 13157 t = parent; 13158 else { 13159 t = parent.predicate("fhir:"+parentType+'.'+name); 13160 } 13161 composeBackboneElement(t, "dynamicValue", name, element, index); 13162 if (element.hasPathElement()) 13163 composeString(t, "PlanDefinition", "path", element.getPathElement(), -1); 13164 if (element.hasExpression()) 13165 composeExpression(t, "PlanDefinition", "expression", element.getExpression(), -1); 13166 } 13167 13168 protected void composePractitioner(Complex parent, String parentType, String name, Practitioner element, int index) { 13169 if (element == null) 13170 return; 13171 Complex t; 13172 if (Utilities.noString(parentType)) 13173 t = parent; 13174 else { 13175 t = parent.predicate("fhir:"+parentType+'.'+name); 13176 } 13177 composeDomainResource(t, "Practitioner", name, element, index); 13178 for (int i = 0; i < element.getIdentifier().size(); i++) 13179 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 13180 if (element.hasActiveElement()) 13181 composeBoolean(t, "Practitioner", "active", element.getActiveElement(), -1); 13182 for (int i = 0; i < element.getName().size(); i++) 13183 composeHumanName(t, "Practitioner", "name", element.getName().get(i), i); 13184 for (int i = 0; i < element.getTelecom().size(); i++) 13185 composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i); 13186 for (int i = 0; i < element.getAddress().size(); i++) 13187 composeAddress(t, "Practitioner", "address", element.getAddress().get(i), i); 13188 if (element.hasGenderElement()) 13189 composeEnum(t, "Practitioner", "gender", element.getGenderElement(), -1); 13190 if (element.hasBirthDateElement()) 13191 composeDate(t, "Practitioner", "birthDate", element.getBirthDateElement(), -1); 13192 for (int i = 0; i < element.getPhoto().size(); i++) 13193 composeAttachment(t, "Practitioner", "photo", element.getPhoto().get(i), i); 13194 for (int i = 0; i < element.getQualification().size(); i++) 13195 composePractitionerPractitionerQualificationComponent(t, "Practitioner", "qualification", element.getQualification().get(i), i); 13196 for (int i = 0; i < element.getCommunication().size(); i++) 13197 composeCodeableConcept(t, "Practitioner", "communication", element.getCommunication().get(i), i); 13198 } 13199 13200 protected void composePractitionerPractitionerQualificationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerQualificationComponent element, int index) { 13201 if (element == null) 13202 return; 13203 Complex t; 13204 if (Utilities.noString(parentType)) 13205 t = parent; 13206 else { 13207 t = parent.predicate("fhir:"+parentType+'.'+name); 13208 } 13209 composeBackboneElement(t, "qualification", name, element, index); 13210 for (int i = 0; i < element.getIdentifier().size(); i++) 13211 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 13212 if (element.hasCode()) 13213 composeCodeableConcept(t, "Practitioner", "code", element.getCode(), -1); 13214 if (element.hasPeriod()) 13215 composePeriod(t, "Practitioner", "period", element.getPeriod(), -1); 13216 if (element.hasIssuer()) 13217 composeReference(t, "Practitioner", "issuer", element.getIssuer(), -1); 13218 } 13219 13220 protected void composePractitionerRole(Complex parent, String parentType, String name, PractitionerRole element, int index) { 13221 if (element == null) 13222 return; 13223 Complex t; 13224 if (Utilities.noString(parentType)) 13225 t = parent; 13226 else { 13227 t = parent.predicate("fhir:"+parentType+'.'+name); 13228 } 13229 composeDomainResource(t, "PractitionerRole", name, element, index); 13230 for (int i = 0; i < element.getIdentifier().size(); i++) 13231 composeIdentifier(t, "PractitionerRole", "identifier", element.getIdentifier().get(i), i); 13232 if (element.hasActiveElement()) 13233 composeBoolean(t, "PractitionerRole", "active", element.getActiveElement(), -1); 13234 if (element.hasPeriod()) 13235 composePeriod(t, "PractitionerRole", "period", element.getPeriod(), -1); 13236 if (element.hasPractitioner()) 13237 composeReference(t, "PractitionerRole", "practitioner", element.getPractitioner(), -1); 13238 if (element.hasOrganization()) 13239 composeReference(t, "PractitionerRole", "organization", element.getOrganization(), -1); 13240 for (int i = 0; i < element.getCode().size(); i++) 13241 composeCodeableConcept(t, "PractitionerRole", "code", element.getCode().get(i), i); 13242 for (int i = 0; i < element.getSpecialty().size(); i++) 13243 composeCodeableConcept(t, "PractitionerRole", "specialty", element.getSpecialty().get(i), i); 13244 for (int i = 0; i < element.getLocation().size(); i++) 13245 composeReference(t, "PractitionerRole", "location", element.getLocation().get(i), i); 13246 for (int i = 0; i < element.getHealthcareService().size(); i++) 13247 composeReference(t, "PractitionerRole", "healthcareService", element.getHealthcareService().get(i), i); 13248 for (int i = 0; i < element.getTelecom().size(); i++) 13249 composeContactPoint(t, "PractitionerRole", "telecom", element.getTelecom().get(i), i); 13250 for (int i = 0; i < element.getAvailableTime().size(); i++) 13251 composePractitionerRolePractitionerRoleAvailableTimeComponent(t, "PractitionerRole", "availableTime", element.getAvailableTime().get(i), i); 13252 for (int i = 0; i < element.getNotAvailable().size(); i++) 13253 composePractitionerRolePractitionerRoleNotAvailableComponent(t, "PractitionerRole", "notAvailable", element.getNotAvailable().get(i), i); 13254 if (element.hasAvailabilityExceptionsElement()) 13255 composeString(t, "PractitionerRole", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 13256 for (int i = 0; i < element.getEndpoint().size(); i++) 13257 composeReference(t, "PractitionerRole", "endpoint", element.getEndpoint().get(i), i); 13258 } 13259 13260 protected void composePractitionerRolePractitionerRoleAvailableTimeComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleAvailableTimeComponent element, int index) { 13261 if (element == null) 13262 return; 13263 Complex t; 13264 if (Utilities.noString(parentType)) 13265 t = parent; 13266 else { 13267 t = parent.predicate("fhir:"+parentType+'.'+name); 13268 } 13269 composeBackboneElement(t, "availableTime", name, element, index); 13270 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 13271 composeEnum(t, "PractitionerRole", "daysOfWeek", element.getDaysOfWeek().get(i), i); 13272 if (element.hasAllDayElement()) 13273 composeBoolean(t, "PractitionerRole", "allDay", element.getAllDayElement(), -1); 13274 if (element.hasAvailableStartTimeElement()) 13275 composeTime(t, "PractitionerRole", "availableStartTime", element.getAvailableStartTimeElement(), -1); 13276 if (element.hasAvailableEndTimeElement()) 13277 composeTime(t, "PractitionerRole", "availableEndTime", element.getAvailableEndTimeElement(), -1); 13278 } 13279 13280 protected void composePractitionerRolePractitionerRoleNotAvailableComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleNotAvailableComponent element, int index) { 13281 if (element == null) 13282 return; 13283 Complex t; 13284 if (Utilities.noString(parentType)) 13285 t = parent; 13286 else { 13287 t = parent.predicate("fhir:"+parentType+'.'+name); 13288 } 13289 composeBackboneElement(t, "notAvailable", name, element, index); 13290 if (element.hasDescriptionElement()) 13291 composeString(t, "PractitionerRole", "description", element.getDescriptionElement(), -1); 13292 if (element.hasDuring()) 13293 composePeriod(t, "PractitionerRole", "during", element.getDuring(), -1); 13294 } 13295 13296 protected void composeProcedure(Complex parent, String parentType, String name, Procedure element, int index) { 13297 if (element == null) 13298 return; 13299 Complex t; 13300 if (Utilities.noString(parentType)) 13301 t = parent; 13302 else { 13303 t = parent.predicate("fhir:"+parentType+'.'+name); 13304 } 13305 composeDomainResource(t, "Procedure", name, element, index); 13306 for (int i = 0; i < element.getIdentifier().size(); i++) 13307 composeIdentifier(t, "Procedure", "identifier", element.getIdentifier().get(i), i); 13308 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 13309 composeCanonical(t, "Procedure", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 13310 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 13311 composeUri(t, "Procedure", "instantiatesUri", element.getInstantiatesUri().get(i), i); 13312 for (int i = 0; i < element.getBasedOn().size(); i++) 13313 composeReference(t, "Procedure", "basedOn", element.getBasedOn().get(i), i); 13314 for (int i = 0; i < element.getPartOf().size(); i++) 13315 composeReference(t, "Procedure", "partOf", element.getPartOf().get(i), i); 13316 if (element.hasStatusElement()) 13317 composeEnum(t, "Procedure", "status", element.getStatusElement(), -1); 13318 if (element.hasStatusReason()) 13319 composeCodeableConcept(t, "Procedure", "statusReason", element.getStatusReason(), -1); 13320 if (element.hasCategory()) 13321 composeCodeableConcept(t, "Procedure", "category", element.getCategory(), -1); 13322 if (element.hasCode()) 13323 composeCodeableConcept(t, "Procedure", "code", element.getCode(), -1); 13324 if (element.hasSubject()) 13325 composeReference(t, "Procedure", "subject", element.getSubject(), -1); 13326 if (element.hasEncounter()) 13327 composeReference(t, "Procedure", "encounter", element.getEncounter(), -1); 13328 if (element.hasPerformed()) 13329 composeType(t, "Procedure", "performed", element.getPerformed(), -1); 13330 if (element.hasRecorder()) 13331 composeReference(t, "Procedure", "recorder", element.getRecorder(), -1); 13332 if (element.hasAsserter()) 13333 composeReference(t, "Procedure", "asserter", element.getAsserter(), -1); 13334 for (int i = 0; i < element.getPerformer().size(); i++) 13335 composeProcedureProcedurePerformerComponent(t, "Procedure", "performer", element.getPerformer().get(i), i); 13336 if (element.hasLocation()) 13337 composeReference(t, "Procedure", "location", element.getLocation(), -1); 13338 for (int i = 0; i < element.getReasonCode().size(); i++) 13339 composeCodeableConcept(t, "Procedure", "reasonCode", element.getReasonCode().get(i), i); 13340 for (int i = 0; i < element.getReasonReference().size(); i++) 13341 composeReference(t, "Procedure", "reasonReference", element.getReasonReference().get(i), i); 13342 for (int i = 0; i < element.getBodySite().size(); i++) 13343 composeCodeableConcept(t, "Procedure", "bodySite", element.getBodySite().get(i), i); 13344 if (element.hasOutcome()) 13345 composeCodeableConcept(t, "Procedure", "outcome", element.getOutcome(), -1); 13346 for (int i = 0; i < element.getReport().size(); i++) 13347 composeReference(t, "Procedure", "report", element.getReport().get(i), i); 13348 for (int i = 0; i < element.getComplication().size(); i++) 13349 composeCodeableConcept(t, "Procedure", "complication", element.getComplication().get(i), i); 13350 for (int i = 0; i < element.getComplicationDetail().size(); i++) 13351 composeReference(t, "Procedure", "complicationDetail", element.getComplicationDetail().get(i), i); 13352 for (int i = 0; i < element.getFollowUp().size(); i++) 13353 composeCodeableConcept(t, "Procedure", "followUp", element.getFollowUp().get(i), i); 13354 for (int i = 0; i < element.getNote().size(); i++) 13355 composeAnnotation(t, "Procedure", "note", element.getNote().get(i), i); 13356 for (int i = 0; i < element.getFocalDevice().size(); i++) 13357 composeProcedureProcedureFocalDeviceComponent(t, "Procedure", "focalDevice", element.getFocalDevice().get(i), i); 13358 for (int i = 0; i < element.getUsedReference().size(); i++) 13359 composeReference(t, "Procedure", "usedReference", element.getUsedReference().get(i), i); 13360 for (int i = 0; i < element.getUsedCode().size(); i++) 13361 composeCodeableConcept(t, "Procedure", "usedCode", element.getUsedCode().get(i), i); 13362 } 13363 13364 protected void composeProcedureProcedurePerformerComponent(Complex parent, String parentType, String name, Procedure.ProcedurePerformerComponent element, int index) { 13365 if (element == null) 13366 return; 13367 Complex t; 13368 if (Utilities.noString(parentType)) 13369 t = parent; 13370 else { 13371 t = parent.predicate("fhir:"+parentType+'.'+name); 13372 } 13373 composeBackboneElement(t, "performer", name, element, index); 13374 if (element.hasFunction()) 13375 composeCodeableConcept(t, "Procedure", "function", element.getFunction(), -1); 13376 if (element.hasActor()) 13377 composeReference(t, "Procedure", "actor", element.getActor(), -1); 13378 if (element.hasOnBehalfOf()) 13379 composeReference(t, "Procedure", "onBehalfOf", element.getOnBehalfOf(), -1); 13380 } 13381 13382 protected void composeProcedureProcedureFocalDeviceComponent(Complex parent, String parentType, String name, Procedure.ProcedureFocalDeviceComponent element, int index) { 13383 if (element == null) 13384 return; 13385 Complex t; 13386 if (Utilities.noString(parentType)) 13387 t = parent; 13388 else { 13389 t = parent.predicate("fhir:"+parentType+'.'+name); 13390 } 13391 composeBackboneElement(t, "focalDevice", name, element, index); 13392 if (element.hasAction()) 13393 composeCodeableConcept(t, "Procedure", "action", element.getAction(), -1); 13394 if (element.hasManipulated()) 13395 composeReference(t, "Procedure", "manipulated", element.getManipulated(), -1); 13396 } 13397 13398 protected void composeProvenance(Complex parent, String parentType, String name, Provenance element, int index) { 13399 if (element == null) 13400 return; 13401 Complex t; 13402 if (Utilities.noString(parentType)) 13403 t = parent; 13404 else { 13405 t = parent.predicate("fhir:"+parentType+'.'+name); 13406 } 13407 composeDomainResource(t, "Provenance", name, element, index); 13408 for (int i = 0; i < element.getTarget().size(); i++) 13409 composeReference(t, "Provenance", "target", element.getTarget().get(i), i); 13410 if (element.hasOccurred()) 13411 composeType(t, "Provenance", "occurred", element.getOccurred(), -1); 13412 if (element.hasRecordedElement()) 13413 composeInstant(t, "Provenance", "recorded", element.getRecordedElement(), -1); 13414 for (int i = 0; i < element.getPolicy().size(); i++) 13415 composeUri(t, "Provenance", "policy", element.getPolicy().get(i), i); 13416 if (element.hasLocation()) 13417 composeReference(t, "Provenance", "location", element.getLocation(), -1); 13418 for (int i = 0; i < element.getReason().size(); i++) 13419 composeCodeableConcept(t, "Provenance", "reason", element.getReason().get(i), i); 13420 if (element.hasActivity()) 13421 composeCodeableConcept(t, "Provenance", "activity", element.getActivity(), -1); 13422 for (int i = 0; i < element.getAgent().size(); i++) 13423 composeProvenanceProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i); 13424 for (int i = 0; i < element.getEntity().size(); i++) 13425 composeProvenanceProvenanceEntityComponent(t, "Provenance", "entity", element.getEntity().get(i), i); 13426 for (int i = 0; i < element.getSignature().size(); i++) 13427 composeSignature(t, "Provenance", "signature", element.getSignature().get(i), i); 13428 } 13429 13430 protected void composeProvenanceProvenanceAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentComponent element, int index) { 13431 if (element == null) 13432 return; 13433 Complex t; 13434 if (Utilities.noString(parentType)) 13435 t = parent; 13436 else { 13437 t = parent.predicate("fhir:"+parentType+'.'+name); 13438 } 13439 composeBackboneElement(t, "agent", name, element, index); 13440 if (element.hasType()) 13441 composeCodeableConcept(t, "Provenance", "type", element.getType(), -1); 13442 for (int i = 0; i < element.getRole().size(); i++) 13443 composeCodeableConcept(t, "Provenance", "role", element.getRole().get(i), i); 13444 if (element.hasWho()) 13445 composeReference(t, "Provenance", "who", element.getWho(), -1); 13446 if (element.hasOnBehalfOf()) 13447 composeReference(t, "Provenance", "onBehalfOf", element.getOnBehalfOf(), -1); 13448 } 13449 13450 protected void composeProvenanceProvenanceEntityComponent(Complex parent, String parentType, String name, Provenance.ProvenanceEntityComponent element, int index) { 13451 if (element == null) 13452 return; 13453 Complex t; 13454 if (Utilities.noString(parentType)) 13455 t = parent; 13456 else { 13457 t = parent.predicate("fhir:"+parentType+'.'+name); 13458 } 13459 composeBackboneElement(t, "entity", name, element, index); 13460 if (element.hasRoleElement()) 13461 composeEnum(t, "Provenance", "role", element.getRoleElement(), -1); 13462 if (element.hasWhat()) 13463 composeReference(t, "Provenance", "what", element.getWhat(), -1); 13464 for (int i = 0; i < element.getAgent().size(); i++) 13465 composeProvenanceProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i); 13466 } 13467 13468 protected void composeQuestionnaire(Complex parent, String parentType, String name, Questionnaire element, int index) { 13469 if (element == null) 13470 return; 13471 Complex t; 13472 if (Utilities.noString(parentType)) 13473 t = parent; 13474 else { 13475 t = parent.predicate("fhir:"+parentType+'.'+name); 13476 } 13477 composeDomainResource(t, "Questionnaire", name, element, index); 13478 if (element.hasUrlElement()) 13479 composeUri(t, "Questionnaire", "url", element.getUrlElement(), -1); 13480 for (int i = 0; i < element.getIdentifier().size(); i++) 13481 composeIdentifier(t, "Questionnaire", "identifier", element.getIdentifier().get(i), i); 13482 if (element.hasVersionElement()) 13483 composeString(t, "Questionnaire", "version", element.getVersionElement(), -1); 13484 if (element.hasNameElement()) 13485 composeString(t, "Questionnaire", "name", element.getNameElement(), -1); 13486 if (element.hasTitleElement()) 13487 composeString(t, "Questionnaire", "title", element.getTitleElement(), -1); 13488 for (int i = 0; i < element.getDerivedFrom().size(); i++) 13489 composeCanonical(t, "Questionnaire", "derivedFrom", element.getDerivedFrom().get(i), i); 13490 if (element.hasStatusElement()) 13491 composeEnum(t, "Questionnaire", "status", element.getStatusElement(), -1); 13492 if (element.hasExperimentalElement()) 13493 composeBoolean(t, "Questionnaire", "experimental", element.getExperimentalElement(), -1); 13494 for (int i = 0; i < element.getSubjectType().size(); i++) 13495 composeCode(t, "Questionnaire", "subjectType", element.getSubjectType().get(i), i); 13496 if (element.hasDateElement()) 13497 composeDateTime(t, "Questionnaire", "date", element.getDateElement(), -1); 13498 if (element.hasPublisherElement()) 13499 composeString(t, "Questionnaire", "publisher", element.getPublisherElement(), -1); 13500 for (int i = 0; i < element.getContact().size(); i++) 13501 composeContactDetail(t, "Questionnaire", "contact", element.getContact().get(i), i); 13502 if (element.hasDescriptionElement()) 13503 composeMarkdown(t, "Questionnaire", "description", element.getDescriptionElement(), -1); 13504 for (int i = 0; i < element.getUseContext().size(); i++) 13505 composeUsageContext(t, "Questionnaire", "useContext", element.getUseContext().get(i), i); 13506 for (int i = 0; i < element.getJurisdiction().size(); i++) 13507 composeCodeableConcept(t, "Questionnaire", "jurisdiction", element.getJurisdiction().get(i), i); 13508 if (element.hasPurposeElement()) 13509 composeMarkdown(t, "Questionnaire", "purpose", element.getPurposeElement(), -1); 13510 if (element.hasCopyrightElement()) 13511 composeMarkdown(t, "Questionnaire", "copyright", element.getCopyrightElement(), -1); 13512 if (element.hasApprovalDateElement()) 13513 composeDate(t, "Questionnaire", "approvalDate", element.getApprovalDateElement(), -1); 13514 if (element.hasLastReviewDateElement()) 13515 composeDate(t, "Questionnaire", "lastReviewDate", element.getLastReviewDateElement(), -1); 13516 if (element.hasEffectivePeriod()) 13517 composePeriod(t, "Questionnaire", "effectivePeriod", element.getEffectivePeriod(), -1); 13518 for (int i = 0; i < element.getCode().size(); i++) 13519 composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i); 13520 for (int i = 0; i < element.getItem().size(); i++) 13521 composeQuestionnaireQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 13522 } 13523 13524 protected void composeQuestionnaireQuestionnaireItemComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemComponent element, int index) { 13525 if (element == null) 13526 return; 13527 Complex t; 13528 if (Utilities.noString(parentType)) 13529 t = parent; 13530 else { 13531 t = parent.predicate("fhir:"+parentType+'.'+name); 13532 } 13533 composeBackboneElement(t, "item", name, element, index); 13534 if (element.hasLinkIdElement()) 13535 composeString(t, "Questionnaire", "linkId", element.getLinkIdElement(), -1); 13536 if (element.hasDefinitionElement()) 13537 composeUri(t, "Questionnaire", "definition", element.getDefinitionElement(), -1); 13538 for (int i = 0; i < element.getCode().size(); i++) 13539 composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i); 13540 if (element.hasPrefixElement()) 13541 composeString(t, "Questionnaire", "prefix", element.getPrefixElement(), -1); 13542 if (element.hasTextElement()) 13543 composeString(t, "Questionnaire", "text", element.getTextElement(), -1); 13544 if (element.hasTypeElement()) 13545 composeEnum(t, "Questionnaire", "type", element.getTypeElement(), -1); 13546 for (int i = 0; i < element.getEnableWhen().size(); i++) 13547 composeQuestionnaireQuestionnaireItemEnableWhenComponent(t, "Questionnaire", "enableWhen", element.getEnableWhen().get(i), i); 13548 if (element.hasEnableBehaviorElement()) 13549 composeEnum(t, "Questionnaire", "enableBehavior", element.getEnableBehaviorElement(), -1); 13550 if (element.hasRequiredElement()) 13551 composeBoolean(t, "Questionnaire", "required", element.getRequiredElement(), -1); 13552 if (element.hasRepeatsElement()) 13553 composeBoolean(t, "Questionnaire", "repeats", element.getRepeatsElement(), -1); 13554 if (element.hasReadOnlyElement()) 13555 composeBoolean(t, "Questionnaire", "readOnly", element.getReadOnlyElement(), -1); 13556 if (element.hasMaxLengthElement()) 13557 composeInteger(t, "Questionnaire", "maxLength", element.getMaxLengthElement(), -1); 13558 if (element.hasAnswerValueSetElement()) 13559 composeCanonical(t, "Questionnaire", "answerValueSet", element.getAnswerValueSetElement(), -1); 13560 for (int i = 0; i < element.getAnswerOption().size(); i++) 13561 composeQuestionnaireQuestionnaireItemAnswerOptionComponent(t, "Questionnaire", "answerOption", element.getAnswerOption().get(i), i); 13562 for (int i = 0; i < element.getInitial().size(); i++) 13563 composeQuestionnaireQuestionnaireItemInitialComponent(t, "Questionnaire", "initial", element.getInitial().get(i), i); 13564 for (int i = 0; i < element.getItem().size(); i++) 13565 composeQuestionnaireQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 13566 } 13567 13568 protected void composeQuestionnaireQuestionnaireItemEnableWhenComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemEnableWhenComponent element, int index) { 13569 if (element == null) 13570 return; 13571 Complex t; 13572 if (Utilities.noString(parentType)) 13573 t = parent; 13574 else { 13575 t = parent.predicate("fhir:"+parentType+'.'+name); 13576 } 13577 composeBackboneElement(t, "enableWhen", name, element, index); 13578 if (element.hasQuestionElement()) 13579 composeString(t, "Questionnaire", "question", element.getQuestionElement(), -1); 13580 if (element.hasOperatorElement()) 13581 composeEnum(t, "Questionnaire", "operator", element.getOperatorElement(), -1); 13582 if (element.hasAnswer()) 13583 composeType(t, "Questionnaire", "answer", element.getAnswer(), -1); 13584 } 13585 13586 protected void composeQuestionnaireQuestionnaireItemAnswerOptionComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemAnswerOptionComponent element, int index) { 13587 if (element == null) 13588 return; 13589 Complex t; 13590 if (Utilities.noString(parentType)) 13591 t = parent; 13592 else { 13593 t = parent.predicate("fhir:"+parentType+'.'+name); 13594 } 13595 composeBackboneElement(t, "answerOption", name, element, index); 13596 if (element.hasValue()) 13597 composeType(t, "Questionnaire", "value", element.getValue(), -1); 13598 if (element.hasInitialSelectedElement()) 13599 composeBoolean(t, "Questionnaire", "initialSelected", element.getInitialSelectedElement(), -1); 13600 } 13601 13602 protected void composeQuestionnaireQuestionnaireItemInitialComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemInitialComponent element, int index) { 13603 if (element == null) 13604 return; 13605 Complex t; 13606 if (Utilities.noString(parentType)) 13607 t = parent; 13608 else { 13609 t = parent.predicate("fhir:"+parentType+'.'+name); 13610 } 13611 composeBackboneElement(t, "initial", name, element, index); 13612 if (element.hasValue()) 13613 composeType(t, "Questionnaire", "value", element.getValue(), -1); 13614 } 13615 13616 protected void composeQuestionnaireResponse(Complex parent, String parentType, String name, QuestionnaireResponse element, int index) { 13617 if (element == null) 13618 return; 13619 Complex t; 13620 if (Utilities.noString(parentType)) 13621 t = parent; 13622 else { 13623 t = parent.predicate("fhir:"+parentType+'.'+name); 13624 } 13625 composeDomainResource(t, "QuestionnaireResponse", name, element, index); 13626 if (element.hasIdentifier()) 13627 composeIdentifier(t, "QuestionnaireResponse", "identifier", element.getIdentifier(), -1); 13628 for (int i = 0; i < element.getBasedOn().size(); i++) 13629 composeReference(t, "QuestionnaireResponse", "basedOn", element.getBasedOn().get(i), i); 13630 for (int i = 0; i < element.getPartOf().size(); i++) 13631 composeReference(t, "QuestionnaireResponse", "partOf", element.getPartOf().get(i), i); 13632 if (element.hasQuestionnaireElement()) 13633 composeCanonical(t, "QuestionnaireResponse", "questionnaire", element.getQuestionnaireElement(), -1); 13634 if (element.hasStatusElement()) 13635 composeEnum(t, "QuestionnaireResponse", "status", element.getStatusElement(), -1); 13636 if (element.hasSubject()) 13637 composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1); 13638 if (element.hasEncounter()) 13639 composeReference(t, "QuestionnaireResponse", "encounter", element.getEncounter(), -1); 13640 if (element.hasAuthoredElement()) 13641 composeDateTime(t, "QuestionnaireResponse", "authored", element.getAuthoredElement(), -1); 13642 if (element.hasAuthor()) 13643 composeReference(t, "QuestionnaireResponse", "author", element.getAuthor(), -1); 13644 if (element.hasSource()) 13645 composeReference(t, "QuestionnaireResponse", "source", element.getSource(), -1); 13646 for (int i = 0; i < element.getItem().size(); i++) 13647 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 13648 } 13649 13650 protected void composeQuestionnaireResponseQuestionnaireResponseItemComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemComponent element, int index) { 13651 if (element == null) 13652 return; 13653 Complex t; 13654 if (Utilities.noString(parentType)) 13655 t = parent; 13656 else { 13657 t = parent.predicate("fhir:"+parentType+'.'+name); 13658 } 13659 composeBackboneElement(t, "item", name, element, index); 13660 if (element.hasLinkIdElement()) 13661 composeString(t, "QuestionnaireResponse", "linkId", element.getLinkIdElement(), -1); 13662 if (element.hasDefinitionElement()) 13663 composeUri(t, "QuestionnaireResponse", "definition", element.getDefinitionElement(), -1); 13664 if (element.hasTextElement()) 13665 composeString(t, "QuestionnaireResponse", "text", element.getTextElement(), -1); 13666 for (int i = 0; i < element.getAnswer().size(); i++) 13667 composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(t, "QuestionnaireResponse", "answer", element.getAnswer().get(i), i); 13668 for (int i = 0; i < element.getItem().size(); i++) 13669 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 13670 } 13671 13672 protected void composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element, int index) { 13673 if (element == null) 13674 return; 13675 Complex t; 13676 if (Utilities.noString(parentType)) 13677 t = parent; 13678 else { 13679 t = parent.predicate("fhir:"+parentType+'.'+name); 13680 } 13681 composeBackboneElement(t, "answer", name, element, index); 13682 if (element.hasValue()) 13683 composeType(t, "QuestionnaireResponse", "value", element.getValue(), -1); 13684 for (int i = 0; i < element.getItem().size(); i++) 13685 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 13686 } 13687 13688 protected void composeRelatedPerson(Complex parent, String parentType, String name, RelatedPerson element, int index) { 13689 if (element == null) 13690 return; 13691 Complex t; 13692 if (Utilities.noString(parentType)) 13693 t = parent; 13694 else { 13695 t = parent.predicate("fhir:"+parentType+'.'+name); 13696 } 13697 composeDomainResource(t, "RelatedPerson", name, element, index); 13698 for (int i = 0; i < element.getIdentifier().size(); i++) 13699 composeIdentifier(t, "RelatedPerson", "identifier", element.getIdentifier().get(i), i); 13700 if (element.hasActiveElement()) 13701 composeBoolean(t, "RelatedPerson", "active", element.getActiveElement(), -1); 13702 if (element.hasPatient()) 13703 composeReference(t, "RelatedPerson", "patient", element.getPatient(), -1); 13704 for (int i = 0; i < element.getRelationship().size(); i++) 13705 composeCodeableConcept(t, "RelatedPerson", "relationship", element.getRelationship().get(i), i); 13706 for (int i = 0; i < element.getName().size(); i++) 13707 composeHumanName(t, "RelatedPerson", "name", element.getName().get(i), i); 13708 for (int i = 0; i < element.getTelecom().size(); i++) 13709 composeContactPoint(t, "RelatedPerson", "telecom", element.getTelecom().get(i), i); 13710 if (element.hasGenderElement()) 13711 composeEnum(t, "RelatedPerson", "gender", element.getGenderElement(), -1); 13712 if (element.hasBirthDateElement()) 13713 composeDate(t, "RelatedPerson", "birthDate", element.getBirthDateElement(), -1); 13714 for (int i = 0; i < element.getAddress().size(); i++) 13715 composeAddress(t, "RelatedPerson", "address", element.getAddress().get(i), i); 13716 for (int i = 0; i < element.getPhoto().size(); i++) 13717 composeAttachment(t, "RelatedPerson", "photo", element.getPhoto().get(i), i); 13718 if (element.hasPeriod()) 13719 composePeriod(t, "RelatedPerson", "period", element.getPeriod(), -1); 13720 for (int i = 0; i < element.getCommunication().size(); i++) 13721 composeRelatedPersonRelatedPersonCommunicationComponent(t, "RelatedPerson", "communication", element.getCommunication().get(i), i); 13722 } 13723 13724 protected void composeRelatedPersonRelatedPersonCommunicationComponent(Complex parent, String parentType, String name, RelatedPerson.RelatedPersonCommunicationComponent element, int index) { 13725 if (element == null) 13726 return; 13727 Complex t; 13728 if (Utilities.noString(parentType)) 13729 t = parent; 13730 else { 13731 t = parent.predicate("fhir:"+parentType+'.'+name); 13732 } 13733 composeBackboneElement(t, "communication", name, element, index); 13734 if (element.hasLanguage()) 13735 composeCodeableConcept(t, "RelatedPerson", "language", element.getLanguage(), -1); 13736 if (element.hasPreferredElement()) 13737 composeBoolean(t, "RelatedPerson", "preferred", element.getPreferredElement(), -1); 13738 } 13739 13740 protected void composeRequestGroup(Complex parent, String parentType, String name, RequestGroup element, int index) { 13741 if (element == null) 13742 return; 13743 Complex t; 13744 if (Utilities.noString(parentType)) 13745 t = parent; 13746 else { 13747 t = parent.predicate("fhir:"+parentType+'.'+name); 13748 } 13749 composeDomainResource(t, "RequestGroup", name, element, index); 13750 for (int i = 0; i < element.getIdentifier().size(); i++) 13751 composeIdentifier(t, "RequestGroup", "identifier", element.getIdentifier().get(i), i); 13752 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 13753 composeCanonical(t, "RequestGroup", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 13754 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 13755 composeUri(t, "RequestGroup", "instantiatesUri", element.getInstantiatesUri().get(i), i); 13756 for (int i = 0; i < element.getBasedOn().size(); i++) 13757 composeReference(t, "RequestGroup", "basedOn", element.getBasedOn().get(i), i); 13758 for (int i = 0; i < element.getReplaces().size(); i++) 13759 composeReference(t, "RequestGroup", "replaces", element.getReplaces().get(i), i); 13760 if (element.hasGroupIdentifier()) 13761 composeIdentifier(t, "RequestGroup", "groupIdentifier", element.getGroupIdentifier(), -1); 13762 if (element.hasStatusElement()) 13763 composeEnum(t, "RequestGroup", "status", element.getStatusElement(), -1); 13764 if (element.hasIntentElement()) 13765 composeEnum(t, "RequestGroup", "intent", element.getIntentElement(), -1); 13766 if (element.hasPriorityElement()) 13767 composeEnum(t, "RequestGroup", "priority", element.getPriorityElement(), -1); 13768 if (element.hasCode()) 13769 composeCodeableConcept(t, "RequestGroup", "code", element.getCode(), -1); 13770 if (element.hasSubject()) 13771 composeReference(t, "RequestGroup", "subject", element.getSubject(), -1); 13772 if (element.hasEncounter()) 13773 composeReference(t, "RequestGroup", "encounter", element.getEncounter(), -1); 13774 if (element.hasAuthoredOnElement()) 13775 composeDateTime(t, "RequestGroup", "authoredOn", element.getAuthoredOnElement(), -1); 13776 if (element.hasAuthor()) 13777 composeReference(t, "RequestGroup", "author", element.getAuthor(), -1); 13778 for (int i = 0; i < element.getReasonCode().size(); i++) 13779 composeCodeableConcept(t, "RequestGroup", "reasonCode", element.getReasonCode().get(i), i); 13780 for (int i = 0; i < element.getReasonReference().size(); i++) 13781 composeReference(t, "RequestGroup", "reasonReference", element.getReasonReference().get(i), i); 13782 for (int i = 0; i < element.getNote().size(); i++) 13783 composeAnnotation(t, "RequestGroup", "note", element.getNote().get(i), i); 13784 for (int i = 0; i < element.getAction().size(); i++) 13785 composeRequestGroupRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i); 13786 } 13787 13788 protected void composeRequestGroupRequestGroupActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionComponent element, int index) { 13789 if (element == null) 13790 return; 13791 Complex t; 13792 if (Utilities.noString(parentType)) 13793 t = parent; 13794 else { 13795 t = parent.predicate("fhir:"+parentType+'.'+name); 13796 } 13797 composeBackboneElement(t, "action", name, element, index); 13798 if (element.hasPrefixElement()) 13799 composeString(t, "RequestGroup", "prefix", element.getPrefixElement(), -1); 13800 if (element.hasTitleElement()) 13801 composeString(t, "RequestGroup", "title", element.getTitleElement(), -1); 13802 if (element.hasDescriptionElement()) 13803 composeString(t, "RequestGroup", "description", element.getDescriptionElement(), -1); 13804 if (element.hasTextEquivalentElement()) 13805 composeString(t, "RequestGroup", "textEquivalent", element.getTextEquivalentElement(), -1); 13806 if (element.hasPriorityElement()) 13807 composeEnum(t, "RequestGroup", "priority", element.getPriorityElement(), -1); 13808 for (int i = 0; i < element.getCode().size(); i++) 13809 composeCodeableConcept(t, "RequestGroup", "code", element.getCode().get(i), i); 13810 for (int i = 0; i < element.getDocumentation().size(); i++) 13811 composeRelatedArtifact(t, "RequestGroup", "documentation", element.getDocumentation().get(i), i); 13812 for (int i = 0; i < element.getCondition().size(); i++) 13813 composeRequestGroupRequestGroupActionConditionComponent(t, "RequestGroup", "condition", element.getCondition().get(i), i); 13814 for (int i = 0; i < element.getRelatedAction().size(); i++) 13815 composeRequestGroupRequestGroupActionRelatedActionComponent(t, "RequestGroup", "relatedAction", element.getRelatedAction().get(i), i); 13816 if (element.hasTiming()) 13817 composeType(t, "RequestGroup", "timing", element.getTiming(), -1); 13818 for (int i = 0; i < element.getParticipant().size(); i++) 13819 composeReference(t, "RequestGroup", "participant", element.getParticipant().get(i), i); 13820 if (element.hasType()) 13821 composeCodeableConcept(t, "RequestGroup", "type", element.getType(), -1); 13822 if (element.hasGroupingBehaviorElement()) 13823 composeEnum(t, "RequestGroup", "groupingBehavior", element.getGroupingBehaviorElement(), -1); 13824 if (element.hasSelectionBehaviorElement()) 13825 composeEnum(t, "RequestGroup", "selectionBehavior", element.getSelectionBehaviorElement(), -1); 13826 if (element.hasRequiredBehaviorElement()) 13827 composeEnum(t, "RequestGroup", "requiredBehavior", element.getRequiredBehaviorElement(), -1); 13828 if (element.hasPrecheckBehaviorElement()) 13829 composeEnum(t, "RequestGroup", "precheckBehavior", element.getPrecheckBehaviorElement(), -1); 13830 if (element.hasCardinalityBehaviorElement()) 13831 composeEnum(t, "RequestGroup", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1); 13832 if (element.hasResource()) 13833 composeReference(t, "RequestGroup", "resource", element.getResource(), -1); 13834 for (int i = 0; i < element.getAction().size(); i++) 13835 composeRequestGroupRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i); 13836 } 13837 13838 protected void composeRequestGroupRequestGroupActionConditionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionConditionComponent element, int index) { 13839 if (element == null) 13840 return; 13841 Complex t; 13842 if (Utilities.noString(parentType)) 13843 t = parent; 13844 else { 13845 t = parent.predicate("fhir:"+parentType+'.'+name); 13846 } 13847 composeBackboneElement(t, "condition", name, element, index); 13848 if (element.hasKindElement()) 13849 composeEnum(t, "RequestGroup", "kind", element.getKindElement(), -1); 13850 if (element.hasExpression()) 13851 composeExpression(t, "RequestGroup", "expression", element.getExpression(), -1); 13852 } 13853 13854 protected void composeRequestGroupRequestGroupActionRelatedActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionRelatedActionComponent element, int index) { 13855 if (element == null) 13856 return; 13857 Complex t; 13858 if (Utilities.noString(parentType)) 13859 t = parent; 13860 else { 13861 t = parent.predicate("fhir:"+parentType+'.'+name); 13862 } 13863 composeBackboneElement(t, "relatedAction", name, element, index); 13864 if (element.hasActionIdElement()) 13865 composeId(t, "RequestGroup", "actionId", element.getActionIdElement(), -1); 13866 if (element.hasRelationshipElement()) 13867 composeEnum(t, "RequestGroup", "relationship", element.getRelationshipElement(), -1); 13868 if (element.hasOffset()) 13869 composeType(t, "RequestGroup", "offset", element.getOffset(), -1); 13870 } 13871 13872 protected void composeResearchDefinition(Complex parent, String parentType, String name, ResearchDefinition element, int index) { 13873 if (element == null) 13874 return; 13875 Complex t; 13876 if (Utilities.noString(parentType)) 13877 t = parent; 13878 else { 13879 t = parent.predicate("fhir:"+parentType+'.'+name); 13880 } 13881 composeDomainResource(t, "ResearchDefinition", name, element, index); 13882 if (element.hasUrlElement()) 13883 composeUri(t, "ResearchDefinition", "url", element.getUrlElement(), -1); 13884 for (int i = 0; i < element.getIdentifier().size(); i++) 13885 composeIdentifier(t, "ResearchDefinition", "identifier", element.getIdentifier().get(i), i); 13886 if (element.hasVersionElement()) 13887 composeString(t, "ResearchDefinition", "version", element.getVersionElement(), -1); 13888 if (element.hasNameElement()) 13889 composeString(t, "ResearchDefinition", "name", element.getNameElement(), -1); 13890 if (element.hasTitleElement()) 13891 composeString(t, "ResearchDefinition", "title", element.getTitleElement(), -1); 13892 if (element.hasShortTitleElement()) 13893 composeString(t, "ResearchDefinition", "shortTitle", element.getShortTitleElement(), -1); 13894 if (element.hasSubtitleElement()) 13895 composeString(t, "ResearchDefinition", "subtitle", element.getSubtitleElement(), -1); 13896 if (element.hasStatusElement()) 13897 composeEnum(t, "ResearchDefinition", "status", element.getStatusElement(), -1); 13898 if (element.hasExperimentalElement()) 13899 composeBoolean(t, "ResearchDefinition", "experimental", element.getExperimentalElement(), -1); 13900 if (element.hasSubject()) 13901 composeType(t, "ResearchDefinition", "subject", element.getSubject(), -1); 13902 if (element.hasDateElement()) 13903 composeDateTime(t, "ResearchDefinition", "date", element.getDateElement(), -1); 13904 if (element.hasPublisherElement()) 13905 composeString(t, "ResearchDefinition", "publisher", element.getPublisherElement(), -1); 13906 for (int i = 0; i < element.getContact().size(); i++) 13907 composeContactDetail(t, "ResearchDefinition", "contact", element.getContact().get(i), i); 13908 if (element.hasDescriptionElement()) 13909 composeMarkdown(t, "ResearchDefinition", "description", element.getDescriptionElement(), -1); 13910 for (int i = 0; i < element.getComment().size(); i++) 13911 composeString(t, "ResearchDefinition", "comment", element.getComment().get(i), i); 13912 for (int i = 0; i < element.getUseContext().size(); i++) 13913 composeUsageContext(t, "ResearchDefinition", "useContext", element.getUseContext().get(i), i); 13914 for (int i = 0; i < element.getJurisdiction().size(); i++) 13915 composeCodeableConcept(t, "ResearchDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 13916 if (element.hasPurposeElement()) 13917 composeMarkdown(t, "ResearchDefinition", "purpose", element.getPurposeElement(), -1); 13918 if (element.hasUsageElement()) 13919 composeString(t, "ResearchDefinition", "usage", element.getUsageElement(), -1); 13920 if (element.hasCopyrightElement()) 13921 composeMarkdown(t, "ResearchDefinition", "copyright", element.getCopyrightElement(), -1); 13922 if (element.hasApprovalDateElement()) 13923 composeDate(t, "ResearchDefinition", "approvalDate", element.getApprovalDateElement(), -1); 13924 if (element.hasLastReviewDateElement()) 13925 composeDate(t, "ResearchDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 13926 if (element.hasEffectivePeriod()) 13927 composePeriod(t, "ResearchDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 13928 for (int i = 0; i < element.getTopic().size(); i++) 13929 composeCodeableConcept(t, "ResearchDefinition", "topic", element.getTopic().get(i), i); 13930 for (int i = 0; i < element.getAuthor().size(); i++) 13931 composeContactDetail(t, "ResearchDefinition", "author", element.getAuthor().get(i), i); 13932 for (int i = 0; i < element.getEditor().size(); i++) 13933 composeContactDetail(t, "ResearchDefinition", "editor", element.getEditor().get(i), i); 13934 for (int i = 0; i < element.getReviewer().size(); i++) 13935 composeContactDetail(t, "ResearchDefinition", "reviewer", element.getReviewer().get(i), i); 13936 for (int i = 0; i < element.getEndorser().size(); i++) 13937 composeContactDetail(t, "ResearchDefinition", "endorser", element.getEndorser().get(i), i); 13938 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 13939 composeRelatedArtifact(t, "ResearchDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 13940 for (int i = 0; i < element.getLibrary().size(); i++) 13941 composeCanonical(t, "ResearchDefinition", "library", element.getLibrary().get(i), i); 13942 if (element.hasPopulation()) 13943 composeReference(t, "ResearchDefinition", "population", element.getPopulation(), -1); 13944 if (element.hasExposure()) 13945 composeReference(t, "ResearchDefinition", "exposure", element.getExposure(), -1); 13946 if (element.hasExposureAlternative()) 13947 composeReference(t, "ResearchDefinition", "exposureAlternative", element.getExposureAlternative(), -1); 13948 if (element.hasOutcome()) 13949 composeReference(t, "ResearchDefinition", "outcome", element.getOutcome(), -1); 13950 } 13951 13952 protected void composeResearchElementDefinition(Complex parent, String parentType, String name, ResearchElementDefinition element, int index) { 13953 if (element == null) 13954 return; 13955 Complex t; 13956 if (Utilities.noString(parentType)) 13957 t = parent; 13958 else { 13959 t = parent.predicate("fhir:"+parentType+'.'+name); 13960 } 13961 composeDomainResource(t, "ResearchElementDefinition", name, element, index); 13962 if (element.hasUrlElement()) 13963 composeUri(t, "ResearchElementDefinition", "url", element.getUrlElement(), -1); 13964 for (int i = 0; i < element.getIdentifier().size(); i++) 13965 composeIdentifier(t, "ResearchElementDefinition", "identifier", element.getIdentifier().get(i), i); 13966 if (element.hasVersionElement()) 13967 composeString(t, "ResearchElementDefinition", "version", element.getVersionElement(), -1); 13968 if (element.hasNameElement()) 13969 composeString(t, "ResearchElementDefinition", "name", element.getNameElement(), -1); 13970 if (element.hasTitleElement()) 13971 composeString(t, "ResearchElementDefinition", "title", element.getTitleElement(), -1); 13972 if (element.hasShortTitleElement()) 13973 composeString(t, "ResearchElementDefinition", "shortTitle", element.getShortTitleElement(), -1); 13974 if (element.hasSubtitleElement()) 13975 composeString(t, "ResearchElementDefinition", "subtitle", element.getSubtitleElement(), -1); 13976 if (element.hasStatusElement()) 13977 composeEnum(t, "ResearchElementDefinition", "status", element.getStatusElement(), -1); 13978 if (element.hasExperimentalElement()) 13979 composeBoolean(t, "ResearchElementDefinition", "experimental", element.getExperimentalElement(), -1); 13980 if (element.hasSubject()) 13981 composeType(t, "ResearchElementDefinition", "subject", element.getSubject(), -1); 13982 if (element.hasDateElement()) 13983 composeDateTime(t, "ResearchElementDefinition", "date", element.getDateElement(), -1); 13984 if (element.hasPublisherElement()) 13985 composeString(t, "ResearchElementDefinition", "publisher", element.getPublisherElement(), -1); 13986 for (int i = 0; i < element.getContact().size(); i++) 13987 composeContactDetail(t, "ResearchElementDefinition", "contact", element.getContact().get(i), i); 13988 if (element.hasDescriptionElement()) 13989 composeMarkdown(t, "ResearchElementDefinition", "description", element.getDescriptionElement(), -1); 13990 for (int i = 0; i < element.getComment().size(); i++) 13991 composeString(t, "ResearchElementDefinition", "comment", element.getComment().get(i), i); 13992 for (int i = 0; i < element.getUseContext().size(); i++) 13993 composeUsageContext(t, "ResearchElementDefinition", "useContext", element.getUseContext().get(i), i); 13994 for (int i = 0; i < element.getJurisdiction().size(); i++) 13995 composeCodeableConcept(t, "ResearchElementDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 13996 if (element.hasPurposeElement()) 13997 composeMarkdown(t, "ResearchElementDefinition", "purpose", element.getPurposeElement(), -1); 13998 if (element.hasUsageElement()) 13999 composeString(t, "ResearchElementDefinition", "usage", element.getUsageElement(), -1); 14000 if (element.hasCopyrightElement()) 14001 composeMarkdown(t, "ResearchElementDefinition", "copyright", element.getCopyrightElement(), -1); 14002 if (element.hasApprovalDateElement()) 14003 composeDate(t, "ResearchElementDefinition", "approvalDate", element.getApprovalDateElement(), -1); 14004 if (element.hasLastReviewDateElement()) 14005 composeDate(t, "ResearchElementDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 14006 if (element.hasEffectivePeriod()) 14007 composePeriod(t, "ResearchElementDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 14008 for (int i = 0; i < element.getTopic().size(); i++) 14009 composeCodeableConcept(t, "ResearchElementDefinition", "topic", element.getTopic().get(i), i); 14010 for (int i = 0; i < element.getAuthor().size(); i++) 14011 composeContactDetail(t, "ResearchElementDefinition", "author", element.getAuthor().get(i), i); 14012 for (int i = 0; i < element.getEditor().size(); i++) 14013 composeContactDetail(t, "ResearchElementDefinition", "editor", element.getEditor().get(i), i); 14014 for (int i = 0; i < element.getReviewer().size(); i++) 14015 composeContactDetail(t, "ResearchElementDefinition", "reviewer", element.getReviewer().get(i), i); 14016 for (int i = 0; i < element.getEndorser().size(); i++) 14017 composeContactDetail(t, "ResearchElementDefinition", "endorser", element.getEndorser().get(i), i); 14018 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 14019 composeRelatedArtifact(t, "ResearchElementDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 14020 for (int i = 0; i < element.getLibrary().size(); i++) 14021 composeCanonical(t, "ResearchElementDefinition", "library", element.getLibrary().get(i), i); 14022 if (element.hasTypeElement()) 14023 composeEnum(t, "ResearchElementDefinition", "type", element.getTypeElement(), -1); 14024 if (element.hasVariableTypeElement()) 14025 composeEnum(t, "ResearchElementDefinition", "variableType", element.getVariableTypeElement(), -1); 14026 for (int i = 0; i < element.getCharacteristic().size(); i++) 14027 composeResearchElementDefinitionResearchElementDefinitionCharacteristicComponent(t, "ResearchElementDefinition", "characteristic", element.getCharacteristic().get(i), i); 14028 } 14029 14030 protected void composeResearchElementDefinitionResearchElementDefinitionCharacteristicComponent(Complex parent, String parentType, String name, ResearchElementDefinition.ResearchElementDefinitionCharacteristicComponent element, int index) { 14031 if (element == null) 14032 return; 14033 Complex t; 14034 if (Utilities.noString(parentType)) 14035 t = parent; 14036 else { 14037 t = parent.predicate("fhir:"+parentType+'.'+name); 14038 } 14039 composeBackboneElement(t, "characteristic", name, element, index); 14040 if (element.hasDefinition()) 14041 composeType(t, "ResearchElementDefinition", "definition", element.getDefinition(), -1); 14042 for (int i = 0; i < element.getUsageContext().size(); i++) 14043 composeUsageContext(t, "ResearchElementDefinition", "usageContext", element.getUsageContext().get(i), i); 14044 if (element.hasExcludeElement()) 14045 composeBoolean(t, "ResearchElementDefinition", "exclude", element.getExcludeElement(), -1); 14046 if (element.hasUnitOfMeasure()) 14047 composeCodeableConcept(t, "ResearchElementDefinition", "unitOfMeasure", element.getUnitOfMeasure(), -1); 14048 if (element.hasStudyEffectiveDescriptionElement()) 14049 composeString(t, "ResearchElementDefinition", "studyEffectiveDescription", element.getStudyEffectiveDescriptionElement(), -1); 14050 if (element.hasStudyEffective()) 14051 composeType(t, "ResearchElementDefinition", "studyEffective", element.getStudyEffective(), -1); 14052 if (element.hasStudyEffectiveTimeFromStart()) 14053 composeDuration(t, "ResearchElementDefinition", "studyEffectiveTimeFromStart", element.getStudyEffectiveTimeFromStart(), -1); 14054 if (element.hasStudyEffectiveGroupMeasureElement()) 14055 composeEnum(t, "ResearchElementDefinition", "studyEffectiveGroupMeasure", element.getStudyEffectiveGroupMeasureElement(), -1); 14056 if (element.hasParticipantEffectiveDescriptionElement()) 14057 composeString(t, "ResearchElementDefinition", "participantEffectiveDescription", element.getParticipantEffectiveDescriptionElement(), -1); 14058 if (element.hasParticipantEffective()) 14059 composeType(t, "ResearchElementDefinition", "participantEffective", element.getParticipantEffective(), -1); 14060 if (element.hasParticipantEffectiveTimeFromStart()) 14061 composeDuration(t, "ResearchElementDefinition", "participantEffectiveTimeFromStart", element.getParticipantEffectiveTimeFromStart(), -1); 14062 if (element.hasParticipantEffectiveGroupMeasureElement()) 14063 composeEnum(t, "ResearchElementDefinition", "participantEffectiveGroupMeasure", element.getParticipantEffectiveGroupMeasureElement(), -1); 14064 } 14065 14066 protected void composeResearchStudy(Complex parent, String parentType, String name, ResearchStudy element, int index) { 14067 if (element == null) 14068 return; 14069 Complex t; 14070 if (Utilities.noString(parentType)) 14071 t = parent; 14072 else { 14073 t = parent.predicate("fhir:"+parentType+'.'+name); 14074 } 14075 composeDomainResource(t, "ResearchStudy", name, element, index); 14076 for (int i = 0; i < element.getIdentifier().size(); i++) 14077 composeIdentifier(t, "ResearchStudy", "identifier", element.getIdentifier().get(i), i); 14078 if (element.hasTitleElement()) 14079 composeString(t, "ResearchStudy", "title", element.getTitleElement(), -1); 14080 for (int i = 0; i < element.getProtocol().size(); i++) 14081 composeReference(t, "ResearchStudy", "protocol", element.getProtocol().get(i), i); 14082 for (int i = 0; i < element.getPartOf().size(); i++) 14083 composeReference(t, "ResearchStudy", "partOf", element.getPartOf().get(i), i); 14084 if (element.hasStatusElement()) 14085 composeEnum(t, "ResearchStudy", "status", element.getStatusElement(), -1); 14086 if (element.hasPrimaryPurposeType()) 14087 composeCodeableConcept(t, "ResearchStudy", "primaryPurposeType", element.getPrimaryPurposeType(), -1); 14088 if (element.hasPhase()) 14089 composeCodeableConcept(t, "ResearchStudy", "phase", element.getPhase(), -1); 14090 for (int i = 0; i < element.getCategory().size(); i++) 14091 composeCodeableConcept(t, "ResearchStudy", "category", element.getCategory().get(i), i); 14092 for (int i = 0; i < element.getFocus().size(); i++) 14093 composeCodeableConcept(t, "ResearchStudy", "focus", element.getFocus().get(i), i); 14094 for (int i = 0; i < element.getCondition().size(); i++) 14095 composeCodeableConcept(t, "ResearchStudy", "condition", element.getCondition().get(i), i); 14096 for (int i = 0; i < element.getContact().size(); i++) 14097 composeContactDetail(t, "ResearchStudy", "contact", element.getContact().get(i), i); 14098 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 14099 composeRelatedArtifact(t, "ResearchStudy", "relatedArtifact", element.getRelatedArtifact().get(i), i); 14100 for (int i = 0; i < element.getKeyword().size(); i++) 14101 composeCodeableConcept(t, "ResearchStudy", "keyword", element.getKeyword().get(i), i); 14102 for (int i = 0; i < element.getLocation().size(); i++) 14103 composeCodeableConcept(t, "ResearchStudy", "location", element.getLocation().get(i), i); 14104 if (element.hasDescriptionElement()) 14105 composeMarkdown(t, "ResearchStudy", "description", element.getDescriptionElement(), -1); 14106 for (int i = 0; i < element.getEnrollment().size(); i++) 14107 composeReference(t, "ResearchStudy", "enrollment", element.getEnrollment().get(i), i); 14108 if (element.hasPeriod()) 14109 composePeriod(t, "ResearchStudy", "period", element.getPeriod(), -1); 14110 if (element.hasSponsor()) 14111 composeReference(t, "ResearchStudy", "sponsor", element.getSponsor(), -1); 14112 if (element.hasPrincipalInvestigator()) 14113 composeReference(t, "ResearchStudy", "principalInvestigator", element.getPrincipalInvestigator(), -1); 14114 for (int i = 0; i < element.getSite().size(); i++) 14115 composeReference(t, "ResearchStudy", "site", element.getSite().get(i), i); 14116 if (element.hasReasonStopped()) 14117 composeCodeableConcept(t, "ResearchStudy", "reasonStopped", element.getReasonStopped(), -1); 14118 for (int i = 0; i < element.getNote().size(); i++) 14119 composeAnnotation(t, "ResearchStudy", "note", element.getNote().get(i), i); 14120 for (int i = 0; i < element.getArm().size(); i++) 14121 composeResearchStudyResearchStudyArmComponent(t, "ResearchStudy", "arm", element.getArm().get(i), i); 14122 for (int i = 0; i < element.getObjective().size(); i++) 14123 composeResearchStudyResearchStudyObjectiveComponent(t, "ResearchStudy", "objective", element.getObjective().get(i), i); 14124 } 14125 14126 protected void composeResearchStudyResearchStudyArmComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyArmComponent element, int index) { 14127 if (element == null) 14128 return; 14129 Complex t; 14130 if (Utilities.noString(parentType)) 14131 t = parent; 14132 else { 14133 t = parent.predicate("fhir:"+parentType+'.'+name); 14134 } 14135 composeBackboneElement(t, "arm", name, element, index); 14136 if (element.hasNameElement()) 14137 composeString(t, "ResearchStudy", "name", element.getNameElement(), -1); 14138 if (element.hasType()) 14139 composeCodeableConcept(t, "ResearchStudy", "type", element.getType(), -1); 14140 if (element.hasDescriptionElement()) 14141 composeString(t, "ResearchStudy", "description", element.getDescriptionElement(), -1); 14142 } 14143 14144 protected void composeResearchStudyResearchStudyObjectiveComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyObjectiveComponent element, int index) { 14145 if (element == null) 14146 return; 14147 Complex t; 14148 if (Utilities.noString(parentType)) 14149 t = parent; 14150 else { 14151 t = parent.predicate("fhir:"+parentType+'.'+name); 14152 } 14153 composeBackboneElement(t, "objective", name, element, index); 14154 if (element.hasNameElement()) 14155 composeString(t, "ResearchStudy", "name", element.getNameElement(), -1); 14156 if (element.hasType()) 14157 composeCodeableConcept(t, "ResearchStudy", "type", element.getType(), -1); 14158 } 14159 14160 protected void composeResearchSubject(Complex parent, String parentType, String name, ResearchSubject element, int index) { 14161 if (element == null) 14162 return; 14163 Complex t; 14164 if (Utilities.noString(parentType)) 14165 t = parent; 14166 else { 14167 t = parent.predicate("fhir:"+parentType+'.'+name); 14168 } 14169 composeDomainResource(t, "ResearchSubject", name, element, index); 14170 for (int i = 0; i < element.getIdentifier().size(); i++) 14171 composeIdentifier(t, "ResearchSubject", "identifier", element.getIdentifier().get(i), i); 14172 if (element.hasStatusElement()) 14173 composeEnum(t, "ResearchSubject", "status", element.getStatusElement(), -1); 14174 if (element.hasPeriod()) 14175 composePeriod(t, "ResearchSubject", "period", element.getPeriod(), -1); 14176 if (element.hasStudy()) 14177 composeReference(t, "ResearchSubject", "study", element.getStudy(), -1); 14178 if (element.hasIndividual()) 14179 composeReference(t, "ResearchSubject", "individual", element.getIndividual(), -1); 14180 if (element.hasAssignedArmElement()) 14181 composeString(t, "ResearchSubject", "assignedArm", element.getAssignedArmElement(), -1); 14182 if (element.hasActualArmElement()) 14183 composeString(t, "ResearchSubject", "actualArm", element.getActualArmElement(), -1); 14184 if (element.hasConsent()) 14185 composeReference(t, "ResearchSubject", "consent", element.getConsent(), -1); 14186 } 14187 14188 protected void composeRiskAssessment(Complex parent, String parentType, String name, RiskAssessment element, int index) { 14189 if (element == null) 14190 return; 14191 Complex t; 14192 if (Utilities.noString(parentType)) 14193 t = parent; 14194 else { 14195 t = parent.predicate("fhir:"+parentType+'.'+name); 14196 } 14197 composeDomainResource(t, "RiskAssessment", name, element, index); 14198 for (int i = 0; i < element.getIdentifier().size(); i++) 14199 composeIdentifier(t, "RiskAssessment", "identifier", element.getIdentifier().get(i), i); 14200 if (element.hasBasedOn()) 14201 composeReference(t, "RiskAssessment", "basedOn", element.getBasedOn(), -1); 14202 if (element.hasParent()) 14203 composeReference(t, "RiskAssessment", "parent", element.getParent(), -1); 14204 if (element.hasStatusElement()) 14205 composeEnum(t, "RiskAssessment", "status", element.getStatusElement(), -1); 14206 if (element.hasMethod()) 14207 composeCodeableConcept(t, "RiskAssessment", "method", element.getMethod(), -1); 14208 if (element.hasCode()) 14209 composeCodeableConcept(t, "RiskAssessment", "code", element.getCode(), -1); 14210 if (element.hasSubject()) 14211 composeReference(t, "RiskAssessment", "subject", element.getSubject(), -1); 14212 if (element.hasEncounter()) 14213 composeReference(t, "RiskAssessment", "encounter", element.getEncounter(), -1); 14214 if (element.hasOccurrence()) 14215 composeType(t, "RiskAssessment", "occurrence", element.getOccurrence(), -1); 14216 if (element.hasCondition()) 14217 composeReference(t, "RiskAssessment", "condition", element.getCondition(), -1); 14218 if (element.hasPerformer()) 14219 composeReference(t, "RiskAssessment", "performer", element.getPerformer(), -1); 14220 for (int i = 0; i < element.getReasonCode().size(); i++) 14221 composeCodeableConcept(t, "RiskAssessment", "reasonCode", element.getReasonCode().get(i), i); 14222 for (int i = 0; i < element.getReasonReference().size(); i++) 14223 composeReference(t, "RiskAssessment", "reasonReference", element.getReasonReference().get(i), i); 14224 for (int i = 0; i < element.getBasis().size(); i++) 14225 composeReference(t, "RiskAssessment", "basis", element.getBasis().get(i), i); 14226 for (int i = 0; i < element.getPrediction().size(); i++) 14227 composeRiskAssessmentRiskAssessmentPredictionComponent(t, "RiskAssessment", "prediction", element.getPrediction().get(i), i); 14228 if (element.hasMitigationElement()) 14229 composeString(t, "RiskAssessment", "mitigation", element.getMitigationElement(), -1); 14230 for (int i = 0; i < element.getNote().size(); i++) 14231 composeAnnotation(t, "RiskAssessment", "note", element.getNote().get(i), i); 14232 } 14233 14234 protected void composeRiskAssessmentRiskAssessmentPredictionComponent(Complex parent, String parentType, String name, RiskAssessment.RiskAssessmentPredictionComponent element, int index) { 14235 if (element == null) 14236 return; 14237 Complex t; 14238 if (Utilities.noString(parentType)) 14239 t = parent; 14240 else { 14241 t = parent.predicate("fhir:"+parentType+'.'+name); 14242 } 14243 composeBackboneElement(t, "prediction", name, element, index); 14244 if (element.hasOutcome()) 14245 composeCodeableConcept(t, "RiskAssessment", "outcome", element.getOutcome(), -1); 14246 if (element.hasProbability()) 14247 composeType(t, "RiskAssessment", "probability", element.getProbability(), -1); 14248 if (element.hasQualitativeRisk()) 14249 composeCodeableConcept(t, "RiskAssessment", "qualitativeRisk", element.getQualitativeRisk(), -1); 14250 if (element.hasRelativeRiskElement()) 14251 composeDecimal(t, "RiskAssessment", "relativeRisk", element.getRelativeRiskElement(), -1); 14252 if (element.hasWhen()) 14253 composeType(t, "RiskAssessment", "when", element.getWhen(), -1); 14254 if (element.hasRationaleElement()) 14255 composeString(t, "RiskAssessment", "rationale", element.getRationaleElement(), -1); 14256 } 14257 14258 protected void composeRiskEvidenceSynthesis(Complex parent, String parentType, String name, RiskEvidenceSynthesis element, int index) { 14259 if (element == null) 14260 return; 14261 Complex t; 14262 if (Utilities.noString(parentType)) 14263 t = parent; 14264 else { 14265 t = parent.predicate("fhir:"+parentType+'.'+name); 14266 } 14267 composeDomainResource(t, "RiskEvidenceSynthesis", name, element, index); 14268 if (element.hasUrlElement()) 14269 composeUri(t, "RiskEvidenceSynthesis", "url", element.getUrlElement(), -1); 14270 for (int i = 0; i < element.getIdentifier().size(); i++) 14271 composeIdentifier(t, "RiskEvidenceSynthesis", "identifier", element.getIdentifier().get(i), i); 14272 if (element.hasVersionElement()) 14273 composeString(t, "RiskEvidenceSynthesis", "version", element.getVersionElement(), -1); 14274 if (element.hasNameElement()) 14275 composeString(t, "RiskEvidenceSynthesis", "name", element.getNameElement(), -1); 14276 if (element.hasTitleElement()) 14277 composeString(t, "RiskEvidenceSynthesis", "title", element.getTitleElement(), -1); 14278 if (element.hasStatusElement()) 14279 composeEnum(t, "RiskEvidenceSynthesis", "status", element.getStatusElement(), -1); 14280 if (element.hasDateElement()) 14281 composeDateTime(t, "RiskEvidenceSynthesis", "date", element.getDateElement(), -1); 14282 if (element.hasPublisherElement()) 14283 composeString(t, "RiskEvidenceSynthesis", "publisher", element.getPublisherElement(), -1); 14284 for (int i = 0; i < element.getContact().size(); i++) 14285 composeContactDetail(t, "RiskEvidenceSynthesis", "contact", element.getContact().get(i), i); 14286 if (element.hasDescriptionElement()) 14287 composeMarkdown(t, "RiskEvidenceSynthesis", "description", element.getDescriptionElement(), -1); 14288 for (int i = 0; i < element.getNote().size(); i++) 14289 composeAnnotation(t, "RiskEvidenceSynthesis", "note", element.getNote().get(i), i); 14290 for (int i = 0; i < element.getUseContext().size(); i++) 14291 composeUsageContext(t, "RiskEvidenceSynthesis", "useContext", element.getUseContext().get(i), i); 14292 for (int i = 0; i < element.getJurisdiction().size(); i++) 14293 composeCodeableConcept(t, "RiskEvidenceSynthesis", "jurisdiction", element.getJurisdiction().get(i), i); 14294 if (element.hasCopyrightElement()) 14295 composeMarkdown(t, "RiskEvidenceSynthesis", "copyright", element.getCopyrightElement(), -1); 14296 if (element.hasApprovalDateElement()) 14297 composeDate(t, "RiskEvidenceSynthesis", "approvalDate", element.getApprovalDateElement(), -1); 14298 if (element.hasLastReviewDateElement()) 14299 composeDate(t, "RiskEvidenceSynthesis", "lastReviewDate", element.getLastReviewDateElement(), -1); 14300 if (element.hasEffectivePeriod()) 14301 composePeriod(t, "RiskEvidenceSynthesis", "effectivePeriod", element.getEffectivePeriod(), -1); 14302 for (int i = 0; i < element.getTopic().size(); i++) 14303 composeCodeableConcept(t, "RiskEvidenceSynthesis", "topic", element.getTopic().get(i), i); 14304 for (int i = 0; i < element.getAuthor().size(); i++) 14305 composeContactDetail(t, "RiskEvidenceSynthesis", "author", element.getAuthor().get(i), i); 14306 for (int i = 0; i < element.getEditor().size(); i++) 14307 composeContactDetail(t, "RiskEvidenceSynthesis", "editor", element.getEditor().get(i), i); 14308 for (int i = 0; i < element.getReviewer().size(); i++) 14309 composeContactDetail(t, "RiskEvidenceSynthesis", "reviewer", element.getReviewer().get(i), i); 14310 for (int i = 0; i < element.getEndorser().size(); i++) 14311 composeContactDetail(t, "RiskEvidenceSynthesis", "endorser", element.getEndorser().get(i), i); 14312 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 14313 composeRelatedArtifact(t, "RiskEvidenceSynthesis", "relatedArtifact", element.getRelatedArtifact().get(i), i); 14314 if (element.hasSynthesisType()) 14315 composeCodeableConcept(t, "RiskEvidenceSynthesis", "synthesisType", element.getSynthesisType(), -1); 14316 if (element.hasStudyType()) 14317 composeCodeableConcept(t, "RiskEvidenceSynthesis", "studyType", element.getStudyType(), -1); 14318 if (element.hasPopulation()) 14319 composeReference(t, "RiskEvidenceSynthesis", "population", element.getPopulation(), -1); 14320 if (element.hasExposure()) 14321 composeReference(t, "RiskEvidenceSynthesis", "exposure", element.getExposure(), -1); 14322 if (element.hasOutcome()) 14323 composeReference(t, "RiskEvidenceSynthesis", "outcome", element.getOutcome(), -1); 14324 if (element.hasSampleSize()) 14325 composeRiskEvidenceSynthesisRiskEvidenceSynthesisSampleSizeComponent(t, "RiskEvidenceSynthesis", "sampleSize", element.getSampleSize(), -1); 14326 if (element.hasRiskEstimate()) 14327 composeRiskEvidenceSynthesisRiskEvidenceSynthesisRiskEstimateComponent(t, "RiskEvidenceSynthesis", "riskEstimate", element.getRiskEstimate(), -1); 14328 for (int i = 0; i < element.getCertainty().size(); i++) 14329 composeRiskEvidenceSynthesisRiskEvidenceSynthesisCertaintyComponent(t, "RiskEvidenceSynthesis", "certainty", element.getCertainty().get(i), i); 14330 } 14331 14332 protected void composeRiskEvidenceSynthesisRiskEvidenceSynthesisSampleSizeComponent(Complex parent, String parentType, String name, RiskEvidenceSynthesis.RiskEvidenceSynthesisSampleSizeComponent element, int index) { 14333 if (element == null) 14334 return; 14335 Complex t; 14336 if (Utilities.noString(parentType)) 14337 t = parent; 14338 else { 14339 t = parent.predicate("fhir:"+parentType+'.'+name); 14340 } 14341 composeBackboneElement(t, "sampleSize", name, element, index); 14342 if (element.hasDescriptionElement()) 14343 composeString(t, "RiskEvidenceSynthesis", "description", element.getDescriptionElement(), -1); 14344 if (element.hasNumberOfStudiesElement()) 14345 composeInteger(t, "RiskEvidenceSynthesis", "numberOfStudies", element.getNumberOfStudiesElement(), -1); 14346 if (element.hasNumberOfParticipantsElement()) 14347 composeInteger(t, "RiskEvidenceSynthesis", "numberOfParticipants", element.getNumberOfParticipantsElement(), -1); 14348 } 14349 14350 protected void composeRiskEvidenceSynthesisRiskEvidenceSynthesisRiskEstimateComponent(Complex parent, String parentType, String name, RiskEvidenceSynthesis.RiskEvidenceSynthesisRiskEstimateComponent element, int index) { 14351 if (element == null) 14352 return; 14353 Complex t; 14354 if (Utilities.noString(parentType)) 14355 t = parent; 14356 else { 14357 t = parent.predicate("fhir:"+parentType+'.'+name); 14358 } 14359 composeBackboneElement(t, "riskEstimate", name, element, index); 14360 if (element.hasDescriptionElement()) 14361 composeString(t, "RiskEvidenceSynthesis", "description", element.getDescriptionElement(), -1); 14362 if (element.hasType()) 14363 composeCodeableConcept(t, "RiskEvidenceSynthesis", "type", element.getType(), -1); 14364 if (element.hasValueElement()) 14365 composeDecimal(t, "RiskEvidenceSynthesis", "value", element.getValueElement(), -1); 14366 if (element.hasUnitOfMeasure()) 14367 composeCodeableConcept(t, "RiskEvidenceSynthesis", "unitOfMeasure", element.getUnitOfMeasure(), -1); 14368 if (element.hasDenominatorCountElement()) 14369 composeInteger(t, "RiskEvidenceSynthesis", "denominatorCount", element.getDenominatorCountElement(), -1); 14370 if (element.hasNumeratorCountElement()) 14371 composeInteger(t, "RiskEvidenceSynthesis", "numeratorCount", element.getNumeratorCountElement(), -1); 14372 for (int i = 0; i < element.getPrecisionEstimate().size(); i++) 14373 composeRiskEvidenceSynthesisRiskEvidenceSynthesisRiskEstimatePrecisionEstimateComponent(t, "RiskEvidenceSynthesis", "precisionEstimate", element.getPrecisionEstimate().get(i), i); 14374 } 14375 14376 protected void composeRiskEvidenceSynthesisRiskEvidenceSynthesisRiskEstimatePrecisionEstimateComponent(Complex parent, String parentType, String name, RiskEvidenceSynthesis.RiskEvidenceSynthesisRiskEstimatePrecisionEstimateComponent element, int index) { 14377 if (element == null) 14378 return; 14379 Complex t; 14380 if (Utilities.noString(parentType)) 14381 t = parent; 14382 else { 14383 t = parent.predicate("fhir:"+parentType+'.'+name); 14384 } 14385 composeBackboneElement(t, "precisionEstimate", name, element, index); 14386 if (element.hasType()) 14387 composeCodeableConcept(t, "RiskEvidenceSynthesis", "type", element.getType(), -1); 14388 if (element.hasLevelElement()) 14389 composeDecimal(t, "RiskEvidenceSynthesis", "level", element.getLevelElement(), -1); 14390 if (element.hasFromElement()) 14391 composeDecimal(t, "RiskEvidenceSynthesis", "from", element.getFromElement(), -1); 14392 if (element.hasToElement()) 14393 composeDecimal(t, "RiskEvidenceSynthesis", "to", element.getToElement(), -1); 14394 } 14395 14396 protected void composeRiskEvidenceSynthesisRiskEvidenceSynthesisCertaintyComponent(Complex parent, String parentType, String name, RiskEvidenceSynthesis.RiskEvidenceSynthesisCertaintyComponent element, int index) { 14397 if (element == null) 14398 return; 14399 Complex t; 14400 if (Utilities.noString(parentType)) 14401 t = parent; 14402 else { 14403 t = parent.predicate("fhir:"+parentType+'.'+name); 14404 } 14405 composeBackboneElement(t, "certainty", name, element, index); 14406 for (int i = 0; i < element.getRating().size(); i++) 14407 composeCodeableConcept(t, "RiskEvidenceSynthesis", "rating", element.getRating().get(i), i); 14408 for (int i = 0; i < element.getNote().size(); i++) 14409 composeAnnotation(t, "RiskEvidenceSynthesis", "note", element.getNote().get(i), i); 14410 for (int i = 0; i < element.getCertaintySubcomponent().size(); i++) 14411 composeRiskEvidenceSynthesisRiskEvidenceSynthesisCertaintyCertaintySubcomponentComponent(t, "RiskEvidenceSynthesis", "certaintySubcomponent", element.getCertaintySubcomponent().get(i), i); 14412 } 14413 14414 protected void composeRiskEvidenceSynthesisRiskEvidenceSynthesisCertaintyCertaintySubcomponentComponent(Complex parent, String parentType, String name, RiskEvidenceSynthesis.RiskEvidenceSynthesisCertaintyCertaintySubcomponentComponent element, int index) { 14415 if (element == null) 14416 return; 14417 Complex t; 14418 if (Utilities.noString(parentType)) 14419 t = parent; 14420 else { 14421 t = parent.predicate("fhir:"+parentType+'.'+name); 14422 } 14423 composeBackboneElement(t, "certaintySubcomponent", name, element, index); 14424 if (element.hasType()) 14425 composeCodeableConcept(t, "RiskEvidenceSynthesis", "type", element.getType(), -1); 14426 for (int i = 0; i < element.getRating().size(); i++) 14427 composeCodeableConcept(t, "RiskEvidenceSynthesis", "rating", element.getRating().get(i), i); 14428 for (int i = 0; i < element.getNote().size(); i++) 14429 composeAnnotation(t, "RiskEvidenceSynthesis", "note", element.getNote().get(i), i); 14430 } 14431 14432 protected void composeSchedule(Complex parent, String parentType, String name, Schedule element, int index) { 14433 if (element == null) 14434 return; 14435 Complex t; 14436 if (Utilities.noString(parentType)) 14437 t = parent; 14438 else { 14439 t = parent.predicate("fhir:"+parentType+'.'+name); 14440 } 14441 composeDomainResource(t, "Schedule", name, element, index); 14442 for (int i = 0; i < element.getIdentifier().size(); i++) 14443 composeIdentifier(t, "Schedule", "identifier", element.getIdentifier().get(i), i); 14444 if (element.hasActiveElement()) 14445 composeBoolean(t, "Schedule", "active", element.getActiveElement(), -1); 14446 for (int i = 0; i < element.getServiceCategory().size(); i++) 14447 composeCodeableConcept(t, "Schedule", "serviceCategory", element.getServiceCategory().get(i), i); 14448 for (int i = 0; i < element.getServiceType().size(); i++) 14449 composeCodeableConcept(t, "Schedule", "serviceType", element.getServiceType().get(i), i); 14450 for (int i = 0; i < element.getSpecialty().size(); i++) 14451 composeCodeableConcept(t, "Schedule", "specialty", element.getSpecialty().get(i), i); 14452 for (int i = 0; i < element.getActor().size(); i++) 14453 composeReference(t, "Schedule", "actor", element.getActor().get(i), i); 14454 if (element.hasPlanningHorizon()) 14455 composePeriod(t, "Schedule", "planningHorizon", element.getPlanningHorizon(), -1); 14456 if (element.hasCommentElement()) 14457 composeString(t, "Schedule", "comment", element.getCommentElement(), -1); 14458 } 14459 14460 protected void composeSearchParameter(Complex parent, String parentType, String name, SearchParameter element, int index) { 14461 if (element == null) 14462 return; 14463 Complex t; 14464 if (Utilities.noString(parentType)) 14465 t = parent; 14466 else { 14467 t = parent.predicate("fhir:"+parentType+'.'+name); 14468 } 14469 composeDomainResource(t, "SearchParameter", name, element, index); 14470 if (element.hasUrlElement()) 14471 composeUri(t, "SearchParameter", "url", element.getUrlElement(), -1); 14472 if (element.hasVersionElement()) 14473 composeString(t, "SearchParameter", "version", element.getVersionElement(), -1); 14474 if (element.hasNameElement()) 14475 composeString(t, "SearchParameter", "name", element.getNameElement(), -1); 14476 if (element.hasDerivedFromElement()) 14477 composeCanonical(t, "SearchParameter", "derivedFrom", element.getDerivedFromElement(), -1); 14478 if (element.hasStatusElement()) 14479 composeEnum(t, "SearchParameter", "status", element.getStatusElement(), -1); 14480 if (element.hasExperimentalElement()) 14481 composeBoolean(t, "SearchParameter", "experimental", element.getExperimentalElement(), -1); 14482 if (element.hasDateElement()) 14483 composeDateTime(t, "SearchParameter", "date", element.getDateElement(), -1); 14484 if (element.hasPublisherElement()) 14485 composeString(t, "SearchParameter", "publisher", element.getPublisherElement(), -1); 14486 for (int i = 0; i < element.getContact().size(); i++) 14487 composeContactDetail(t, "SearchParameter", "contact", element.getContact().get(i), i); 14488 if (element.hasDescriptionElement()) 14489 composeMarkdown(t, "SearchParameter", "description", element.getDescriptionElement(), -1); 14490 for (int i = 0; i < element.getUseContext().size(); i++) 14491 composeUsageContext(t, "SearchParameter", "useContext", element.getUseContext().get(i), i); 14492 for (int i = 0; i < element.getJurisdiction().size(); i++) 14493 composeCodeableConcept(t, "SearchParameter", "jurisdiction", element.getJurisdiction().get(i), i); 14494 if (element.hasPurposeElement()) 14495 composeMarkdown(t, "SearchParameter", "purpose", element.getPurposeElement(), -1); 14496 if (element.hasCodeElement()) 14497 composeCode(t, "SearchParameter", "code", element.getCodeElement(), -1); 14498 for (int i = 0; i < element.getBase().size(); i++) 14499 composeCode(t, "SearchParameter", "base", element.getBase().get(i), i); 14500 if (element.hasTypeElement()) 14501 composeEnum(t, "SearchParameter", "type", element.getTypeElement(), -1); 14502 if (element.hasExpressionElement()) 14503 composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1); 14504 if (element.hasXpathElement()) 14505 composeString(t, "SearchParameter", "xpath", element.getXpathElement(), -1); 14506 if (element.hasXpathUsageElement()) 14507 composeEnum(t, "SearchParameter", "xpathUsage", element.getXpathUsageElement(), -1); 14508 for (int i = 0; i < element.getTarget().size(); i++) 14509 composeCode(t, "SearchParameter", "target", element.getTarget().get(i), i); 14510 if (element.hasMultipleOrElement()) 14511 composeBoolean(t, "SearchParameter", "multipleOr", element.getMultipleOrElement(), -1); 14512 if (element.hasMultipleAndElement()) 14513 composeBoolean(t, "SearchParameter", "multipleAnd", element.getMultipleAndElement(), -1); 14514 for (int i = 0; i < element.getComparator().size(); i++) 14515 composeEnum(t, "SearchParameter", "comparator", element.getComparator().get(i), i); 14516 for (int i = 0; i < element.getModifier().size(); i++) 14517 composeEnum(t, "SearchParameter", "modifier", element.getModifier().get(i), i); 14518 for (int i = 0; i < element.getChain().size(); i++) 14519 composeString(t, "SearchParameter", "chain", element.getChain().get(i), i); 14520 for (int i = 0; i < element.getComponent().size(); i++) 14521 composeSearchParameterSearchParameterComponentComponent(t, "SearchParameter", "component", element.getComponent().get(i), i); 14522 } 14523 14524 protected void composeSearchParameterSearchParameterComponentComponent(Complex parent, String parentType, String name, SearchParameter.SearchParameterComponentComponent element, int index) { 14525 if (element == null) 14526 return; 14527 Complex t; 14528 if (Utilities.noString(parentType)) 14529 t = parent; 14530 else { 14531 t = parent.predicate("fhir:"+parentType+'.'+name); 14532 } 14533 composeBackboneElement(t, "component", name, element, index); 14534 if (element.hasDefinitionElement()) 14535 composeCanonical(t, "SearchParameter", "definition", element.getDefinitionElement(), -1); 14536 if (element.hasExpressionElement()) 14537 composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1); 14538 } 14539 14540 protected void composeServiceRequest(Complex parent, String parentType, String name, ServiceRequest element, int index) { 14541 if (element == null) 14542 return; 14543 Complex t; 14544 if (Utilities.noString(parentType)) 14545 t = parent; 14546 else { 14547 t = parent.predicate("fhir:"+parentType+'.'+name); 14548 } 14549 composeDomainResource(t, "ServiceRequest", name, element, index); 14550 for (int i = 0; i < element.getIdentifier().size(); i++) 14551 composeIdentifier(t, "ServiceRequest", "identifier", element.getIdentifier().get(i), i); 14552 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) 14553 composeCanonical(t, "ServiceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 14554 for (int i = 0; i < element.getInstantiatesUri().size(); i++) 14555 composeUri(t, "ServiceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i); 14556 for (int i = 0; i < element.getBasedOn().size(); i++) 14557 composeReference(t, "ServiceRequest", "basedOn", element.getBasedOn().get(i), i); 14558 for (int i = 0; i < element.getReplaces().size(); i++) 14559 composeReference(t, "ServiceRequest", "replaces", element.getReplaces().get(i), i); 14560 if (element.hasRequisition()) 14561 composeIdentifier(t, "ServiceRequest", "requisition", element.getRequisition(), -1); 14562 if (element.hasStatusElement()) 14563 composeEnum(t, "ServiceRequest", "status", element.getStatusElement(), -1); 14564 if (element.hasIntentElement()) 14565 composeEnum(t, "ServiceRequest", "intent", element.getIntentElement(), -1); 14566 for (int i = 0; i < element.getCategory().size(); i++) 14567 composeCodeableConcept(t, "ServiceRequest", "category", element.getCategory().get(i), i); 14568 if (element.hasPriorityElement()) 14569 composeEnum(t, "ServiceRequest", "priority", element.getPriorityElement(), -1); 14570 if (element.hasDoNotPerformElement()) 14571 composeBoolean(t, "ServiceRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 14572 if (element.hasCode()) 14573 composeCodeableConcept(t, "ServiceRequest", "code", element.getCode(), -1); 14574 for (int i = 0; i < element.getOrderDetail().size(); i++) 14575 composeCodeableConcept(t, "ServiceRequest", "orderDetail", element.getOrderDetail().get(i), i); 14576 if (element.hasQuantity()) 14577 composeType(t, "ServiceRequest", "quantity", element.getQuantity(), -1); 14578 if (element.hasSubject()) 14579 composeReference(t, "ServiceRequest", "subject", element.getSubject(), -1); 14580 if (element.hasEncounter()) 14581 composeReference(t, "ServiceRequest", "encounter", element.getEncounter(), -1); 14582 if (element.hasOccurrence()) 14583 composeType(t, "ServiceRequest", "occurrence", element.getOccurrence(), -1); 14584 if (element.hasAsNeeded()) 14585 composeType(t, "ServiceRequest", "asNeeded", element.getAsNeeded(), -1); 14586 if (element.hasAuthoredOnElement()) 14587 composeDateTime(t, "ServiceRequest", "authoredOn", element.getAuthoredOnElement(), -1); 14588 if (element.hasRequester()) 14589 composeReference(t, "ServiceRequest", "requester", element.getRequester(), -1); 14590 if (element.hasPerformerType()) 14591 composeCodeableConcept(t, "ServiceRequest", "performerType", element.getPerformerType(), -1); 14592 for (int i = 0; i < element.getPerformer().size(); i++) 14593 composeReference(t, "ServiceRequest", "performer", element.getPerformer().get(i), i); 14594 for (int i = 0; i < element.getLocationCode().size(); i++) 14595 composeCodeableConcept(t, "ServiceRequest", "locationCode", element.getLocationCode().get(i), i); 14596 for (int i = 0; i < element.getLocationReference().size(); i++) 14597 composeReference(t, "ServiceRequest", "locationReference", element.getLocationReference().get(i), i); 14598 for (int i = 0; i < element.getReasonCode().size(); i++) 14599 composeCodeableConcept(t, "ServiceRequest", "reasonCode", element.getReasonCode().get(i), i); 14600 for (int i = 0; i < element.getReasonReference().size(); i++) 14601 composeReference(t, "ServiceRequest", "reasonReference", element.getReasonReference().get(i), i); 14602 for (int i = 0; i < element.getInsurance().size(); i++) 14603 composeReference(t, "ServiceRequest", "insurance", element.getInsurance().get(i), i); 14604 for (int i = 0; i < element.getSupportingInfo().size(); i++) 14605 composeReference(t, "ServiceRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 14606 for (int i = 0; i < element.getSpecimen().size(); i++) 14607 composeReference(t, "ServiceRequest", "specimen", element.getSpecimen().get(i), i); 14608 for (int i = 0; i < element.getBodySite().size(); i++) 14609 composeCodeableConcept(t, "ServiceRequest", "bodySite", element.getBodySite().get(i), i); 14610 for (int i = 0; i < element.getNote().size(); i++) 14611 composeAnnotation(t, "ServiceRequest", "note", element.getNote().get(i), i); 14612 if (element.hasPatientInstructionElement()) 14613 composeString(t, "ServiceRequest", "patientInstruction", element.getPatientInstructionElement(), -1); 14614 for (int i = 0; i < element.getRelevantHistory().size(); i++) 14615 composeReference(t, "ServiceRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 14616 } 14617 14618 protected void composeSlot(Complex parent, String parentType, String name, Slot element, int index) { 14619 if (element == null) 14620 return; 14621 Complex t; 14622 if (Utilities.noString(parentType)) 14623 t = parent; 14624 else { 14625 t = parent.predicate("fhir:"+parentType+'.'+name); 14626 } 14627 composeDomainResource(t, "Slot", name, element, index); 14628 for (int i = 0; i < element.getIdentifier().size(); i++) 14629 composeIdentifier(t, "Slot", "identifier", element.getIdentifier().get(i), i); 14630 for (int i = 0; i < element.getServiceCategory().size(); i++) 14631 composeCodeableConcept(t, "Slot", "serviceCategory", element.getServiceCategory().get(i), i); 14632 for (int i = 0; i < element.getServiceType().size(); i++) 14633 composeCodeableConcept(t, "Slot", "serviceType", element.getServiceType().get(i), i); 14634 for (int i = 0; i < element.getSpecialty().size(); i++) 14635 composeCodeableConcept(t, "Slot", "specialty", element.getSpecialty().get(i), i); 14636 if (element.hasAppointmentType()) 14637 composeCodeableConcept(t, "Slot", "appointmentType", element.getAppointmentType(), -1); 14638 if (element.hasSchedule()) 14639 composeReference(t, "Slot", "schedule", element.getSchedule(), -1); 14640 if (element.hasStatusElement()) 14641 composeEnum(t, "Slot", "status", element.getStatusElement(), -1); 14642 if (element.hasStartElement()) 14643 composeInstant(t, "Slot", "start", element.getStartElement(), -1); 14644 if (element.hasEndElement()) 14645 composeInstant(t, "Slot", "end", element.getEndElement(), -1); 14646 if (element.hasOverbookedElement()) 14647 composeBoolean(t, "Slot", "overbooked", element.getOverbookedElement(), -1); 14648 if (element.hasCommentElement()) 14649 composeString(t, "Slot", "comment", element.getCommentElement(), -1); 14650 } 14651 14652 protected void composeSpecimen(Complex parent, String parentType, String name, Specimen element, int index) { 14653 if (element == null) 14654 return; 14655 Complex t; 14656 if (Utilities.noString(parentType)) 14657 t = parent; 14658 else { 14659 t = parent.predicate("fhir:"+parentType+'.'+name); 14660 } 14661 composeDomainResource(t, "Specimen", name, element, index); 14662 for (int i = 0; i < element.getIdentifier().size(); i++) 14663 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 14664 if (element.hasAccessionIdentifier()) 14665 composeIdentifier(t, "Specimen", "accessionIdentifier", element.getAccessionIdentifier(), -1); 14666 if (element.hasStatusElement()) 14667 composeEnum(t, "Specimen", "status", element.getStatusElement(), -1); 14668 if (element.hasType()) 14669 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 14670 if (element.hasSubject()) 14671 composeReference(t, "Specimen", "subject", element.getSubject(), -1); 14672 if (element.hasReceivedTimeElement()) 14673 composeDateTime(t, "Specimen", "receivedTime", element.getReceivedTimeElement(), -1); 14674 for (int i = 0; i < element.getParent().size(); i++) 14675 composeReference(t, "Specimen", "parent", element.getParent().get(i), i); 14676 for (int i = 0; i < element.getRequest().size(); i++) 14677 composeReference(t, "Specimen", "request", element.getRequest().get(i), i); 14678 if (element.hasCollection()) 14679 composeSpecimenSpecimenCollectionComponent(t, "Specimen", "collection", element.getCollection(), -1); 14680 for (int i = 0; i < element.getProcessing().size(); i++) 14681 composeSpecimenSpecimenProcessingComponent(t, "Specimen", "processing", element.getProcessing().get(i), i); 14682 for (int i = 0; i < element.getContainer().size(); i++) 14683 composeSpecimenSpecimenContainerComponent(t, "Specimen", "container", element.getContainer().get(i), i); 14684 for (int i = 0; i < element.getCondition().size(); i++) 14685 composeCodeableConcept(t, "Specimen", "condition", element.getCondition().get(i), i); 14686 for (int i = 0; i < element.getNote().size(); i++) 14687 composeAnnotation(t, "Specimen", "note", element.getNote().get(i), i); 14688 } 14689 14690 protected void composeSpecimenSpecimenCollectionComponent(Complex parent, String parentType, String name, Specimen.SpecimenCollectionComponent element, int index) { 14691 if (element == null) 14692 return; 14693 Complex t; 14694 if (Utilities.noString(parentType)) 14695 t = parent; 14696 else { 14697 t = parent.predicate("fhir:"+parentType+'.'+name); 14698 } 14699 composeBackboneElement(t, "collection", name, element, index); 14700 if (element.hasCollector()) 14701 composeReference(t, "Specimen", "collector", element.getCollector(), -1); 14702 if (element.hasCollected()) 14703 composeType(t, "Specimen", "collected", element.getCollected(), -1); 14704 if (element.hasDuration()) 14705 composeDuration(t, "Specimen", "duration", element.getDuration(), -1); 14706 if (element.hasQuantity()) 14707 composeQuantity(t, "Specimen", "quantity", element.getQuantity(), -1); 14708 if (element.hasMethod()) 14709 composeCodeableConcept(t, "Specimen", "method", element.getMethod(), -1); 14710 if (element.hasBodySite()) 14711 composeCodeableConcept(t, "Specimen", "bodySite", element.getBodySite(), -1); 14712 if (element.hasFastingStatus()) 14713 composeType(t, "Specimen", "fastingStatus", element.getFastingStatus(), -1); 14714 } 14715 14716 protected void composeSpecimenSpecimenProcessingComponent(Complex parent, String parentType, String name, Specimen.SpecimenProcessingComponent element, int index) { 14717 if (element == null) 14718 return; 14719 Complex t; 14720 if (Utilities.noString(parentType)) 14721 t = parent; 14722 else { 14723 t = parent.predicate("fhir:"+parentType+'.'+name); 14724 } 14725 composeBackboneElement(t, "processing", name, element, index); 14726 if (element.hasDescriptionElement()) 14727 composeString(t, "Specimen", "description", element.getDescriptionElement(), -1); 14728 if (element.hasProcedure()) 14729 composeCodeableConcept(t, "Specimen", "procedure", element.getProcedure(), -1); 14730 for (int i = 0; i < element.getAdditive().size(); i++) 14731 composeReference(t, "Specimen", "additive", element.getAdditive().get(i), i); 14732 if (element.hasTime()) 14733 composeType(t, "Specimen", "time", element.getTime(), -1); 14734 } 14735 14736 protected void composeSpecimenSpecimenContainerComponent(Complex parent, String parentType, String name, Specimen.SpecimenContainerComponent element, int index) { 14737 if (element == null) 14738 return; 14739 Complex t; 14740 if (Utilities.noString(parentType)) 14741 t = parent; 14742 else { 14743 t = parent.predicate("fhir:"+parentType+'.'+name); 14744 } 14745 composeBackboneElement(t, "container", name, element, index); 14746 for (int i = 0; i < element.getIdentifier().size(); i++) 14747 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 14748 if (element.hasDescriptionElement()) 14749 composeString(t, "Specimen", "description", element.getDescriptionElement(), -1); 14750 if (element.hasType()) 14751 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 14752 if (element.hasCapacity()) 14753 composeQuantity(t, "Specimen", "capacity", element.getCapacity(), -1); 14754 if (element.hasSpecimenQuantity()) 14755 composeQuantity(t, "Specimen", "specimenQuantity", element.getSpecimenQuantity(), -1); 14756 if (element.hasAdditive()) 14757 composeType(t, "Specimen", "additive", element.getAdditive(), -1); 14758 } 14759 14760 protected void composeSpecimenDefinition(Complex parent, String parentType, String name, SpecimenDefinition element, int index) { 14761 if (element == null) 14762 return; 14763 Complex t; 14764 if (Utilities.noString(parentType)) 14765 t = parent; 14766 else { 14767 t = parent.predicate("fhir:"+parentType+'.'+name); 14768 } 14769 composeDomainResource(t, "SpecimenDefinition", name, element, index); 14770 if (element.hasIdentifier()) 14771 composeIdentifier(t, "SpecimenDefinition", "identifier", element.getIdentifier(), -1); 14772 if (element.hasTypeCollected()) 14773 composeCodeableConcept(t, "SpecimenDefinition", "typeCollected", element.getTypeCollected(), -1); 14774 for (int i = 0; i < element.getPatientPreparation().size(); i++) 14775 composeCodeableConcept(t, "SpecimenDefinition", "patientPreparation", element.getPatientPreparation().get(i), i); 14776 if (element.hasTimeAspectElement()) 14777 composeString(t, "SpecimenDefinition", "timeAspect", element.getTimeAspectElement(), -1); 14778 for (int i = 0; i < element.getCollection().size(); i++) 14779 composeCodeableConcept(t, "SpecimenDefinition", "collection", element.getCollection().get(i), i); 14780 for (int i = 0; i < element.getTypeTested().size(); i++) 14781 composeSpecimenDefinitionSpecimenDefinitionTypeTestedComponent(t, "SpecimenDefinition", "typeTested", element.getTypeTested().get(i), i); 14782 } 14783 14784 protected void composeSpecimenDefinitionSpecimenDefinitionTypeTestedComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedComponent element, int index) { 14785 if (element == null) 14786 return; 14787 Complex t; 14788 if (Utilities.noString(parentType)) 14789 t = parent; 14790 else { 14791 t = parent.predicate("fhir:"+parentType+'.'+name); 14792 } 14793 composeBackboneElement(t, "typeTested", name, element, index); 14794 if (element.hasIsDerivedElement()) 14795 composeBoolean(t, "SpecimenDefinition", "isDerived", element.getIsDerivedElement(), -1); 14796 if (element.hasType()) 14797 composeCodeableConcept(t, "SpecimenDefinition", "type", element.getType(), -1); 14798 if (element.hasPreferenceElement()) 14799 composeEnum(t, "SpecimenDefinition", "preference", element.getPreferenceElement(), -1); 14800 if (element.hasContainer()) 14801 composeSpecimenDefinitionSpecimenDefinitionTypeTestedContainerComponent(t, "SpecimenDefinition", "container", element.getContainer(), -1); 14802 if (element.hasRequirementElement()) 14803 composeString(t, "SpecimenDefinition", "requirement", element.getRequirementElement(), -1); 14804 if (element.hasRetentionTime()) 14805 composeDuration(t, "SpecimenDefinition", "retentionTime", element.getRetentionTime(), -1); 14806 for (int i = 0; i < element.getRejectionCriterion().size(); i++) 14807 composeCodeableConcept(t, "SpecimenDefinition", "rejectionCriterion", element.getRejectionCriterion().get(i), i); 14808 for (int i = 0; i < element.getHandling().size(); i++) 14809 composeSpecimenDefinitionSpecimenDefinitionTypeTestedHandlingComponent(t, "SpecimenDefinition", "handling", element.getHandling().get(i), i); 14810 } 14811 14812 protected void composeSpecimenDefinitionSpecimenDefinitionTypeTestedContainerComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerComponent element, int index) { 14813 if (element == null) 14814 return; 14815 Complex t; 14816 if (Utilities.noString(parentType)) 14817 t = parent; 14818 else { 14819 t = parent.predicate("fhir:"+parentType+'.'+name); 14820 } 14821 composeBackboneElement(t, "container", name, element, index); 14822 if (element.hasMaterial()) 14823 composeCodeableConcept(t, "SpecimenDefinition", "material", element.getMaterial(), -1); 14824 if (element.hasType()) 14825 composeCodeableConcept(t, "SpecimenDefinition", "type", element.getType(), -1); 14826 if (element.hasCap()) 14827 composeCodeableConcept(t, "SpecimenDefinition", "cap", element.getCap(), -1); 14828 if (element.hasDescriptionElement()) 14829 composeString(t, "SpecimenDefinition", "description", element.getDescriptionElement(), -1); 14830 if (element.hasCapacity()) 14831 composeQuantity(t, "SpecimenDefinition", "capacity", element.getCapacity(), -1); 14832 if (element.hasMinimumVolume()) 14833 composeType(t, "SpecimenDefinition", "minimumVolume", element.getMinimumVolume(), -1); 14834 for (int i = 0; i < element.getAdditive().size(); i++) 14835 composeSpecimenDefinitionSpecimenDefinitionTypeTestedContainerAdditiveComponent(t, "SpecimenDefinition", "additive", element.getAdditive().get(i), i); 14836 if (element.hasPreparationElement()) 14837 composeString(t, "SpecimenDefinition", "preparation", element.getPreparationElement(), -1); 14838 } 14839 14840 protected void composeSpecimenDefinitionSpecimenDefinitionTypeTestedContainerAdditiveComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerAdditiveComponent element, int index) { 14841 if (element == null) 14842 return; 14843 Complex t; 14844 if (Utilities.noString(parentType)) 14845 t = parent; 14846 else { 14847 t = parent.predicate("fhir:"+parentType+'.'+name); 14848 } 14849 composeBackboneElement(t, "additive", name, element, index); 14850 if (element.hasAdditive()) 14851 composeType(t, "SpecimenDefinition", "additive", element.getAdditive(), -1); 14852 } 14853 14854 protected void composeSpecimenDefinitionSpecimenDefinitionTypeTestedHandlingComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedHandlingComponent element, int index) { 14855 if (element == null) 14856 return; 14857 Complex t; 14858 if (Utilities.noString(parentType)) 14859 t = parent; 14860 else { 14861 t = parent.predicate("fhir:"+parentType+'.'+name); 14862 } 14863 composeBackboneElement(t, "handling", name, element, index); 14864 if (element.hasTemperatureQualifier()) 14865 composeCodeableConcept(t, "SpecimenDefinition", "temperatureQualifier", element.getTemperatureQualifier(), -1); 14866 if (element.hasTemperatureRange()) 14867 composeRange(t, "SpecimenDefinition", "temperatureRange", element.getTemperatureRange(), -1); 14868 if (element.hasMaxDuration()) 14869 composeDuration(t, "SpecimenDefinition", "maxDuration", element.getMaxDuration(), -1); 14870 if (element.hasInstructionElement()) 14871 composeString(t, "SpecimenDefinition", "instruction", element.getInstructionElement(), -1); 14872 } 14873 14874 protected void composeStructureDefinition(Complex parent, String parentType, String name, StructureDefinition element, int index) { 14875 if (element == null) 14876 return; 14877 Complex t; 14878 if (Utilities.noString(parentType)) 14879 t = parent; 14880 else { 14881 t = parent.predicate("fhir:"+parentType+'.'+name); 14882 } 14883 composeDomainResource(t, "StructureDefinition", name, element, index); 14884 if (element.hasUrlElement()) 14885 composeUri(t, "StructureDefinition", "url", element.getUrlElement(), -1); 14886 for (int i = 0; i < element.getIdentifier().size(); i++) 14887 composeIdentifier(t, "StructureDefinition", "identifier", element.getIdentifier().get(i), i); 14888 if (element.hasVersionElement()) 14889 composeString(t, "StructureDefinition", "version", element.getVersionElement(), -1); 14890 if (element.hasNameElement()) 14891 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 14892 if (element.hasTitleElement()) 14893 composeString(t, "StructureDefinition", "title", element.getTitleElement(), -1); 14894 if (element.hasStatusElement()) 14895 composeEnum(t, "StructureDefinition", "status", element.getStatusElement(), -1); 14896 if (element.hasExperimentalElement()) 14897 composeBoolean(t, "StructureDefinition", "experimental", element.getExperimentalElement(), -1); 14898 if (element.hasDateElement()) 14899 composeDateTime(t, "StructureDefinition", "date", element.getDateElement(), -1); 14900 if (element.hasPublisherElement()) 14901 composeString(t, "StructureDefinition", "publisher", element.getPublisherElement(), -1); 14902 for (int i = 0; i < element.getContact().size(); i++) 14903 composeContactDetail(t, "StructureDefinition", "contact", element.getContact().get(i), i); 14904 if (element.hasDescriptionElement()) 14905 composeMarkdown(t, "StructureDefinition", "description", element.getDescriptionElement(), -1); 14906 for (int i = 0; i < element.getUseContext().size(); i++) 14907 composeUsageContext(t, "StructureDefinition", "useContext", element.getUseContext().get(i), i); 14908 for (int i = 0; i < element.getJurisdiction().size(); i++) 14909 composeCodeableConcept(t, "StructureDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 14910 if (element.hasPurposeElement()) 14911 composeMarkdown(t, "StructureDefinition", "purpose", element.getPurposeElement(), -1); 14912 if (element.hasCopyrightElement()) 14913 composeMarkdown(t, "StructureDefinition", "copyright", element.getCopyrightElement(), -1); 14914 for (int i = 0; i < element.getKeyword().size(); i++) 14915 composeCoding(t, "StructureDefinition", "keyword", element.getKeyword().get(i), i); 14916 if (element.hasFhirVersionElement()) 14917 composeEnum(t, "StructureDefinition", "fhirVersion", element.getFhirVersionElement(), -1); 14918 for (int i = 0; i < element.getMapping().size(); i++) 14919 composeStructureDefinitionStructureDefinitionMappingComponent(t, "StructureDefinition", "mapping", element.getMapping().get(i), i); 14920 if (element.hasKindElement()) 14921 composeEnum(t, "StructureDefinition", "kind", element.getKindElement(), -1); 14922 if (element.hasAbstractElement()) 14923 composeBoolean(t, "StructureDefinition", "abstract", element.getAbstractElement(), -1); 14924 for (int i = 0; i < element.getContext().size(); i++) 14925 composeStructureDefinitionStructureDefinitionContextComponent(t, "StructureDefinition", "context", element.getContext().get(i), i); 14926 for (int i = 0; i < element.getContextInvariant().size(); i++) 14927 composeString(t, "StructureDefinition", "contextInvariant", element.getContextInvariant().get(i), i); 14928 if (element.hasTypeElement()) 14929 composeUri(t, "StructureDefinition", "type", element.getTypeElement(), -1); 14930 if (element.hasBaseDefinitionElement()) 14931 composeCanonical(t, "StructureDefinition", "baseDefinition", element.getBaseDefinitionElement(), -1); 14932 if (element.hasDerivationElement()) 14933 composeEnum(t, "StructureDefinition", "derivation", element.getDerivationElement(), -1); 14934 if (element.hasSnapshot()) 14935 composeStructureDefinitionStructureDefinitionSnapshotComponent(t, "StructureDefinition", "snapshot", element.getSnapshot(), -1); 14936 if (element.hasDifferential()) 14937 composeStructureDefinitionStructureDefinitionDifferentialComponent(t, "StructureDefinition", "differential", element.getDifferential(), -1); 14938 } 14939 14940 protected void composeStructureDefinitionStructureDefinitionMappingComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionMappingComponent element, int index) { 14941 if (element == null) 14942 return; 14943 Complex t; 14944 if (Utilities.noString(parentType)) 14945 t = parent; 14946 else { 14947 t = parent.predicate("fhir:"+parentType+'.'+name); 14948 } 14949 composeBackboneElement(t, "mapping", name, element, index); 14950 if (element.hasIdentityElement()) 14951 composeId(t, "StructureDefinition", "identity", element.getIdentityElement(), -1); 14952 if (element.hasUriElement()) 14953 composeUri(t, "StructureDefinition", "uri", element.getUriElement(), -1); 14954 if (element.hasNameElement()) 14955 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 14956 if (element.hasCommentElement()) 14957 composeString(t, "StructureDefinition", "comment", element.getCommentElement(), -1); 14958 } 14959 14960 protected void composeStructureDefinitionStructureDefinitionContextComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionContextComponent element, int index) { 14961 if (element == null) 14962 return; 14963 Complex t; 14964 if (Utilities.noString(parentType)) 14965 t = parent; 14966 else { 14967 t = parent.predicate("fhir:"+parentType+'.'+name); 14968 } 14969 composeBackboneElement(t, "context", name, element, index); 14970 if (element.hasTypeElement()) 14971 composeEnum(t, "StructureDefinition", "type", element.getTypeElement(), -1); 14972 if (element.hasExpressionElement()) 14973 composeString(t, "StructureDefinition", "expression", element.getExpressionElement(), -1); 14974 } 14975 14976 protected void composeStructureDefinitionStructureDefinitionSnapshotComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionSnapshotComponent element, int index) { 14977 if (element == null) 14978 return; 14979 Complex t; 14980 if (Utilities.noString(parentType)) 14981 t = parent; 14982 else { 14983 t = parent.predicate("fhir:"+parentType+'.'+name); 14984 } 14985 composeBackboneElement(t, "snapshot", name, element, index); 14986 for (int i = 0; i < element.getElement().size(); i++) 14987 composeElementDefinition(t, "StructureDefinition", "element", element.getElement().get(i), i); 14988 } 14989 14990 protected void composeStructureDefinitionStructureDefinitionDifferentialComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionDifferentialComponent element, int index) { 14991 if (element == null) 14992 return; 14993 Complex t; 14994 if (Utilities.noString(parentType)) 14995 t = parent; 14996 else { 14997 t = parent.predicate("fhir:"+parentType+'.'+name); 14998 } 14999 composeBackboneElement(t, "differential", name, element, index); 15000 for (int i = 0; i < element.getElement().size(); i++) 15001 composeElementDefinition(t, "StructureDefinition", "element", element.getElement().get(i), i); 15002 } 15003 15004 protected void composeStructureMap(Complex parent, String parentType, String name, StructureMap element, int index) { 15005 if (element == null) 15006 return; 15007 Complex t; 15008 if (Utilities.noString(parentType)) 15009 t = parent; 15010 else { 15011 t = parent.predicate("fhir:"+parentType+'.'+name); 15012 } 15013 composeDomainResource(t, "StructureMap", name, element, index); 15014 if (element.hasUrlElement()) 15015 composeUri(t, "StructureMap", "url", element.getUrlElement(), -1); 15016 for (int i = 0; i < element.getIdentifier().size(); i++) 15017 composeIdentifier(t, "StructureMap", "identifier", element.getIdentifier().get(i), i); 15018 if (element.hasVersionElement()) 15019 composeString(t, "StructureMap", "version", element.getVersionElement(), -1); 15020 if (element.hasNameElement()) 15021 composeString(t, "StructureMap", "name", element.getNameElement(), -1); 15022 if (element.hasTitleElement()) 15023 composeString(t, "StructureMap", "title", element.getTitleElement(), -1); 15024 if (element.hasStatusElement()) 15025 composeEnum(t, "StructureMap", "status", element.getStatusElement(), -1); 15026 if (element.hasExperimentalElement()) 15027 composeBoolean(t, "StructureMap", "experimental", element.getExperimentalElement(), -1); 15028 if (element.hasDateElement()) 15029 composeDateTime(t, "StructureMap", "date", element.getDateElement(), -1); 15030 if (element.hasPublisherElement()) 15031 composeString(t, "StructureMap", "publisher", element.getPublisherElement(), -1); 15032 for (int i = 0; i < element.getContact().size(); i++) 15033 composeContactDetail(t, "StructureMap", "contact", element.getContact().get(i), i); 15034 if (element.hasDescriptionElement()) 15035 composeMarkdown(t, "StructureMap", "description", element.getDescriptionElement(), -1); 15036 for (int i = 0; i < element.getUseContext().size(); i++) 15037 composeUsageContext(t, "StructureMap", "useContext", element.getUseContext().get(i), i); 15038 for (int i = 0; i < element.getJurisdiction().size(); i++) 15039 composeCodeableConcept(t, "StructureMap", "jurisdiction", element.getJurisdiction().get(i), i); 15040 if (element.hasPurposeElement()) 15041 composeMarkdown(t, "StructureMap", "purpose", element.getPurposeElement(), -1); 15042 if (element.hasCopyrightElement()) 15043 composeMarkdown(t, "StructureMap", "copyright", element.getCopyrightElement(), -1); 15044 for (int i = 0; i < element.getStructure().size(); i++) 15045 composeStructureMapStructureMapStructureComponent(t, "StructureMap", "structure", element.getStructure().get(i), i); 15046 for (int i = 0; i < element.getImport().size(); i++) 15047 composeCanonical(t, "StructureMap", "import", element.getImport().get(i), i); 15048 for (int i = 0; i < element.getGroup().size(); i++) 15049 composeStructureMapStructureMapGroupComponent(t, "StructureMap", "group", element.getGroup().get(i), i); 15050 } 15051 15052 protected void composeStructureMapStructureMapStructureComponent(Complex parent, String parentType, String name, StructureMap.StructureMapStructureComponent element, int index) { 15053 if (element == null) 15054 return; 15055 Complex t; 15056 if (Utilities.noString(parentType)) 15057 t = parent; 15058 else { 15059 t = parent.predicate("fhir:"+parentType+'.'+name); 15060 } 15061 composeBackboneElement(t, "structure", name, element, index); 15062 if (element.hasUrlElement()) 15063 composeCanonical(t, "StructureMap", "url", element.getUrlElement(), -1); 15064 if (element.hasModeElement()) 15065 composeEnum(t, "StructureMap", "mode", element.getModeElement(), -1); 15066 if (element.hasAliasElement()) 15067 composeString(t, "StructureMap", "alias", element.getAliasElement(), -1); 15068 if (element.hasDocumentationElement()) 15069 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 15070 } 15071 15072 protected void composeStructureMapStructureMapGroupComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupComponent element, int index) { 15073 if (element == null) 15074 return; 15075 Complex t; 15076 if (Utilities.noString(parentType)) 15077 t = parent; 15078 else { 15079 t = parent.predicate("fhir:"+parentType+'.'+name); 15080 } 15081 composeBackboneElement(t, "group", name, element, index); 15082 if (element.hasNameElement()) 15083 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 15084 if (element.hasExtendsElement()) 15085 composeId(t, "StructureMap", "extends", element.getExtendsElement(), -1); 15086 if (element.hasTypeModeElement()) 15087 composeEnum(t, "StructureMap", "typeMode", element.getTypeModeElement(), -1); 15088 if (element.hasDocumentationElement()) 15089 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 15090 for (int i = 0; i < element.getInput().size(); i++) 15091 composeStructureMapStructureMapGroupInputComponent(t, "StructureMap", "input", element.getInput().get(i), i); 15092 for (int i = 0; i < element.getRule().size(); i++) 15093 composeStructureMapStructureMapGroupRuleComponent(t, "StructureMap", "rule", element.getRule().get(i), i); 15094 } 15095 15096 protected void composeStructureMapStructureMapGroupInputComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupInputComponent element, int index) { 15097 if (element == null) 15098 return; 15099 Complex t; 15100 if (Utilities.noString(parentType)) 15101 t = parent; 15102 else { 15103 t = parent.predicate("fhir:"+parentType+'.'+name); 15104 } 15105 composeBackboneElement(t, "input", name, element, index); 15106 if (element.hasNameElement()) 15107 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 15108 if (element.hasTypeElement()) 15109 composeString(t, "StructureMap", "type", element.getTypeElement(), -1); 15110 if (element.hasModeElement()) 15111 composeEnum(t, "StructureMap", "mode", element.getModeElement(), -1); 15112 if (element.hasDocumentationElement()) 15113 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 15114 } 15115 15116 protected void composeStructureMapStructureMapGroupRuleComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleComponent element, int index) { 15117 if (element == null) 15118 return; 15119 Complex t; 15120 if (Utilities.noString(parentType)) 15121 t = parent; 15122 else { 15123 t = parent.predicate("fhir:"+parentType+'.'+name); 15124 } 15125 composeBackboneElement(t, "rule", name, element, index); 15126 if (element.hasNameElement()) 15127 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 15128 for (int i = 0; i < element.getSource().size(); i++) 15129 composeStructureMapStructureMapGroupRuleSourceComponent(t, "StructureMap", "source", element.getSource().get(i), i); 15130 for (int i = 0; i < element.getTarget().size(); i++) 15131 composeStructureMapStructureMapGroupRuleTargetComponent(t, "StructureMap", "target", element.getTarget().get(i), i); 15132 for (int i = 0; i < element.getRule().size(); i++) 15133 composeStructureMapStructureMapGroupRuleComponent(t, "StructureMap", "rule", element.getRule().get(i), i); 15134 for (int i = 0; i < element.getDependent().size(); i++) 15135 composeStructureMapStructureMapGroupRuleDependentComponent(t, "StructureMap", "dependent", element.getDependent().get(i), i); 15136 if (element.hasDocumentationElement()) 15137 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 15138 } 15139 15140 protected void composeStructureMapStructureMapGroupRuleSourceComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleSourceComponent element, int index) { 15141 if (element == null) 15142 return; 15143 Complex t; 15144 if (Utilities.noString(parentType)) 15145 t = parent; 15146 else { 15147 t = parent.predicate("fhir:"+parentType+'.'+name); 15148 } 15149 composeBackboneElement(t, "source", name, element, index); 15150 if (element.hasContextElement()) 15151 composeId(t, "StructureMap", "context", element.getContextElement(), -1); 15152 if (element.hasMinElement()) 15153 composeInteger(t, "StructureMap", "min", element.getMinElement(), -1); 15154 if (element.hasMaxElement()) 15155 composeString(t, "StructureMap", "max", element.getMaxElement(), -1); 15156 if (element.hasTypeElement()) 15157 composeString(t, "StructureMap", "type", element.getTypeElement(), -1); 15158 if (element.hasDefaultValue()) 15159 composeType(t, "StructureMap", "defaultValue", element.getDefaultValue(), -1); 15160 if (element.hasElementElement()) 15161 composeString(t, "StructureMap", "element", element.getElementElement(), -1); 15162 if (element.hasListModeElement()) 15163 composeEnum(t, "StructureMap", "listMode", element.getListModeElement(), -1); 15164 if (element.hasVariableElement()) 15165 composeId(t, "StructureMap", "variable", element.getVariableElement(), -1); 15166 if (element.hasConditionElement()) 15167 composeString(t, "StructureMap", "condition", element.getConditionElement(), -1); 15168 if (element.hasCheckElement()) 15169 composeString(t, "StructureMap", "check", element.getCheckElement(), -1); 15170 if (element.hasLogMessageElement()) 15171 composeString(t, "StructureMap", "logMessage", element.getLogMessageElement(), -1); 15172 } 15173 15174 protected void composeStructureMapStructureMapGroupRuleTargetComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetComponent element, int index) { 15175 if (element == null) 15176 return; 15177 Complex t; 15178 if (Utilities.noString(parentType)) 15179 t = parent; 15180 else { 15181 t = parent.predicate("fhir:"+parentType+'.'+name); 15182 } 15183 composeBackboneElement(t, "target", name, element, index); 15184 if (element.hasContextElement()) 15185 composeId(t, "StructureMap", "context", element.getContextElement(), -1); 15186 if (element.hasContextTypeElement()) 15187 composeEnum(t, "StructureMap", "contextType", element.getContextTypeElement(), -1); 15188 if (element.hasElementElement()) 15189 composeString(t, "StructureMap", "element", element.getElementElement(), -1); 15190 if (element.hasVariableElement()) 15191 composeId(t, "StructureMap", "variable", element.getVariableElement(), -1); 15192 for (int i = 0; i < element.getListMode().size(); i++) 15193 composeEnum(t, "StructureMap", "listMode", element.getListMode().get(i), i); 15194 if (element.hasListRuleIdElement()) 15195 composeId(t, "StructureMap", "listRuleId", element.getListRuleIdElement(), -1); 15196 if (element.hasTransformElement()) 15197 composeEnum(t, "StructureMap", "transform", element.getTransformElement(), -1); 15198 for (int i = 0; i < element.getParameter().size(); i++) 15199 composeStructureMapStructureMapGroupRuleTargetParameterComponent(t, "StructureMap", "parameter", element.getParameter().get(i), i); 15200 } 15201 15202 protected void composeStructureMapStructureMapGroupRuleTargetParameterComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetParameterComponent element, int index) { 15203 if (element == null) 15204 return; 15205 Complex t; 15206 if (Utilities.noString(parentType)) 15207 t = parent; 15208 else { 15209 t = parent.predicate("fhir:"+parentType+'.'+name); 15210 } 15211 composeBackboneElement(t, "parameter", name, element, index); 15212 if (element.hasValue()) 15213 composeType(t, "StructureMap", "value", element.getValue(), -1); 15214 } 15215 15216 protected void composeStructureMapStructureMapGroupRuleDependentComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleDependentComponent element, int index) { 15217 if (element == null) 15218 return; 15219 Complex t; 15220 if (Utilities.noString(parentType)) 15221 t = parent; 15222 else { 15223 t = parent.predicate("fhir:"+parentType+'.'+name); 15224 } 15225 composeBackboneElement(t, "dependent", name, element, index); 15226 if (element.hasNameElement()) 15227 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 15228 for (int i = 0; i < element.getVariable().size(); i++) 15229 composeString(t, "StructureMap", "variable", element.getVariable().get(i), i); 15230 } 15231 15232 protected void composeSubscription(Complex parent, String parentType, String name, Subscription element, int index) { 15233 if (element == null) 15234 return; 15235 Complex t; 15236 if (Utilities.noString(parentType)) 15237 t = parent; 15238 else { 15239 t = parent.predicate("fhir:"+parentType+'.'+name); 15240 } 15241 composeDomainResource(t, "Subscription", name, element, index); 15242 if (element.hasStatusElement()) 15243 composeEnum(t, "Subscription", "status", element.getStatusElement(), -1); 15244 for (int i = 0; i < element.getContact().size(); i++) 15245 composeContactPoint(t, "Subscription", "contact", element.getContact().get(i), i); 15246 if (element.hasEndElement()) 15247 composeInstant(t, "Subscription", "end", element.getEndElement(), -1); 15248 if (element.hasReasonElement()) 15249 composeString(t, "Subscription", "reason", element.getReasonElement(), -1); 15250 if (element.hasCriteriaElement()) 15251 composeString(t, "Subscription", "criteria", element.getCriteriaElement(), -1); 15252 if (element.hasErrorElement()) 15253 composeString(t, "Subscription", "error", element.getErrorElement(), -1); 15254 if (element.hasChannel()) 15255 composeSubscriptionSubscriptionChannelComponent(t, "Subscription", "channel", element.getChannel(), -1); 15256 } 15257 15258 protected void composeSubscriptionSubscriptionChannelComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelComponent element, int index) { 15259 if (element == null) 15260 return; 15261 Complex t; 15262 if (Utilities.noString(parentType)) 15263 t = parent; 15264 else { 15265 t = parent.predicate("fhir:"+parentType+'.'+name); 15266 } 15267 composeBackboneElement(t, "channel", name, element, index); 15268 if (element.hasTypeElement()) 15269 composeEnum(t, "Subscription", "type", element.getTypeElement(), -1); 15270 if (element.hasEndpointElement()) 15271 composeUrl(t, "Subscription", "endpoint", element.getEndpointElement(), -1); 15272 if (element.hasPayloadElement()) 15273 composeCode(t, "Subscription", "payload", element.getPayloadElement(), -1); 15274 for (int i = 0; i < element.getHeader().size(); i++) 15275 composeString(t, "Subscription", "header", element.getHeader().get(i), i); 15276 } 15277 15278 protected void composeSubstance(Complex parent, String parentType, String name, Substance element, int index) { 15279 if (element == null) 15280 return; 15281 Complex t; 15282 if (Utilities.noString(parentType)) 15283 t = parent; 15284 else { 15285 t = parent.predicate("fhir:"+parentType+'.'+name); 15286 } 15287 composeDomainResource(t, "Substance", name, element, index); 15288 for (int i = 0; i < element.getIdentifier().size(); i++) 15289 composeIdentifier(t, "Substance", "identifier", element.getIdentifier().get(i), i); 15290 if (element.hasStatusElement()) 15291 composeEnum(t, "Substance", "status", element.getStatusElement(), -1); 15292 for (int i = 0; i < element.getCategory().size(); i++) 15293 composeCodeableConcept(t, "Substance", "category", element.getCategory().get(i), i); 15294 if (element.hasCode()) 15295 composeCodeableConcept(t, "Substance", "code", element.getCode(), -1); 15296 if (element.hasDescriptionElement()) 15297 composeString(t, "Substance", "description", element.getDescriptionElement(), -1); 15298 for (int i = 0; i < element.getInstance().size(); i++) 15299 composeSubstanceSubstanceInstanceComponent(t, "Substance", "instance", element.getInstance().get(i), i); 15300 for (int i = 0; i < element.getIngredient().size(); i++) 15301 composeSubstanceSubstanceIngredientComponent(t, "Substance", "ingredient", element.getIngredient().get(i), i); 15302 } 15303 15304 protected void composeSubstanceSubstanceInstanceComponent(Complex parent, String parentType, String name, Substance.SubstanceInstanceComponent element, int index) { 15305 if (element == null) 15306 return; 15307 Complex t; 15308 if (Utilities.noString(parentType)) 15309 t = parent; 15310 else { 15311 t = parent.predicate("fhir:"+parentType+'.'+name); 15312 } 15313 composeBackboneElement(t, "instance", name, element, index); 15314 if (element.hasIdentifier()) 15315 composeIdentifier(t, "Substance", "identifier", element.getIdentifier(), -1); 15316 if (element.hasExpiryElement()) 15317 composeDateTime(t, "Substance", "expiry", element.getExpiryElement(), -1); 15318 if (element.hasQuantity()) 15319 composeQuantity(t, "Substance", "quantity", element.getQuantity(), -1); 15320 } 15321 15322 protected void composeSubstanceSubstanceIngredientComponent(Complex parent, String parentType, String name, Substance.SubstanceIngredientComponent element, int index) { 15323 if (element == null) 15324 return; 15325 Complex t; 15326 if (Utilities.noString(parentType)) 15327 t = parent; 15328 else { 15329 t = parent.predicate("fhir:"+parentType+'.'+name); 15330 } 15331 composeBackboneElement(t, "ingredient", name, element, index); 15332 if (element.hasQuantity()) 15333 composeRatio(t, "Substance", "quantity", element.getQuantity(), -1); 15334 if (element.hasSubstance()) 15335 composeType(t, "Substance", "substance", element.getSubstance(), -1); 15336 } 15337 15338 protected void composeSubstanceNucleicAcid(Complex parent, String parentType, String name, SubstanceNucleicAcid element, int index) { 15339 if (element == null) 15340 return; 15341 Complex t; 15342 if (Utilities.noString(parentType)) 15343 t = parent; 15344 else { 15345 t = parent.predicate("fhir:"+parentType+'.'+name); 15346 } 15347 composeDomainResource(t, "SubstanceNucleicAcid", name, element, index); 15348 if (element.hasSequenceType()) 15349 composeCodeableConcept(t, "SubstanceNucleicAcid", "sequenceType", element.getSequenceType(), -1); 15350 if (element.hasNumberOfSubunitsElement()) 15351 composeInteger(t, "SubstanceNucleicAcid", "numberOfSubunits", element.getNumberOfSubunitsElement(), -1); 15352 if (element.hasAreaOfHybridisationElement()) 15353 composeString(t, "SubstanceNucleicAcid", "areaOfHybridisation", element.getAreaOfHybridisationElement(), -1); 15354 if (element.hasOligoNucleotideType()) 15355 composeCodeableConcept(t, "SubstanceNucleicAcid", "oligoNucleotideType", element.getOligoNucleotideType(), -1); 15356 for (int i = 0; i < element.getSubunit().size(); i++) 15357 composeSubstanceNucleicAcidSubstanceNucleicAcidSubunitComponent(t, "SubstanceNucleicAcid", "subunit", element.getSubunit().get(i), i); 15358 } 15359 15360 protected void composeSubstanceNucleicAcidSubstanceNucleicAcidSubunitComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitComponent element, int index) { 15361 if (element == null) 15362 return; 15363 Complex t; 15364 if (Utilities.noString(parentType)) 15365 t = parent; 15366 else { 15367 t = parent.predicate("fhir:"+parentType+'.'+name); 15368 } 15369 composeBackboneElement(t, "subunit", name, element, index); 15370 if (element.hasSubunitElement()) 15371 composeInteger(t, "SubstanceNucleicAcid", "subunit", element.getSubunitElement(), -1); 15372 if (element.hasSequenceElement()) 15373 composeString(t, "SubstanceNucleicAcid", "sequence", element.getSequenceElement(), -1); 15374 if (element.hasLengthElement()) 15375 composeInteger(t, "SubstanceNucleicAcid", "length", element.getLengthElement(), -1); 15376 if (element.hasSequenceAttachment()) 15377 composeAttachment(t, "SubstanceNucleicAcid", "sequenceAttachment", element.getSequenceAttachment(), -1); 15378 if (element.hasFivePrime()) 15379 composeCodeableConcept(t, "SubstanceNucleicAcid", "fivePrime", element.getFivePrime(), -1); 15380 if (element.hasThreePrime()) 15381 composeCodeableConcept(t, "SubstanceNucleicAcid", "threePrime", element.getThreePrime(), -1); 15382 for (int i = 0; i < element.getLinkage().size(); i++) 15383 composeSubstanceNucleicAcidSubstanceNucleicAcidSubunitLinkageComponent(t, "SubstanceNucleicAcid", "linkage", element.getLinkage().get(i), i); 15384 for (int i = 0; i < element.getSugar().size(); i++) 15385 composeSubstanceNucleicAcidSubstanceNucleicAcidSubunitSugarComponent(t, "SubstanceNucleicAcid", "sugar", element.getSugar().get(i), i); 15386 } 15387 15388 protected void composeSubstanceNucleicAcidSubstanceNucleicAcidSubunitLinkageComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitLinkageComponent element, int index) { 15389 if (element == null) 15390 return; 15391 Complex t; 15392 if (Utilities.noString(parentType)) 15393 t = parent; 15394 else { 15395 t = parent.predicate("fhir:"+parentType+'.'+name); 15396 } 15397 composeBackboneElement(t, "linkage", name, element, index); 15398 if (element.hasConnectivityElement()) 15399 composeString(t, "SubstanceNucleicAcid", "connectivity", element.getConnectivityElement(), -1); 15400 if (element.hasIdentifier()) 15401 composeIdentifier(t, "SubstanceNucleicAcid", "identifier", element.getIdentifier(), -1); 15402 if (element.hasNameElement()) 15403 composeString(t, "SubstanceNucleicAcid", "name", element.getNameElement(), -1); 15404 if (element.hasResidueSiteElement()) 15405 composeString(t, "SubstanceNucleicAcid", "residueSite", element.getResidueSiteElement(), -1); 15406 } 15407 15408 protected void composeSubstanceNucleicAcidSubstanceNucleicAcidSubunitSugarComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitSugarComponent element, int index) { 15409 if (element == null) 15410 return; 15411 Complex t; 15412 if (Utilities.noString(parentType)) 15413 t = parent; 15414 else { 15415 t = parent.predicate("fhir:"+parentType+'.'+name); 15416 } 15417 composeBackboneElement(t, "sugar", name, element, index); 15418 if (element.hasIdentifier()) 15419 composeIdentifier(t, "SubstanceNucleicAcid", "identifier", element.getIdentifier(), -1); 15420 if (element.hasNameElement()) 15421 composeString(t, "SubstanceNucleicAcid", "name", element.getNameElement(), -1); 15422 if (element.hasResidueSiteElement()) 15423 composeString(t, "SubstanceNucleicAcid", "residueSite", element.getResidueSiteElement(), -1); 15424 } 15425 15426 protected void composeSubstancePolymer(Complex parent, String parentType, String name, SubstancePolymer element, int index) { 15427 if (element == null) 15428 return; 15429 Complex t; 15430 if (Utilities.noString(parentType)) 15431 t = parent; 15432 else { 15433 t = parent.predicate("fhir:"+parentType+'.'+name); 15434 } 15435 composeDomainResource(t, "SubstancePolymer", name, element, index); 15436 if (element.hasClass_()) 15437 composeCodeableConcept(t, "SubstancePolymer", "class", element.getClass_(), -1); 15438 if (element.hasGeometry()) 15439 composeCodeableConcept(t, "SubstancePolymer", "geometry", element.getGeometry(), -1); 15440 for (int i = 0; i < element.getCopolymerConnectivity().size(); i++) 15441 composeCodeableConcept(t, "SubstancePolymer", "copolymerConnectivity", element.getCopolymerConnectivity().get(i), i); 15442 for (int i = 0; i < element.getModification().size(); i++) 15443 composeString(t, "SubstancePolymer", "modification", element.getModification().get(i), i); 15444 for (int i = 0; i < element.getMonomerSet().size(); i++) 15445 composeSubstancePolymerSubstancePolymerMonomerSetComponent(t, "SubstancePolymer", "monomerSet", element.getMonomerSet().get(i), i); 15446 for (int i = 0; i < element.getRepeat().size(); i++) 15447 composeSubstancePolymerSubstancePolymerRepeatComponent(t, "SubstancePolymer", "repeat", element.getRepeat().get(i), i); 15448 } 15449 15450 protected void composeSubstancePolymerSubstancePolymerMonomerSetComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerMonomerSetComponent element, int index) { 15451 if (element == null) 15452 return; 15453 Complex t; 15454 if (Utilities.noString(parentType)) 15455 t = parent; 15456 else { 15457 t = parent.predicate("fhir:"+parentType+'.'+name); 15458 } 15459 composeBackboneElement(t, "monomerSet", name, element, index); 15460 if (element.hasRatioType()) 15461 composeCodeableConcept(t, "SubstancePolymer", "ratioType", element.getRatioType(), -1); 15462 for (int i = 0; i < element.getStartingMaterial().size(); i++) 15463 composeSubstancePolymerSubstancePolymerMonomerSetStartingMaterialComponent(t, "SubstancePolymer", "startingMaterial", element.getStartingMaterial().get(i), i); 15464 } 15465 15466 protected void composeSubstancePolymerSubstancePolymerMonomerSetStartingMaterialComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerMonomerSetStartingMaterialComponent element, int index) { 15467 if (element == null) 15468 return; 15469 Complex t; 15470 if (Utilities.noString(parentType)) 15471 t = parent; 15472 else { 15473 t = parent.predicate("fhir:"+parentType+'.'+name); 15474 } 15475 composeBackboneElement(t, "startingMaterial", name, element, index); 15476 if (element.hasMaterial()) 15477 composeCodeableConcept(t, "SubstancePolymer", "material", element.getMaterial(), -1); 15478 if (element.hasType()) 15479 composeCodeableConcept(t, "SubstancePolymer", "type", element.getType(), -1); 15480 if (element.hasIsDefiningElement()) 15481 composeBoolean(t, "SubstancePolymer", "isDefining", element.getIsDefiningElement(), -1); 15482 if (element.hasAmount()) 15483 composeSubstanceAmount(t, "SubstancePolymer", "amount", element.getAmount(), -1); 15484 } 15485 15486 protected void composeSubstancePolymerSubstancePolymerRepeatComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatComponent element, int index) { 15487 if (element == null) 15488 return; 15489 Complex t; 15490 if (Utilities.noString(parentType)) 15491 t = parent; 15492 else { 15493 t = parent.predicate("fhir:"+parentType+'.'+name); 15494 } 15495 composeBackboneElement(t, "repeat", name, element, index); 15496 if (element.hasNumberOfUnitsElement()) 15497 composeInteger(t, "SubstancePolymer", "numberOfUnits", element.getNumberOfUnitsElement(), -1); 15498 if (element.hasAverageMolecularFormulaElement()) 15499 composeString(t, "SubstancePolymer", "averageMolecularFormula", element.getAverageMolecularFormulaElement(), -1); 15500 if (element.hasRepeatUnitAmountType()) 15501 composeCodeableConcept(t, "SubstancePolymer", "repeatUnitAmountType", element.getRepeatUnitAmountType(), -1); 15502 for (int i = 0; i < element.getRepeatUnit().size(); i++) 15503 composeSubstancePolymerSubstancePolymerRepeatRepeatUnitComponent(t, "SubstancePolymer", "repeatUnit", element.getRepeatUnit().get(i), i); 15504 } 15505 15506 protected void composeSubstancePolymerSubstancePolymerRepeatRepeatUnitComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitComponent element, int index) { 15507 if (element == null) 15508 return; 15509 Complex t; 15510 if (Utilities.noString(parentType)) 15511 t = parent; 15512 else { 15513 t = parent.predicate("fhir:"+parentType+'.'+name); 15514 } 15515 composeBackboneElement(t, "repeatUnit", name, element, index); 15516 if (element.hasOrientationOfPolymerisation()) 15517 composeCodeableConcept(t, "SubstancePolymer", "orientationOfPolymerisation", element.getOrientationOfPolymerisation(), -1); 15518 if (element.hasRepeatUnitElement()) 15519 composeString(t, "SubstancePolymer", "repeatUnit", element.getRepeatUnitElement(), -1); 15520 if (element.hasAmount()) 15521 composeSubstanceAmount(t, "SubstancePolymer", "amount", element.getAmount(), -1); 15522 for (int i = 0; i < element.getDegreeOfPolymerisation().size(); i++) 15523 composeSubstancePolymerSubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent(t, "SubstancePolymer", "degreeOfPolymerisation", element.getDegreeOfPolymerisation().get(i), i); 15524 for (int i = 0; i < element.getStructuralRepresentation().size(); i++) 15525 composeSubstancePolymerSubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent(t, "SubstancePolymer", "structuralRepresentation", element.getStructuralRepresentation().get(i), i); 15526 } 15527 15528 protected void composeSubstancePolymerSubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent element, int index) { 15529 if (element == null) 15530 return; 15531 Complex t; 15532 if (Utilities.noString(parentType)) 15533 t = parent; 15534 else { 15535 t = parent.predicate("fhir:"+parentType+'.'+name); 15536 } 15537 composeBackboneElement(t, "degreeOfPolymerisation", name, element, index); 15538 if (element.hasDegree()) 15539 composeCodeableConcept(t, "SubstancePolymer", "degree", element.getDegree(), -1); 15540 if (element.hasAmount()) 15541 composeSubstanceAmount(t, "SubstancePolymer", "amount", element.getAmount(), -1); 15542 } 15543 15544 protected void composeSubstancePolymerSubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent element, int index) { 15545 if (element == null) 15546 return; 15547 Complex t; 15548 if (Utilities.noString(parentType)) 15549 t = parent; 15550 else { 15551 t = parent.predicate("fhir:"+parentType+'.'+name); 15552 } 15553 composeBackboneElement(t, "structuralRepresentation", name, element, index); 15554 if (element.hasType()) 15555 composeCodeableConcept(t, "SubstancePolymer", "type", element.getType(), -1); 15556 if (element.hasRepresentationElement()) 15557 composeString(t, "SubstancePolymer", "representation", element.getRepresentationElement(), -1); 15558 if (element.hasAttachment()) 15559 composeAttachment(t, "SubstancePolymer", "attachment", element.getAttachment(), -1); 15560 } 15561 15562 protected void composeSubstanceProtein(Complex parent, String parentType, String name, SubstanceProtein element, int index) { 15563 if (element == null) 15564 return; 15565 Complex t; 15566 if (Utilities.noString(parentType)) 15567 t = parent; 15568 else { 15569 t = parent.predicate("fhir:"+parentType+'.'+name); 15570 } 15571 composeDomainResource(t, "SubstanceProtein", name, element, index); 15572 if (element.hasSequenceType()) 15573 composeCodeableConcept(t, "SubstanceProtein", "sequenceType", element.getSequenceType(), -1); 15574 if (element.hasNumberOfSubunitsElement()) 15575 composeInteger(t, "SubstanceProtein", "numberOfSubunits", element.getNumberOfSubunitsElement(), -1); 15576 for (int i = 0; i < element.getDisulfideLinkage().size(); i++) 15577 composeString(t, "SubstanceProtein", "disulfideLinkage", element.getDisulfideLinkage().get(i), i); 15578 for (int i = 0; i < element.getSubunit().size(); i++) 15579 composeSubstanceProteinSubstanceProteinSubunitComponent(t, "SubstanceProtein", "subunit", element.getSubunit().get(i), i); 15580 } 15581 15582 protected void composeSubstanceProteinSubstanceProteinSubunitComponent(Complex parent, String parentType, String name, SubstanceProtein.SubstanceProteinSubunitComponent element, int index) { 15583 if (element == null) 15584 return; 15585 Complex t; 15586 if (Utilities.noString(parentType)) 15587 t = parent; 15588 else { 15589 t = parent.predicate("fhir:"+parentType+'.'+name); 15590 } 15591 composeBackboneElement(t, "subunit", name, element, index); 15592 if (element.hasSubunitElement()) 15593 composeInteger(t, "SubstanceProtein", "subunit", element.getSubunitElement(), -1); 15594 if (element.hasSequenceElement()) 15595 composeString(t, "SubstanceProtein", "sequence", element.getSequenceElement(), -1); 15596 if (element.hasLengthElement()) 15597 composeInteger(t, "SubstanceProtein", "length", element.getLengthElement(), -1); 15598 if (element.hasSequenceAttachment()) 15599 composeAttachment(t, "SubstanceProtein", "sequenceAttachment", element.getSequenceAttachment(), -1); 15600 if (element.hasNTerminalModificationId()) 15601 composeIdentifier(t, "SubstanceProtein", "nTerminalModificationId", element.getNTerminalModificationId(), -1); 15602 if (element.hasNTerminalModificationElement()) 15603 composeString(t, "SubstanceProtein", "nTerminalModification", element.getNTerminalModificationElement(), -1); 15604 if (element.hasCTerminalModificationId()) 15605 composeIdentifier(t, "SubstanceProtein", "cTerminalModificationId", element.getCTerminalModificationId(), -1); 15606 if (element.hasCTerminalModificationElement()) 15607 composeString(t, "SubstanceProtein", "cTerminalModification", element.getCTerminalModificationElement(), -1); 15608 } 15609 15610 protected void composeSubstanceReferenceInformation(Complex parent, String parentType, String name, SubstanceReferenceInformation element, int index) { 15611 if (element == null) 15612 return; 15613 Complex t; 15614 if (Utilities.noString(parentType)) 15615 t = parent; 15616 else { 15617 t = parent.predicate("fhir:"+parentType+'.'+name); 15618 } 15619 composeDomainResource(t, "SubstanceReferenceInformation", name, element, index); 15620 if (element.hasCommentElement()) 15621 composeString(t, "SubstanceReferenceInformation", "comment", element.getCommentElement(), -1); 15622 for (int i = 0; i < element.getGene().size(); i++) 15623 composeSubstanceReferenceInformationSubstanceReferenceInformationGeneComponent(t, "SubstanceReferenceInformation", "gene", element.getGene().get(i), i); 15624 for (int i = 0; i < element.getGene().size(); i++) 15625 composeSubstanceReferenceInformationSubstanceReferenceInformationGeneComponent(t, "SubstanceReferenceInformation", "geneElement", element.getGene().get(i), i); 15626 for (int i = 0; i < element.getClassification().size(); i++) 15627 composeSubstanceReferenceInformationSubstanceReferenceInformationClassificationComponent(t, "SubstanceReferenceInformation", "classification", element.getClassification().get(i), i); 15628 for (int i = 0; i < element.getTarget().size(); i++) 15629 composeSubstanceReferenceInformationSubstanceReferenceInformationTargetComponent(t, "SubstanceReferenceInformation", "target", element.getTarget().get(i), i); 15630 } 15631 15632 protected void composeSubstanceReferenceInformationSubstanceReferenceInformationGeneComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationGeneComponent element, int index) { 15633 if (element == null) 15634 return; 15635 Complex t; 15636 if (Utilities.noString(parentType)) 15637 t = parent; 15638 else { 15639 t = parent.predicate("fhir:"+parentType+'.'+name); 15640 } 15641 composeBackboneElement(t, "gene", name, element, index); 15642 if (element.hasGeneSequenceOrigin()) 15643 composeCodeableConcept(t, "SubstanceReferenceInformation", "geneSequenceOrigin", element.getGeneSequenceOrigin(), -1); 15644 if (element.hasGene()) 15645 composeCodeableConcept(t, "SubstanceReferenceInformation", "gene", element.getGene(), -1); 15646 for (int i = 0; i < element.getSource().size(); i++) 15647 composeReference(t, "SubstanceReferenceInformation", "source", element.getSource().get(i), i); 15648 } 15649 15650 protected void composeSubstanceReferenceInformationSubstanceReferenceInformationGeneElementComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationGeneElementComponent element, int index) { 15651 if (element == null) 15652 return; 15653 Complex t; 15654 if (Utilities.noString(parentType)) 15655 t = parent; 15656 else { 15657 t = parent.predicate("fhir:"+parentType+'.'+name); 15658 } 15659 composeBackboneElement(t, "geneElement", name, element, index); 15660 if (element.hasType()) 15661 composeCodeableConcept(t, "SubstanceReferenceInformation", "type", element.getType(), -1); 15662 if (element.hasElement()) 15663 composeIdentifier(t, "SubstanceReferenceInformation", "element", element.getElement(), -1); 15664 for (int i = 0; i < element.getSource().size(); i++) 15665 composeReference(t, "SubstanceReferenceInformation", "source", element.getSource().get(i), i); 15666 } 15667 15668 protected void composeSubstanceReferenceInformationSubstanceReferenceInformationClassificationComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationClassificationComponent element, int index) { 15669 if (element == null) 15670 return; 15671 Complex t; 15672 if (Utilities.noString(parentType)) 15673 t = parent; 15674 else { 15675 t = parent.predicate("fhir:"+parentType+'.'+name); 15676 } 15677 composeBackboneElement(t, "classification", name, element, index); 15678 if (element.hasDomain()) 15679 composeCodeableConcept(t, "SubstanceReferenceInformation", "domain", element.getDomain(), -1); 15680 if (element.hasClassification()) 15681 composeCodeableConcept(t, "SubstanceReferenceInformation", "classification", element.getClassification(), -1); 15682 for (int i = 0; i < element.getSubtype().size(); i++) 15683 composeCodeableConcept(t, "SubstanceReferenceInformation", "subtype", element.getSubtype().get(i), i); 15684 for (int i = 0; i < element.getSource().size(); i++) 15685 composeReference(t, "SubstanceReferenceInformation", "source", element.getSource().get(i), i); 15686 } 15687 15688 protected void composeSubstanceReferenceInformationSubstanceReferenceInformationTargetComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationTargetComponent element, int index) { 15689 if (element == null) 15690 return; 15691 Complex t; 15692 if (Utilities.noString(parentType)) 15693 t = parent; 15694 else { 15695 t = parent.predicate("fhir:"+parentType+'.'+name); 15696 } 15697 composeBackboneElement(t, "target", name, element, index); 15698 if (element.hasTarget()) 15699 composeIdentifier(t, "SubstanceReferenceInformation", "target", element.getTarget(), -1); 15700 if (element.hasType()) 15701 composeCodeableConcept(t, "SubstanceReferenceInformation", "type", element.getType(), -1); 15702 if (element.hasInteraction()) 15703 composeCodeableConcept(t, "SubstanceReferenceInformation", "interaction", element.getInteraction(), -1); 15704 if (element.hasOrganism()) 15705 composeCodeableConcept(t, "SubstanceReferenceInformation", "organism", element.getOrganism(), -1); 15706 if (element.hasOrganismType()) 15707 composeCodeableConcept(t, "SubstanceReferenceInformation", "organismType", element.getOrganismType(), -1); 15708 if (element.hasAmount()) 15709 composeType(t, "SubstanceReferenceInformation", "amount", element.getAmount(), -1); 15710 if (element.hasAmountType()) 15711 composeCodeableConcept(t, "SubstanceReferenceInformation", "amountType", element.getAmountType(), -1); 15712 for (int i = 0; i < element.getSource().size(); i++) 15713 composeReference(t, "SubstanceReferenceInformation", "source", element.getSource().get(i), i); 15714 } 15715 15716 protected void composeSubstanceSourceMaterial(Complex parent, String parentType, String name, SubstanceSourceMaterial element, int index) { 15717 if (element == null) 15718 return; 15719 Complex t; 15720 if (Utilities.noString(parentType)) 15721 t = parent; 15722 else { 15723 t = parent.predicate("fhir:"+parentType+'.'+name); 15724 } 15725 composeDomainResource(t, "SubstanceSourceMaterial", name, element, index); 15726 if (element.hasSourceMaterialClass()) 15727 composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialClass", element.getSourceMaterialClass(), -1); 15728 if (element.hasSourceMaterialType()) 15729 composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialType", element.getSourceMaterialType(), -1); 15730 if (element.hasSourceMaterialState()) 15731 composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialState", element.getSourceMaterialState(), -1); 15732 if (element.hasOrganismId()) 15733 composeIdentifier(t, "SubstanceSourceMaterial", "organismId", element.getOrganismId(), -1); 15734 if (element.hasOrganismNameElement()) 15735 composeString(t, "SubstanceSourceMaterial", "organismName", element.getOrganismNameElement(), -1); 15736 for (int i = 0; i < element.getParentSubstanceId().size(); i++) 15737 composeIdentifier(t, "SubstanceSourceMaterial", "parentSubstanceId", element.getParentSubstanceId().get(i), i); 15738 for (int i = 0; i < element.getParentSubstanceName().size(); i++) 15739 composeString(t, "SubstanceSourceMaterial", "parentSubstanceName", element.getParentSubstanceName().get(i), i); 15740 for (int i = 0; i < element.getCountryOfOrigin().size(); i++) 15741 composeCodeableConcept(t, "SubstanceSourceMaterial", "countryOfOrigin", element.getCountryOfOrigin().get(i), i); 15742 for (int i = 0; i < element.getGeographicalLocation().size(); i++) 15743 composeString(t, "SubstanceSourceMaterial", "geographicalLocation", element.getGeographicalLocation().get(i), i); 15744 if (element.hasDevelopmentStage()) 15745 composeCodeableConcept(t, "SubstanceSourceMaterial", "developmentStage", element.getDevelopmentStage(), -1); 15746 for (int i = 0; i < element.getFractionDescription().size(); i++) 15747 composeSubstanceSourceMaterialSubstanceSourceMaterialFractionDescriptionComponent(t, "SubstanceSourceMaterial", "fractionDescription", element.getFractionDescription().get(i), i); 15748 if (element.hasOrganism()) 15749 composeSubstanceSourceMaterialSubstanceSourceMaterialOrganismComponent(t, "SubstanceSourceMaterial", "organism", element.getOrganism(), -1); 15750 for (int i = 0; i < element.getPartDescription().size(); i++) 15751 composeSubstanceSourceMaterialSubstanceSourceMaterialPartDescriptionComponent(t, "SubstanceSourceMaterial", "partDescription", element.getPartDescription().get(i), i); 15752 } 15753 15754 protected void composeSubstanceSourceMaterialSubstanceSourceMaterialFractionDescriptionComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialFractionDescriptionComponent element, int index) { 15755 if (element == null) 15756 return; 15757 Complex t; 15758 if (Utilities.noString(parentType)) 15759 t = parent; 15760 else { 15761 t = parent.predicate("fhir:"+parentType+'.'+name); 15762 } 15763 composeBackboneElement(t, "fractionDescription", name, element, index); 15764 if (element.hasFractionElement()) 15765 composeString(t, "SubstanceSourceMaterial", "fraction", element.getFractionElement(), -1); 15766 if (element.hasMaterialType()) 15767 composeCodeableConcept(t, "SubstanceSourceMaterial", "materialType", element.getMaterialType(), -1); 15768 } 15769 15770 protected void composeSubstanceSourceMaterialSubstanceSourceMaterialOrganismComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismComponent element, int index) { 15771 if (element == null) 15772 return; 15773 Complex t; 15774 if (Utilities.noString(parentType)) 15775 t = parent; 15776 else { 15777 t = parent.predicate("fhir:"+parentType+'.'+name); 15778 } 15779 composeBackboneElement(t, "organism", name, element, index); 15780 if (element.hasFamily()) 15781 composeCodeableConcept(t, "SubstanceSourceMaterial", "family", element.getFamily(), -1); 15782 if (element.hasGenus()) 15783 composeCodeableConcept(t, "SubstanceSourceMaterial", "genus", element.getGenus(), -1); 15784 if (element.hasSpecies()) 15785 composeCodeableConcept(t, "SubstanceSourceMaterial", "species", element.getSpecies(), -1); 15786 if (element.hasIntraspecificType()) 15787 composeCodeableConcept(t, "SubstanceSourceMaterial", "intraspecificType", element.getIntraspecificType(), -1); 15788 if (element.hasIntraspecificDescriptionElement()) 15789 composeString(t, "SubstanceSourceMaterial", "intraspecificDescription", element.getIntraspecificDescriptionElement(), -1); 15790 for (int i = 0; i < element.getAuthor().size(); i++) 15791 composeSubstanceSourceMaterialSubstanceSourceMaterialOrganismAuthorComponent(t, "SubstanceSourceMaterial", "author", element.getAuthor().get(i), i); 15792 if (element.hasHybrid()) 15793 composeSubstanceSourceMaterialSubstanceSourceMaterialOrganismHybridComponent(t, "SubstanceSourceMaterial", "hybrid", element.getHybrid(), -1); 15794 if (element.hasOrganismGeneral()) 15795 composeSubstanceSourceMaterialSubstanceSourceMaterialOrganismOrganismGeneralComponent(t, "SubstanceSourceMaterial", "organismGeneral", element.getOrganismGeneral(), -1); 15796 } 15797 15798 protected void composeSubstanceSourceMaterialSubstanceSourceMaterialOrganismAuthorComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismAuthorComponent element, int index) { 15799 if (element == null) 15800 return; 15801 Complex t; 15802 if (Utilities.noString(parentType)) 15803 t = parent; 15804 else { 15805 t = parent.predicate("fhir:"+parentType+'.'+name); 15806 } 15807 composeBackboneElement(t, "author", name, element, index); 15808 if (element.hasAuthorType()) 15809 composeCodeableConcept(t, "SubstanceSourceMaterial", "authorType", element.getAuthorType(), -1); 15810 if (element.hasAuthorDescriptionElement()) 15811 composeString(t, "SubstanceSourceMaterial", "authorDescription", element.getAuthorDescriptionElement(), -1); 15812 } 15813 15814 protected void composeSubstanceSourceMaterialSubstanceSourceMaterialOrganismHybridComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismHybridComponent element, int index) { 15815 if (element == null) 15816 return; 15817 Complex t; 15818 if (Utilities.noString(parentType)) 15819 t = parent; 15820 else { 15821 t = parent.predicate("fhir:"+parentType+'.'+name); 15822 } 15823 composeBackboneElement(t, "hybrid", name, element, index); 15824 if (element.hasMaternalOrganismIdElement()) 15825 composeString(t, "SubstanceSourceMaterial", "maternalOrganismId", element.getMaternalOrganismIdElement(), -1); 15826 if (element.hasMaternalOrganismNameElement()) 15827 composeString(t, "SubstanceSourceMaterial", "maternalOrganismName", element.getMaternalOrganismNameElement(), -1); 15828 if (element.hasPaternalOrganismIdElement()) 15829 composeString(t, "SubstanceSourceMaterial", "paternalOrganismId", element.getPaternalOrganismIdElement(), -1); 15830 if (element.hasPaternalOrganismNameElement()) 15831 composeString(t, "SubstanceSourceMaterial", "paternalOrganismName", element.getPaternalOrganismNameElement(), -1); 15832 if (element.hasHybridType()) 15833 composeCodeableConcept(t, "SubstanceSourceMaterial", "hybridType", element.getHybridType(), -1); 15834 } 15835 15836 protected void composeSubstanceSourceMaterialSubstanceSourceMaterialOrganismOrganismGeneralComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismOrganismGeneralComponent element, int index) { 15837 if (element == null) 15838 return; 15839 Complex t; 15840 if (Utilities.noString(parentType)) 15841 t = parent; 15842 else { 15843 t = parent.predicate("fhir:"+parentType+'.'+name); 15844 } 15845 composeBackboneElement(t, "organismGeneral", name, element, index); 15846 if (element.hasKingdom()) 15847 composeCodeableConcept(t, "SubstanceSourceMaterial", "kingdom", element.getKingdom(), -1); 15848 if (element.hasPhylum()) 15849 composeCodeableConcept(t, "SubstanceSourceMaterial", "phylum", element.getPhylum(), -1); 15850 if (element.hasClass_()) 15851 composeCodeableConcept(t, "SubstanceSourceMaterial", "class", element.getClass_(), -1); 15852 if (element.hasOrder()) 15853 composeCodeableConcept(t, "SubstanceSourceMaterial", "order", element.getOrder(), -1); 15854 } 15855 15856 protected void composeSubstanceSourceMaterialSubstanceSourceMaterialPartDescriptionComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialPartDescriptionComponent element, int index) { 15857 if (element == null) 15858 return; 15859 Complex t; 15860 if (Utilities.noString(parentType)) 15861 t = parent; 15862 else { 15863 t = parent.predicate("fhir:"+parentType+'.'+name); 15864 } 15865 composeBackboneElement(t, "partDescription", name, element, index); 15866 if (element.hasPart()) 15867 composeCodeableConcept(t, "SubstanceSourceMaterial", "part", element.getPart(), -1); 15868 if (element.hasPartLocation()) 15869 composeCodeableConcept(t, "SubstanceSourceMaterial", "partLocation", element.getPartLocation(), -1); 15870 } 15871 15872 protected void composeSubstanceSpecification(Complex parent, String parentType, String name, SubstanceSpecification element, int index) { 15873 if (element == null) 15874 return; 15875 Complex t; 15876 if (Utilities.noString(parentType)) 15877 t = parent; 15878 else { 15879 t = parent.predicate("fhir:"+parentType+'.'+name); 15880 } 15881 composeDomainResource(t, "SubstanceSpecification", name, element, index); 15882 if (element.hasIdentifier()) 15883 composeIdentifier(t, "SubstanceSpecification", "identifier", element.getIdentifier(), -1); 15884 if (element.hasType()) 15885 composeCodeableConcept(t, "SubstanceSpecification", "type", element.getType(), -1); 15886 if (element.hasStatus()) 15887 composeCodeableConcept(t, "SubstanceSpecification", "status", element.getStatus(), -1); 15888 if (element.hasDomain()) 15889 composeCodeableConcept(t, "SubstanceSpecification", "domain", element.getDomain(), -1); 15890 if (element.hasDescriptionElement()) 15891 composeString(t, "SubstanceSpecification", "description", element.getDescriptionElement(), -1); 15892 for (int i = 0; i < element.getSource().size(); i++) 15893 composeReference(t, "SubstanceSpecification", "source", element.getSource().get(i), i); 15894 if (element.hasCommentElement()) 15895 composeString(t, "SubstanceSpecification", "comment", element.getCommentElement(), -1); 15896 for (int i = 0; i < element.getMoiety().size(); i++) 15897 composeSubstanceSpecificationSubstanceSpecificationMoietyComponent(t, "SubstanceSpecification", "moiety", element.getMoiety().get(i), i); 15898 for (int i = 0; i < element.getProperty().size(); i++) 15899 composeSubstanceSpecificationSubstanceSpecificationPropertyComponent(t, "SubstanceSpecification", "property", element.getProperty().get(i), i); 15900 if (element.hasReferenceInformation()) 15901 composeReference(t, "SubstanceSpecification", "referenceInformation", element.getReferenceInformation(), -1); 15902 if (element.hasStructure()) 15903 composeSubstanceSpecificationSubstanceSpecificationStructureComponent(t, "SubstanceSpecification", "structure", element.getStructure(), -1); 15904 for (int i = 0; i < element.getCode().size(); i++) 15905 composeSubstanceSpecificationSubstanceSpecificationCodeComponent(t, "SubstanceSpecification", "code", element.getCode().get(i), i); 15906 for (int i = 0; i < element.getName().size(); i++) 15907 composeSubstanceSpecificationSubstanceSpecificationNameComponent(t, "SubstanceSpecification", "name", element.getName().get(i), i); 15908 for (int i = 0; i < element.getMolecularWeight().size(); i++) 15909 composeSubstanceSpecificationSubstanceSpecificationStructureIsotopeMolecularWeightComponent(t, "SubstanceSpecification", "molecularWeight", element.getMolecularWeight().get(i), i); 15910 for (int i = 0; i < element.getRelationship().size(); i++) 15911 composeSubstanceSpecificationSubstanceSpecificationRelationshipComponent(t, "SubstanceSpecification", "relationship", element.getRelationship().get(i), i); 15912 if (element.hasNucleicAcid()) 15913 composeReference(t, "SubstanceSpecification", "nucleicAcid", element.getNucleicAcid(), -1); 15914 if (element.hasPolymer()) 15915 composeReference(t, "SubstanceSpecification", "polymer", element.getPolymer(), -1); 15916 if (element.hasProtein()) 15917 composeReference(t, "SubstanceSpecification", "protein", element.getProtein(), -1); 15918 if (element.hasSourceMaterial()) 15919 composeReference(t, "SubstanceSpecification", "sourceMaterial", element.getSourceMaterial(), -1); 15920 } 15921 15922 protected void composeSubstanceSpecificationSubstanceSpecificationMoietyComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationMoietyComponent element, int index) { 15923 if (element == null) 15924 return; 15925 Complex t; 15926 if (Utilities.noString(parentType)) 15927 t = parent; 15928 else { 15929 t = parent.predicate("fhir:"+parentType+'.'+name); 15930 } 15931 composeBackboneElement(t, "moiety", name, element, index); 15932 if (element.hasRole()) 15933 composeCodeableConcept(t, "SubstanceSpecification", "role", element.getRole(), -1); 15934 if (element.hasIdentifier()) 15935 composeIdentifier(t, "SubstanceSpecification", "identifier", element.getIdentifier(), -1); 15936 if (element.hasNameElement()) 15937 composeString(t, "SubstanceSpecification", "name", element.getNameElement(), -1); 15938 if (element.hasStereochemistry()) 15939 composeCodeableConcept(t, "SubstanceSpecification", "stereochemistry", element.getStereochemistry(), -1); 15940 if (element.hasOpticalActivity()) 15941 composeCodeableConcept(t, "SubstanceSpecification", "opticalActivity", element.getOpticalActivity(), -1); 15942 if (element.hasMolecularFormulaElement()) 15943 composeString(t, "SubstanceSpecification", "molecularFormula", element.getMolecularFormulaElement(), -1); 15944 if (element.hasAmount()) 15945 composeType(t, "SubstanceSpecification", "amount", element.getAmount(), -1); 15946 } 15947 15948 protected void composeSubstanceSpecificationSubstanceSpecificationPropertyComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationPropertyComponent element, int index) { 15949 if (element == null) 15950 return; 15951 Complex t; 15952 if (Utilities.noString(parentType)) 15953 t = parent; 15954 else { 15955 t = parent.predicate("fhir:"+parentType+'.'+name); 15956 } 15957 composeBackboneElement(t, "property", name, element, index); 15958 if (element.hasCategory()) 15959 composeCodeableConcept(t, "SubstanceSpecification", "category", element.getCategory(), -1); 15960 if (element.hasCode()) 15961 composeCodeableConcept(t, "SubstanceSpecification", "code", element.getCode(), -1); 15962 if (element.hasParametersElement()) 15963 composeString(t, "SubstanceSpecification", "parameters", element.getParametersElement(), -1); 15964 if (element.hasDefiningSubstance()) 15965 composeType(t, "SubstanceSpecification", "definingSubstance", element.getDefiningSubstance(), -1); 15966 if (element.hasAmount()) 15967 composeType(t, "SubstanceSpecification", "amount", element.getAmount(), -1); 15968 } 15969 15970 protected void composeSubstanceSpecificationSubstanceSpecificationStructureComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationStructureComponent element, int index) { 15971 if (element == null) 15972 return; 15973 Complex t; 15974 if (Utilities.noString(parentType)) 15975 t = parent; 15976 else { 15977 t = parent.predicate("fhir:"+parentType+'.'+name); 15978 } 15979 composeBackboneElement(t, "structure", name, element, index); 15980 if (element.hasStereochemistry()) 15981 composeCodeableConcept(t, "SubstanceSpecification", "stereochemistry", element.getStereochemistry(), -1); 15982 if (element.hasOpticalActivity()) 15983 composeCodeableConcept(t, "SubstanceSpecification", "opticalActivity", element.getOpticalActivity(), -1); 15984 if (element.hasMolecularFormulaElement()) 15985 composeString(t, "SubstanceSpecification", "molecularFormula", element.getMolecularFormulaElement(), -1); 15986 if (element.hasMolecularFormulaByMoietyElement()) 15987 composeString(t, "SubstanceSpecification", "molecularFormulaByMoiety", element.getMolecularFormulaByMoietyElement(), -1); 15988 for (int i = 0; i < element.getIsotope().size(); i++) 15989 composeSubstanceSpecificationSubstanceSpecificationStructureIsotopeComponent(t, "SubstanceSpecification", "isotope", element.getIsotope().get(i), i); 15990 if (element.hasMolecularWeight()) 15991 composeSubstanceSpecificationSubstanceSpecificationStructureIsotopeMolecularWeightComponent(t, "SubstanceSpecification", "molecularWeight", element.getMolecularWeight(), -1); 15992 for (int i = 0; i < element.getSource().size(); i++) 15993 composeReference(t, "SubstanceSpecification", "source", element.getSource().get(i), i); 15994 for (int i = 0; i < element.getRepresentation().size(); i++) 15995 composeSubstanceSpecificationSubstanceSpecificationStructureRepresentationComponent(t, "SubstanceSpecification", "representation", element.getRepresentation().get(i), i); 15996 } 15997 15998 protected void composeSubstanceSpecificationSubstanceSpecificationStructureIsotopeComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationStructureIsotopeComponent element, int index) { 15999 if (element == null) 16000 return; 16001 Complex t; 16002 if (Utilities.noString(parentType)) 16003 t = parent; 16004 else { 16005 t = parent.predicate("fhir:"+parentType+'.'+name); 16006 } 16007 composeBackboneElement(t, "isotope", name, element, index); 16008 if (element.hasIdentifier()) 16009 composeIdentifier(t, "SubstanceSpecification", "identifier", element.getIdentifier(), -1); 16010 if (element.hasName()) 16011 composeCodeableConcept(t, "SubstanceSpecification", "name", element.getName(), -1); 16012 if (element.hasSubstitution()) 16013 composeCodeableConcept(t, "SubstanceSpecification", "substitution", element.getSubstitution(), -1); 16014 if (element.hasHalfLife()) 16015 composeQuantity(t, "SubstanceSpecification", "halfLife", element.getHalfLife(), -1); 16016 if (element.hasMolecularWeight()) 16017 composeSubstanceSpecificationSubstanceSpecificationStructureIsotopeMolecularWeightComponent(t, "SubstanceSpecification", "molecularWeight", element.getMolecularWeight(), -1); 16018 } 16019 16020 protected void composeSubstanceSpecificationSubstanceSpecificationStructureIsotopeMolecularWeightComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationStructureIsotopeMolecularWeightComponent element, int index) { 16021 if (element == null) 16022 return; 16023 Complex t; 16024 if (Utilities.noString(parentType)) 16025 t = parent; 16026 else { 16027 t = parent.predicate("fhir:"+parentType+'.'+name); 16028 } 16029 composeBackboneElement(t, "molecularWeight", name, element, index); 16030 if (element.hasMethod()) 16031 composeCodeableConcept(t, "SubstanceSpecification", "method", element.getMethod(), -1); 16032 if (element.hasType()) 16033 composeCodeableConcept(t, "SubstanceSpecification", "type", element.getType(), -1); 16034 if (element.hasAmount()) 16035 composeQuantity(t, "SubstanceSpecification", "amount", element.getAmount(), -1); 16036 } 16037 16038 protected void composeSubstanceSpecificationSubstanceSpecificationStructureRepresentationComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationStructureRepresentationComponent element, int index) { 16039 if (element == null) 16040 return; 16041 Complex t; 16042 if (Utilities.noString(parentType)) 16043 t = parent; 16044 else { 16045 t = parent.predicate("fhir:"+parentType+'.'+name); 16046 } 16047 composeBackboneElement(t, "representation", name, element, index); 16048 if (element.hasType()) 16049 composeCodeableConcept(t, "SubstanceSpecification", "type", element.getType(), -1); 16050 if (element.hasRepresentationElement()) 16051 composeString(t, "SubstanceSpecification", "representation", element.getRepresentationElement(), -1); 16052 if (element.hasAttachment()) 16053 composeAttachment(t, "SubstanceSpecification", "attachment", element.getAttachment(), -1); 16054 } 16055 16056 protected void composeSubstanceSpecificationSubstanceSpecificationCodeComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationCodeComponent element, int index) { 16057 if (element == null) 16058 return; 16059 Complex t; 16060 if (Utilities.noString(parentType)) 16061 t = parent; 16062 else { 16063 t = parent.predicate("fhir:"+parentType+'.'+name); 16064 } 16065 composeBackboneElement(t, "code", name, element, index); 16066 if (element.hasCode()) 16067 composeCodeableConcept(t, "SubstanceSpecification", "code", element.getCode(), -1); 16068 if (element.hasStatus()) 16069 composeCodeableConcept(t, "SubstanceSpecification", "status", element.getStatus(), -1); 16070 if (element.hasStatusDateElement()) 16071 composeDateTime(t, "SubstanceSpecification", "statusDate", element.getStatusDateElement(), -1); 16072 if (element.hasCommentElement()) 16073 composeString(t, "SubstanceSpecification", "comment", element.getCommentElement(), -1); 16074 for (int i = 0; i < element.getSource().size(); i++) 16075 composeReference(t, "SubstanceSpecification", "source", element.getSource().get(i), i); 16076 } 16077 16078 protected void composeSubstanceSpecificationSubstanceSpecificationNameComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationNameComponent element, int index) { 16079 if (element == null) 16080 return; 16081 Complex t; 16082 if (Utilities.noString(parentType)) 16083 t = parent; 16084 else { 16085 t = parent.predicate("fhir:"+parentType+'.'+name); 16086 } 16087 composeBackboneElement(t, "name", name, element, index); 16088 if (element.hasNameElement()) 16089 composeString(t, "SubstanceSpecification", "name", element.getNameElement(), -1); 16090 if (element.hasType()) 16091 composeCodeableConcept(t, "SubstanceSpecification", "type", element.getType(), -1); 16092 if (element.hasStatus()) 16093 composeCodeableConcept(t, "SubstanceSpecification", "status", element.getStatus(), -1); 16094 if (element.hasPreferredElement()) 16095 composeBoolean(t, "SubstanceSpecification", "preferred", element.getPreferredElement(), -1); 16096 for (int i = 0; i < element.getLanguage().size(); i++) 16097 composeCodeableConcept(t, "SubstanceSpecification", "language", element.getLanguage().get(i), i); 16098 for (int i = 0; i < element.getDomain().size(); i++) 16099 composeCodeableConcept(t, "SubstanceSpecification", "domain", element.getDomain().get(i), i); 16100 for (int i = 0; i < element.getJurisdiction().size(); i++) 16101 composeCodeableConcept(t, "SubstanceSpecification", "jurisdiction", element.getJurisdiction().get(i), i); 16102 for (int i = 0; i < element.getSynonym().size(); i++) 16103 composeSubstanceSpecificationSubstanceSpecificationNameComponent(t, "SubstanceSpecification", "synonym", element.getSynonym().get(i), i); 16104 for (int i = 0; i < element.getTranslation().size(); i++) 16105 composeSubstanceSpecificationSubstanceSpecificationNameComponent(t, "SubstanceSpecification", "translation", element.getTranslation().get(i), i); 16106 for (int i = 0; i < element.getOfficial().size(); i++) 16107 composeSubstanceSpecificationSubstanceSpecificationNameOfficialComponent(t, "SubstanceSpecification", "official", element.getOfficial().get(i), i); 16108 for (int i = 0; i < element.getSource().size(); i++) 16109 composeReference(t, "SubstanceSpecification", "source", element.getSource().get(i), i); 16110 } 16111 16112 protected void composeSubstanceSpecificationSubstanceSpecificationNameOfficialComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationNameOfficialComponent element, int index) { 16113 if (element == null) 16114 return; 16115 Complex t; 16116 if (Utilities.noString(parentType)) 16117 t = parent; 16118 else { 16119 t = parent.predicate("fhir:"+parentType+'.'+name); 16120 } 16121 composeBackboneElement(t, "official", name, element, index); 16122 if (element.hasAuthority()) 16123 composeCodeableConcept(t, "SubstanceSpecification", "authority", element.getAuthority(), -1); 16124 if (element.hasStatus()) 16125 composeCodeableConcept(t, "SubstanceSpecification", "status", element.getStatus(), -1); 16126 if (element.hasDateElement()) 16127 composeDateTime(t, "SubstanceSpecification", "date", element.getDateElement(), -1); 16128 } 16129 16130 protected void composeSubstanceSpecificationSubstanceSpecificationRelationshipComponent(Complex parent, String parentType, String name, SubstanceSpecification.SubstanceSpecificationRelationshipComponent element, int index) { 16131 if (element == null) 16132 return; 16133 Complex t; 16134 if (Utilities.noString(parentType)) 16135 t = parent; 16136 else { 16137 t = parent.predicate("fhir:"+parentType+'.'+name); 16138 } 16139 composeBackboneElement(t, "relationship", name, element, index); 16140 if (element.hasSubstance()) 16141 composeType(t, "SubstanceSpecification", "substance", element.getSubstance(), -1); 16142 if (element.hasRelationship()) 16143 composeCodeableConcept(t, "SubstanceSpecification", "relationship", element.getRelationship(), -1); 16144 if (element.hasIsDefiningElement()) 16145 composeBoolean(t, "SubstanceSpecification", "isDefining", element.getIsDefiningElement(), -1); 16146 if (element.hasAmount()) 16147 composeType(t, "SubstanceSpecification", "amount", element.getAmount(), -1); 16148 if (element.hasAmountRatioLowLimit()) 16149 composeRatio(t, "SubstanceSpecification", "amountRatioLowLimit", element.getAmountRatioLowLimit(), -1); 16150 if (element.hasAmountType()) 16151 composeCodeableConcept(t, "SubstanceSpecification", "amountType", element.getAmountType(), -1); 16152 for (int i = 0; i < element.getSource().size(); i++) 16153 composeReference(t, "SubstanceSpecification", "source", element.getSource().get(i), i); 16154 } 16155 16156 protected void composeSupplyDelivery(Complex parent, String parentType, String name, SupplyDelivery element, int index) { 16157 if (element == null) 16158 return; 16159 Complex t; 16160 if (Utilities.noString(parentType)) 16161 t = parent; 16162 else { 16163 t = parent.predicate("fhir:"+parentType+'.'+name); 16164 } 16165 composeDomainResource(t, "SupplyDelivery", name, element, index); 16166 for (int i = 0; i < element.getIdentifier().size(); i++) 16167 composeIdentifier(t, "SupplyDelivery", "identifier", element.getIdentifier().get(i), i); 16168 for (int i = 0; i < element.getBasedOn().size(); i++) 16169 composeReference(t, "SupplyDelivery", "basedOn", element.getBasedOn().get(i), i); 16170 for (int i = 0; i < element.getPartOf().size(); i++) 16171 composeReference(t, "SupplyDelivery", "partOf", element.getPartOf().get(i), i); 16172 if (element.hasStatusElement()) 16173 composeEnum(t, "SupplyDelivery", "status", element.getStatusElement(), -1); 16174 if (element.hasPatient()) 16175 composeReference(t, "SupplyDelivery", "patient", element.getPatient(), -1); 16176 if (element.hasType()) 16177 composeCodeableConcept(t, "SupplyDelivery", "type", element.getType(), -1); 16178 if (element.hasSuppliedItem()) 16179 composeSupplyDeliverySupplyDeliverySuppliedItemComponent(t, "SupplyDelivery", "suppliedItem", element.getSuppliedItem(), -1); 16180 if (element.hasOccurrence()) 16181 composeType(t, "SupplyDelivery", "occurrence", element.getOccurrence(), -1); 16182 if (element.hasSupplier()) 16183 composeReference(t, "SupplyDelivery", "supplier", element.getSupplier(), -1); 16184 if (element.hasDestination()) 16185 composeReference(t, "SupplyDelivery", "destination", element.getDestination(), -1); 16186 for (int i = 0; i < element.getReceiver().size(); i++) 16187 composeReference(t, "SupplyDelivery", "receiver", element.getReceiver().get(i), i); 16188 } 16189 16190 protected void composeSupplyDeliverySupplyDeliverySuppliedItemComponent(Complex parent, String parentType, String name, SupplyDelivery.SupplyDeliverySuppliedItemComponent element, int index) { 16191 if (element == null) 16192 return; 16193 Complex t; 16194 if (Utilities.noString(parentType)) 16195 t = parent; 16196 else { 16197 t = parent.predicate("fhir:"+parentType+'.'+name); 16198 } 16199 composeBackboneElement(t, "suppliedItem", name, element, index); 16200 if (element.hasQuantity()) 16201 composeQuantity(t, "SupplyDelivery", "quantity", element.getQuantity(), -1); 16202 if (element.hasItem()) 16203 composeType(t, "SupplyDelivery", "item", element.getItem(), -1); 16204 } 16205 16206 protected void composeSupplyRequest(Complex parent, String parentType, String name, SupplyRequest element, int index) { 16207 if (element == null) 16208 return; 16209 Complex t; 16210 if (Utilities.noString(parentType)) 16211 t = parent; 16212 else { 16213 t = parent.predicate("fhir:"+parentType+'.'+name); 16214 } 16215 composeDomainResource(t, "SupplyRequest", name, element, index); 16216 for (int i = 0; i < element.getIdentifier().size(); i++) 16217 composeIdentifier(t, "SupplyRequest", "identifier", element.getIdentifier().get(i), i); 16218 if (element.hasStatusElement()) 16219 composeEnum(t, "SupplyRequest", "status", element.getStatusElement(), -1); 16220 if (element.hasCategory()) 16221 composeCodeableConcept(t, "SupplyRequest", "category", element.getCategory(), -1); 16222 if (element.hasPriorityElement()) 16223 composeEnum(t, "SupplyRequest", "priority", element.getPriorityElement(), -1); 16224 if (element.hasItem()) 16225 composeType(t, "SupplyRequest", "item", element.getItem(), -1); 16226 if (element.hasQuantity()) 16227 composeQuantity(t, "SupplyRequest", "quantity", element.getQuantity(), -1); 16228 for (int i = 0; i < element.getParameter().size(); i++) 16229 composeSupplyRequestSupplyRequestParameterComponent(t, "SupplyRequest", "parameter", element.getParameter().get(i), i); 16230 if (element.hasOccurrence()) 16231 composeType(t, "SupplyRequest", "occurrence", element.getOccurrence(), -1); 16232 if (element.hasAuthoredOnElement()) 16233 composeDateTime(t, "SupplyRequest", "authoredOn", element.getAuthoredOnElement(), -1); 16234 if (element.hasRequester()) 16235 composeReference(t, "SupplyRequest", "requester", element.getRequester(), -1); 16236 for (int i = 0; i < element.getSupplier().size(); i++) 16237 composeReference(t, "SupplyRequest", "supplier", element.getSupplier().get(i), i); 16238 for (int i = 0; i < element.getReasonCode().size(); i++) 16239 composeCodeableConcept(t, "SupplyRequest", "reasonCode", element.getReasonCode().get(i), i); 16240 for (int i = 0; i < element.getReasonReference().size(); i++) 16241 composeReference(t, "SupplyRequest", "reasonReference", element.getReasonReference().get(i), i); 16242 if (element.hasDeliverFrom()) 16243 composeReference(t, "SupplyRequest", "deliverFrom", element.getDeliverFrom(), -1); 16244 if (element.hasDeliverTo()) 16245 composeReference(t, "SupplyRequest", "deliverTo", element.getDeliverTo(), -1); 16246 } 16247 16248 protected void composeSupplyRequestSupplyRequestParameterComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestParameterComponent element, int index) { 16249 if (element == null) 16250 return; 16251 Complex t; 16252 if (Utilities.noString(parentType)) 16253 t = parent; 16254 else { 16255 t = parent.predicate("fhir:"+parentType+'.'+name); 16256 } 16257 composeBackboneElement(t, "parameter", name, element, index); 16258 if (element.hasCode()) 16259 composeCodeableConcept(t, "SupplyRequest", "code", element.getCode(), -1); 16260 if (element.hasValue()) 16261 composeType(t, "SupplyRequest", "value", element.getValue(), -1); 16262 } 16263 16264 protected void composeTask(Complex parent, String parentType, String name, Task element, int index) { 16265 if (element == null) 16266 return; 16267 Complex t; 16268 if (Utilities.noString(parentType)) 16269 t = parent; 16270 else { 16271 t = parent.predicate("fhir:"+parentType+'.'+name); 16272 } 16273 composeDomainResource(t, "Task", name, element, index); 16274 for (int i = 0; i < element.getIdentifier().size(); i++) 16275 composeIdentifier(t, "Task", "identifier", element.getIdentifier().get(i), i); 16276 if (element.hasInstantiatesCanonicalElement()) 16277 composeCanonical(t, "Task", "instantiatesCanonical", element.getInstantiatesCanonicalElement(), -1); 16278 if (element.hasInstantiatesUriElement()) 16279 composeUri(t, "Task", "instantiatesUri", element.getInstantiatesUriElement(), -1); 16280 for (int i = 0; i < element.getBasedOn().size(); i++) 16281 composeReference(t, "Task", "basedOn", element.getBasedOn().get(i), i); 16282 if (element.hasGroupIdentifier()) 16283 composeIdentifier(t, "Task", "groupIdentifier", element.getGroupIdentifier(), -1); 16284 for (int i = 0; i < element.getPartOf().size(); i++) 16285 composeReference(t, "Task", "partOf", element.getPartOf().get(i), i); 16286 if (element.hasStatusElement()) 16287 composeEnum(t, "Task", "status", element.getStatusElement(), -1); 16288 if (element.hasStatusReason()) 16289 composeCodeableConcept(t, "Task", "statusReason", element.getStatusReason(), -1); 16290 if (element.hasBusinessStatus()) 16291 composeCodeableConcept(t, "Task", "businessStatus", element.getBusinessStatus(), -1); 16292 if (element.hasIntentElement()) 16293 composeEnum(t, "Task", "intent", element.getIntentElement(), -1); 16294 if (element.hasPriorityElement()) 16295 composeEnum(t, "Task", "priority", element.getPriorityElement(), -1); 16296 if (element.hasCode()) 16297 composeCodeableConcept(t, "Task", "code", element.getCode(), -1); 16298 if (element.hasDescriptionElement()) 16299 composeString(t, "Task", "description", element.getDescriptionElement(), -1); 16300 if (element.hasFocus()) 16301 composeReference(t, "Task", "focus", element.getFocus(), -1); 16302 if (element.hasFor()) 16303 composeReference(t, "Task", "for", element.getFor(), -1); 16304 if (element.hasEncounter()) 16305 composeReference(t, "Task", "encounter", element.getEncounter(), -1); 16306 if (element.hasExecutionPeriod()) 16307 composePeriod(t, "Task", "executionPeriod", element.getExecutionPeriod(), -1); 16308 if (element.hasAuthoredOnElement()) 16309 composeDateTime(t, "Task", "authoredOn", element.getAuthoredOnElement(), -1); 16310 if (element.hasLastModifiedElement()) 16311 composeDateTime(t, "Task", "lastModified", element.getLastModifiedElement(), -1); 16312 if (element.hasRequester()) 16313 composeReference(t, "Task", "requester", element.getRequester(), -1); 16314 for (int i = 0; i < element.getPerformerType().size(); i++) 16315 composeCodeableConcept(t, "Task", "performerType", element.getPerformerType().get(i), i); 16316 if (element.hasOwner()) 16317 composeReference(t, "Task", "owner", element.getOwner(), -1); 16318 if (element.hasLocation()) 16319 composeReference(t, "Task", "location", element.getLocation(), -1); 16320 if (element.hasReasonCode()) 16321 composeCodeableConcept(t, "Task", "reasonCode", element.getReasonCode(), -1); 16322 if (element.hasReasonReference()) 16323 composeReference(t, "Task", "reasonReference", element.getReasonReference(), -1); 16324 for (int i = 0; i < element.getInsurance().size(); i++) 16325 composeReference(t, "Task", "insurance", element.getInsurance().get(i), i); 16326 for (int i = 0; i < element.getNote().size(); i++) 16327 composeAnnotation(t, "Task", "note", element.getNote().get(i), i); 16328 for (int i = 0; i < element.getRelevantHistory().size(); i++) 16329 composeReference(t, "Task", "relevantHistory", element.getRelevantHistory().get(i), i); 16330 if (element.hasRestriction()) 16331 composeTaskTaskRestrictionComponent(t, "Task", "restriction", element.getRestriction(), -1); 16332 for (int i = 0; i < element.getInput().size(); i++) 16333 composeTaskParameterComponent(t, "Task", "input", element.getInput().get(i), i); 16334 for (int i = 0; i < element.getOutput().size(); i++) 16335 composeTaskTaskOutputComponent(t, "Task", "output", element.getOutput().get(i), i); 16336 } 16337 16338 protected void composeTaskTaskRestrictionComponent(Complex parent, String parentType, String name, Task.TaskRestrictionComponent element, int index) { 16339 if (element == null) 16340 return; 16341 Complex t; 16342 if (Utilities.noString(parentType)) 16343 t = parent; 16344 else { 16345 t = parent.predicate("fhir:"+parentType+'.'+name); 16346 } 16347 composeBackboneElement(t, "restriction", name, element, index); 16348 if (element.hasRepetitionsElement()) 16349 composePositiveInt(t, "Task", "repetitions", element.getRepetitionsElement(), -1); 16350 if (element.hasPeriod()) 16351 composePeriod(t, "Task", "period", element.getPeriod(), -1); 16352 for (int i = 0; i < element.getRecipient().size(); i++) 16353 composeReference(t, "Task", "recipient", element.getRecipient().get(i), i); 16354 } 16355 16356 protected void composeTaskParameterComponent(Complex parent, String parentType, String name, Task.ParameterComponent element, int index) { 16357 if (element == null) 16358 return; 16359 Complex t; 16360 if (Utilities.noString(parentType)) 16361 t = parent; 16362 else { 16363 t = parent.predicate("fhir:"+parentType+'.'+name); 16364 } 16365 composeBackboneElement(t, "input", name, element, index); 16366 if (element.hasType()) 16367 composeCodeableConcept(t, "Task", "type", element.getType(), -1); 16368 if (element.hasValue()) 16369 composeType(t, "Task", "value", element.getValue(), -1); 16370 } 16371 16372 protected void composeTaskTaskOutputComponent(Complex parent, String parentType, String name, Task.TaskOutputComponent element, int index) { 16373 if (element == null) 16374 return; 16375 Complex t; 16376 if (Utilities.noString(parentType)) 16377 t = parent; 16378 else { 16379 t = parent.predicate("fhir:"+parentType+'.'+name); 16380 } 16381 composeBackboneElement(t, "output", name, element, index); 16382 if (element.hasType()) 16383 composeCodeableConcept(t, "Task", "type", element.getType(), -1); 16384 if (element.hasValue()) 16385 composeType(t, "Task", "value", element.getValue(), -1); 16386 } 16387 16388 protected void composeTerminologyCapabilities(Complex parent, String parentType, String name, TerminologyCapabilities element, int index) { 16389 if (element == null) 16390 return; 16391 Complex t; 16392 if (Utilities.noString(parentType)) 16393 t = parent; 16394 else { 16395 t = parent.predicate("fhir:"+parentType+'.'+name); 16396 } 16397 composeDomainResource(t, "TerminologyCapabilities", name, element, index); 16398 if (element.hasUrlElement()) 16399 composeUri(t, "TerminologyCapabilities", "url", element.getUrlElement(), -1); 16400 if (element.hasVersionElement()) 16401 composeString(t, "TerminologyCapabilities", "version", element.getVersionElement(), -1); 16402 if (element.hasNameElement()) 16403 composeString(t, "TerminologyCapabilities", "name", element.getNameElement(), -1); 16404 if (element.hasTitleElement()) 16405 composeString(t, "TerminologyCapabilities", "title", element.getTitleElement(), -1); 16406 if (element.hasStatusElement()) 16407 composeEnum(t, "TerminologyCapabilities", "status", element.getStatusElement(), -1); 16408 if (element.hasExperimentalElement()) 16409 composeBoolean(t, "TerminologyCapabilities", "experimental", element.getExperimentalElement(), -1); 16410 if (element.hasDateElement()) 16411 composeDateTime(t, "TerminologyCapabilities", "date", element.getDateElement(), -1); 16412 if (element.hasPublisherElement()) 16413 composeString(t, "TerminologyCapabilities", "publisher", element.getPublisherElement(), -1); 16414 for (int i = 0; i < element.getContact().size(); i++) 16415 composeContactDetail(t, "TerminologyCapabilities", "contact", element.getContact().get(i), i); 16416 if (element.hasDescriptionElement()) 16417 composeMarkdown(t, "TerminologyCapabilities", "description", element.getDescriptionElement(), -1); 16418 for (int i = 0; i < element.getUseContext().size(); i++) 16419 composeUsageContext(t, "TerminologyCapabilities", "useContext", element.getUseContext().get(i), i); 16420 for (int i = 0; i < element.getJurisdiction().size(); i++) 16421 composeCodeableConcept(t, "TerminologyCapabilities", "jurisdiction", element.getJurisdiction().get(i), i); 16422 if (element.hasPurposeElement()) 16423 composeMarkdown(t, "TerminologyCapabilities", "purpose", element.getPurposeElement(), -1); 16424 if (element.hasCopyrightElement()) 16425 composeMarkdown(t, "TerminologyCapabilities", "copyright", element.getCopyrightElement(), -1); 16426 if (element.hasKindElement()) 16427 composeEnum(t, "TerminologyCapabilities", "kind", element.getKindElement(), -1); 16428 if (element.hasSoftware()) 16429 composeTerminologyCapabilitiesTerminologyCapabilitiesSoftwareComponent(t, "TerminologyCapabilities", "software", element.getSoftware(), -1); 16430 if (element.hasImplementation()) 16431 composeTerminologyCapabilitiesTerminologyCapabilitiesImplementationComponent(t, "TerminologyCapabilities", "implementation", element.getImplementation(), -1); 16432 if (element.hasLockedDateElement()) 16433 composeBoolean(t, "TerminologyCapabilities", "lockedDate", element.getLockedDateElement(), -1); 16434 for (int i = 0; i < element.getCodeSystem().size(); i++) 16435 composeTerminologyCapabilitiesTerminologyCapabilitiesCodeSystemComponent(t, "TerminologyCapabilities", "codeSystem", element.getCodeSystem().get(i), i); 16436 if (element.hasExpansion()) 16437 composeTerminologyCapabilitiesTerminologyCapabilitiesExpansionComponent(t, "TerminologyCapabilities", "expansion", element.getExpansion(), -1); 16438 if (element.hasCodeSearchElement()) 16439 composeEnum(t, "TerminologyCapabilities", "codeSearch", element.getCodeSearchElement(), -1); 16440 if (element.hasValidateCode()) 16441 composeTerminologyCapabilitiesTerminologyCapabilitiesValidateCodeComponent(t, "TerminologyCapabilities", "validateCode", element.getValidateCode(), -1); 16442 if (element.hasTranslation()) 16443 composeTerminologyCapabilitiesTerminologyCapabilitiesTranslationComponent(t, "TerminologyCapabilities", "translation", element.getTranslation(), -1); 16444 if (element.hasClosure()) 16445 composeTerminologyCapabilitiesTerminologyCapabilitiesClosureComponent(t, "TerminologyCapabilities", "closure", element.getClosure(), -1); 16446 } 16447 16448 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesSoftwareComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesSoftwareComponent element, int index) { 16449 if (element == null) 16450 return; 16451 Complex t; 16452 if (Utilities.noString(parentType)) 16453 t = parent; 16454 else { 16455 t = parent.predicate("fhir:"+parentType+'.'+name); 16456 } 16457 composeBackboneElement(t, "software", name, element, index); 16458 if (element.hasNameElement()) 16459 composeString(t, "TerminologyCapabilities", "name", element.getNameElement(), -1); 16460 if (element.hasVersionElement()) 16461 composeString(t, "TerminologyCapabilities", "version", element.getVersionElement(), -1); 16462 } 16463 16464 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesImplementationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesImplementationComponent element, int index) { 16465 if (element == null) 16466 return; 16467 Complex t; 16468 if (Utilities.noString(parentType)) 16469 t = parent; 16470 else { 16471 t = parent.predicate("fhir:"+parentType+'.'+name); 16472 } 16473 composeBackboneElement(t, "implementation", name, element, index); 16474 if (element.hasDescriptionElement()) 16475 composeString(t, "TerminologyCapabilities", "description", element.getDescriptionElement(), -1); 16476 if (element.hasUrlElement()) 16477 composeUrl(t, "TerminologyCapabilities", "url", element.getUrlElement(), -1); 16478 } 16479 16480 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesCodeSystemComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemComponent element, int index) { 16481 if (element == null) 16482 return; 16483 Complex t; 16484 if (Utilities.noString(parentType)) 16485 t = parent; 16486 else { 16487 t = parent.predicate("fhir:"+parentType+'.'+name); 16488 } 16489 composeBackboneElement(t, "codeSystem", name, element, index); 16490 if (element.hasUriElement()) 16491 composeCanonical(t, "TerminologyCapabilities", "uri", element.getUriElement(), -1); 16492 for (int i = 0; i < element.getVersion().size(); i++) 16493 composeTerminologyCapabilitiesTerminologyCapabilitiesCodeSystemVersionComponent(t, "TerminologyCapabilities", "version", element.getVersion().get(i), i); 16494 if (element.hasSubsumptionElement()) 16495 composeBoolean(t, "TerminologyCapabilities", "subsumption", element.getSubsumptionElement(), -1); 16496 } 16497 16498 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesCodeSystemVersionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionComponent element, int index) { 16499 if (element == null) 16500 return; 16501 Complex t; 16502 if (Utilities.noString(parentType)) 16503 t = parent; 16504 else { 16505 t = parent.predicate("fhir:"+parentType+'.'+name); 16506 } 16507 composeBackboneElement(t, "version", name, element, index); 16508 if (element.hasCodeElement()) 16509 composeString(t, "TerminologyCapabilities", "code", element.getCodeElement(), -1); 16510 if (element.hasIsDefaultElement()) 16511 composeBoolean(t, "TerminologyCapabilities", "isDefault", element.getIsDefaultElement(), -1); 16512 if (element.hasCompositionalElement()) 16513 composeBoolean(t, "TerminologyCapabilities", "compositional", element.getCompositionalElement(), -1); 16514 for (int i = 0; i < element.getLanguage().size(); i++) 16515 composeCode(t, "TerminologyCapabilities", "language", element.getLanguage().get(i), i); 16516 for (int i = 0; i < element.getFilter().size(); i++) 16517 composeTerminologyCapabilitiesTerminologyCapabilitiesCodeSystemVersionFilterComponent(t, "TerminologyCapabilities", "filter", element.getFilter().get(i), i); 16518 for (int i = 0; i < element.getProperty().size(); i++) 16519 composeCode(t, "TerminologyCapabilities", "property", element.getProperty().get(i), i); 16520 } 16521 16522 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesCodeSystemVersionFilterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionFilterComponent element, int index) { 16523 if (element == null) 16524 return; 16525 Complex t; 16526 if (Utilities.noString(parentType)) 16527 t = parent; 16528 else { 16529 t = parent.predicate("fhir:"+parentType+'.'+name); 16530 } 16531 composeBackboneElement(t, "filter", name, element, index); 16532 if (element.hasCodeElement()) 16533 composeCode(t, "TerminologyCapabilities", "code", element.getCodeElement(), -1); 16534 for (int i = 0; i < element.getOp().size(); i++) 16535 composeCode(t, "TerminologyCapabilities", "op", element.getOp().get(i), i); 16536 } 16537 16538 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesExpansionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionComponent element, int index) { 16539 if (element == null) 16540 return; 16541 Complex t; 16542 if (Utilities.noString(parentType)) 16543 t = parent; 16544 else { 16545 t = parent.predicate("fhir:"+parentType+'.'+name); 16546 } 16547 composeBackboneElement(t, "expansion", name, element, index); 16548 if (element.hasHierarchicalElement()) 16549 composeBoolean(t, "TerminologyCapabilities", "hierarchical", element.getHierarchicalElement(), -1); 16550 if (element.hasPagingElement()) 16551 composeBoolean(t, "TerminologyCapabilities", "paging", element.getPagingElement(), -1); 16552 if (element.hasIncompleteElement()) 16553 composeBoolean(t, "TerminologyCapabilities", "incomplete", element.getIncompleteElement(), -1); 16554 for (int i = 0; i < element.getParameter().size(); i++) 16555 composeTerminologyCapabilitiesTerminologyCapabilitiesExpansionParameterComponent(t, "TerminologyCapabilities", "parameter", element.getParameter().get(i), i); 16556 if (element.hasTextFilterElement()) 16557 composeMarkdown(t, "TerminologyCapabilities", "textFilter", element.getTextFilterElement(), -1); 16558 } 16559 16560 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesExpansionParameterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionParameterComponent element, int index) { 16561 if (element == null) 16562 return; 16563 Complex t; 16564 if (Utilities.noString(parentType)) 16565 t = parent; 16566 else { 16567 t = parent.predicate("fhir:"+parentType+'.'+name); 16568 } 16569 composeBackboneElement(t, "parameter", name, element, index); 16570 if (element.hasNameElement()) 16571 composeCode(t, "TerminologyCapabilities", "name", element.getNameElement(), -1); 16572 if (element.hasDocumentationElement()) 16573 composeString(t, "TerminologyCapabilities", "documentation", element.getDocumentationElement(), -1); 16574 } 16575 16576 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesValidateCodeComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesValidateCodeComponent element, int index) { 16577 if (element == null) 16578 return; 16579 Complex t; 16580 if (Utilities.noString(parentType)) 16581 t = parent; 16582 else { 16583 t = parent.predicate("fhir:"+parentType+'.'+name); 16584 } 16585 composeBackboneElement(t, "validateCode", name, element, index); 16586 if (element.hasTranslationsElement()) 16587 composeBoolean(t, "TerminologyCapabilities", "translations", element.getTranslationsElement(), -1); 16588 } 16589 16590 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesTranslationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesTranslationComponent element, int index) { 16591 if (element == null) 16592 return; 16593 Complex t; 16594 if (Utilities.noString(parentType)) 16595 t = parent; 16596 else { 16597 t = parent.predicate("fhir:"+parentType+'.'+name); 16598 } 16599 composeBackboneElement(t, "translation", name, element, index); 16600 if (element.hasNeedsMapElement()) 16601 composeBoolean(t, "TerminologyCapabilities", "needsMap", element.getNeedsMapElement(), -1); 16602 } 16603 16604 protected void composeTerminologyCapabilitiesTerminologyCapabilitiesClosureComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesClosureComponent element, int index) { 16605 if (element == null) 16606 return; 16607 Complex t; 16608 if (Utilities.noString(parentType)) 16609 t = parent; 16610 else { 16611 t = parent.predicate("fhir:"+parentType+'.'+name); 16612 } 16613 composeBackboneElement(t, "closure", name, element, index); 16614 if (element.hasTranslationElement()) 16615 composeBoolean(t, "TerminologyCapabilities", "translation", element.getTranslationElement(), -1); 16616 } 16617 16618 protected void composeTestReport(Complex parent, String parentType, String name, TestReport element, int index) { 16619 if (element == null) 16620 return; 16621 Complex t; 16622 if (Utilities.noString(parentType)) 16623 t = parent; 16624 else { 16625 t = parent.predicate("fhir:"+parentType+'.'+name); 16626 } 16627 composeDomainResource(t, "TestReport", name, element, index); 16628 if (element.hasIdentifier()) 16629 composeIdentifier(t, "TestReport", "identifier", element.getIdentifier(), -1); 16630 if (element.hasNameElement()) 16631 composeString(t, "TestReport", "name", element.getNameElement(), -1); 16632 if (element.hasStatusElement()) 16633 composeEnum(t, "TestReport", "status", element.getStatusElement(), -1); 16634 if (element.hasTestScript()) 16635 composeReference(t, "TestReport", "testScript", element.getTestScript(), -1); 16636 if (element.hasResultElement()) 16637 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 16638 if (element.hasScoreElement()) 16639 composeDecimal(t, "TestReport", "score", element.getScoreElement(), -1); 16640 if (element.hasTesterElement()) 16641 composeString(t, "TestReport", "tester", element.getTesterElement(), -1); 16642 if (element.hasIssuedElement()) 16643 composeDateTime(t, "TestReport", "issued", element.getIssuedElement(), -1); 16644 for (int i = 0; i < element.getParticipant().size(); i++) 16645 composeTestReportTestReportParticipantComponent(t, "TestReport", "participant", element.getParticipant().get(i), i); 16646 if (element.hasSetup()) 16647 composeTestReportTestReportSetupComponent(t, "TestReport", "setup", element.getSetup(), -1); 16648 for (int i = 0; i < element.getTest().size(); i++) 16649 composeTestReportTestReportTestComponent(t, "TestReport", "test", element.getTest().get(i), i); 16650 if (element.hasTeardown()) 16651 composeTestReportTestReportTeardownComponent(t, "TestReport", "teardown", element.getTeardown(), -1); 16652 } 16653 16654 protected void composeTestReportTestReportParticipantComponent(Complex parent, String parentType, String name, TestReport.TestReportParticipantComponent element, int index) { 16655 if (element == null) 16656 return; 16657 Complex t; 16658 if (Utilities.noString(parentType)) 16659 t = parent; 16660 else { 16661 t = parent.predicate("fhir:"+parentType+'.'+name); 16662 } 16663 composeBackboneElement(t, "participant", name, element, index); 16664 if (element.hasTypeElement()) 16665 composeEnum(t, "TestReport", "type", element.getTypeElement(), -1); 16666 if (element.hasUriElement()) 16667 composeUri(t, "TestReport", "uri", element.getUriElement(), -1); 16668 if (element.hasDisplayElement()) 16669 composeString(t, "TestReport", "display", element.getDisplayElement(), -1); 16670 } 16671 16672 protected void composeTestReportTestReportSetupComponent(Complex parent, String parentType, String name, TestReport.TestReportSetupComponent element, int index) { 16673 if (element == null) 16674 return; 16675 Complex t; 16676 if (Utilities.noString(parentType)) 16677 t = parent; 16678 else { 16679 t = parent.predicate("fhir:"+parentType+'.'+name); 16680 } 16681 composeBackboneElement(t, "setup", name, element, index); 16682 for (int i = 0; i < element.getAction().size(); i++) 16683 composeTestReportSetupActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 16684 } 16685 16686 protected void composeTestReportSetupActionComponent(Complex parent, String parentType, String name, TestReport.SetupActionComponent element, int index) { 16687 if (element == null) 16688 return; 16689 Complex t; 16690 if (Utilities.noString(parentType)) 16691 t = parent; 16692 else { 16693 t = parent.predicate("fhir:"+parentType+'.'+name); 16694 } 16695 composeBackboneElement(t, "action", name, element, index); 16696 if (element.hasOperation()) 16697 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 16698 if (element.hasAssert()) 16699 composeTestReportSetupActionAssertComponent(t, "TestReport", "assert", element.getAssert(), -1); 16700 } 16701 16702 protected void composeTestReportSetupActionOperationComponent(Complex parent, String parentType, String name, TestReport.SetupActionOperationComponent element, int index) { 16703 if (element == null) 16704 return; 16705 Complex t; 16706 if (Utilities.noString(parentType)) 16707 t = parent; 16708 else { 16709 t = parent.predicate("fhir:"+parentType+'.'+name); 16710 } 16711 composeBackboneElement(t, "operation", name, element, index); 16712 if (element.hasResultElement()) 16713 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 16714 if (element.hasMessageElement()) 16715 composeMarkdown(t, "TestReport", "message", element.getMessageElement(), -1); 16716 if (element.hasDetailElement()) 16717 composeUri(t, "TestReport", "detail", element.getDetailElement(), -1); 16718 } 16719 16720 protected void composeTestReportSetupActionAssertComponent(Complex parent, String parentType, String name, TestReport.SetupActionAssertComponent element, int index) { 16721 if (element == null) 16722 return; 16723 Complex t; 16724 if (Utilities.noString(parentType)) 16725 t = parent; 16726 else { 16727 t = parent.predicate("fhir:"+parentType+'.'+name); 16728 } 16729 composeBackboneElement(t, "assert", name, element, index); 16730 if (element.hasResultElement()) 16731 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 16732 if (element.hasMessageElement()) 16733 composeMarkdown(t, "TestReport", "message", element.getMessageElement(), -1); 16734 if (element.hasDetailElement()) 16735 composeString(t, "TestReport", "detail", element.getDetailElement(), -1); 16736 } 16737 16738 protected void composeTestReportTestReportTestComponent(Complex parent, String parentType, String name, TestReport.TestReportTestComponent element, int index) { 16739 if (element == null) 16740 return; 16741 Complex t; 16742 if (Utilities.noString(parentType)) 16743 t = parent; 16744 else { 16745 t = parent.predicate("fhir:"+parentType+'.'+name); 16746 } 16747 composeBackboneElement(t, "test", name, element, index); 16748 if (element.hasNameElement()) 16749 composeString(t, "TestReport", "name", element.getNameElement(), -1); 16750 if (element.hasDescriptionElement()) 16751 composeString(t, "TestReport", "description", element.getDescriptionElement(), -1); 16752 for (int i = 0; i < element.getAction().size(); i++) 16753 composeTestReportTestActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 16754 } 16755 16756 protected void composeTestReportTestActionComponent(Complex parent, String parentType, String name, TestReport.TestActionComponent element, int index) { 16757 if (element == null) 16758 return; 16759 Complex t; 16760 if (Utilities.noString(parentType)) 16761 t = parent; 16762 else { 16763 t = parent.predicate("fhir:"+parentType+'.'+name); 16764 } 16765 composeBackboneElement(t, "action", name, element, index); 16766 if (element.hasOperation()) 16767 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 16768 if (element.hasAssert()) 16769 composeTestReportSetupActionAssertComponent(t, "TestReport", "assert", element.getAssert(), -1); 16770 } 16771 16772 protected void composeTestReportTestReportTeardownComponent(Complex parent, String parentType, String name, TestReport.TestReportTeardownComponent element, int index) { 16773 if (element == null) 16774 return; 16775 Complex t; 16776 if (Utilities.noString(parentType)) 16777 t = parent; 16778 else { 16779 t = parent.predicate("fhir:"+parentType+'.'+name); 16780 } 16781 composeBackboneElement(t, "teardown", name, element, index); 16782 for (int i = 0; i < element.getAction().size(); i++) 16783 composeTestReportTeardownActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 16784 } 16785 16786 protected void composeTestReportTeardownActionComponent(Complex parent, String parentType, String name, TestReport.TeardownActionComponent element, int index) { 16787 if (element == null) 16788 return; 16789 Complex t; 16790 if (Utilities.noString(parentType)) 16791 t = parent; 16792 else { 16793 t = parent.predicate("fhir:"+parentType+'.'+name); 16794 } 16795 composeBackboneElement(t, "action", name, element, index); 16796 if (element.hasOperation()) 16797 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 16798 } 16799 16800 protected void composeTestScript(Complex parent, String parentType, String name, TestScript element, int index) { 16801 if (element == null) 16802 return; 16803 Complex t; 16804 if (Utilities.noString(parentType)) 16805 t = parent; 16806 else { 16807 t = parent.predicate("fhir:"+parentType+'.'+name); 16808 } 16809 composeDomainResource(t, "TestScript", name, element, index); 16810 if (element.hasUrlElement()) 16811 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 16812 if (element.hasIdentifier()) 16813 composeIdentifier(t, "TestScript", "identifier", element.getIdentifier(), -1); 16814 if (element.hasVersionElement()) 16815 composeString(t, "TestScript", "version", element.getVersionElement(), -1); 16816 if (element.hasNameElement()) 16817 composeString(t, "TestScript", "name", element.getNameElement(), -1); 16818 if (element.hasTitleElement()) 16819 composeString(t, "TestScript", "title", element.getTitleElement(), -1); 16820 if (element.hasStatusElement()) 16821 composeEnum(t, "TestScript", "status", element.getStatusElement(), -1); 16822 if (element.hasExperimentalElement()) 16823 composeBoolean(t, "TestScript", "experimental", element.getExperimentalElement(), -1); 16824 if (element.hasDateElement()) 16825 composeDateTime(t, "TestScript", "date", element.getDateElement(), -1); 16826 if (element.hasPublisherElement()) 16827 composeString(t, "TestScript", "publisher", element.getPublisherElement(), -1); 16828 for (int i = 0; i < element.getContact().size(); i++) 16829 composeContactDetail(t, "TestScript", "contact", element.getContact().get(i), i); 16830 if (element.hasDescriptionElement()) 16831 composeMarkdown(t, "TestScript", "description", element.getDescriptionElement(), -1); 16832 for (int i = 0; i < element.getUseContext().size(); i++) 16833 composeUsageContext(t, "TestScript", "useContext", element.getUseContext().get(i), i); 16834 for (int i = 0; i < element.getJurisdiction().size(); i++) 16835 composeCodeableConcept(t, "TestScript", "jurisdiction", element.getJurisdiction().get(i), i); 16836 if (element.hasPurposeElement()) 16837 composeMarkdown(t, "TestScript", "purpose", element.getPurposeElement(), -1); 16838 if (element.hasCopyrightElement()) 16839 composeMarkdown(t, "TestScript", "copyright", element.getCopyrightElement(), -1); 16840 for (int i = 0; i < element.getOrigin().size(); i++) 16841 composeTestScriptTestScriptOriginComponent(t, "TestScript", "origin", element.getOrigin().get(i), i); 16842 for (int i = 0; i < element.getDestination().size(); i++) 16843 composeTestScriptTestScriptDestinationComponent(t, "TestScript", "destination", element.getDestination().get(i), i); 16844 if (element.hasMetadata()) 16845 composeTestScriptTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1); 16846 for (int i = 0; i < element.getFixture().size(); i++) 16847 composeTestScriptTestScriptFixtureComponent(t, "TestScript", "fixture", element.getFixture().get(i), i); 16848 for (int i = 0; i < element.getProfile().size(); i++) 16849 composeReference(t, "TestScript", "profile", element.getProfile().get(i), i); 16850 for (int i = 0; i < element.getVariable().size(); i++) 16851 composeTestScriptTestScriptVariableComponent(t, "TestScript", "variable", element.getVariable().get(i), i); 16852 if (element.hasSetup()) 16853 composeTestScriptTestScriptSetupComponent(t, "TestScript", "setup", element.getSetup(), -1); 16854 for (int i = 0; i < element.getTest().size(); i++) 16855 composeTestScriptTestScriptTestComponent(t, "TestScript", "test", element.getTest().get(i), i); 16856 if (element.hasTeardown()) 16857 composeTestScriptTestScriptTeardownComponent(t, "TestScript", "teardown", element.getTeardown(), -1); 16858 } 16859 16860 protected void composeTestScriptTestScriptOriginComponent(Complex parent, String parentType, String name, TestScript.TestScriptOriginComponent element, int index) { 16861 if (element == null) 16862 return; 16863 Complex t; 16864 if (Utilities.noString(parentType)) 16865 t = parent; 16866 else { 16867 t = parent.predicate("fhir:"+parentType+'.'+name); 16868 } 16869 composeBackboneElement(t, "origin", name, element, index); 16870 if (element.hasIndexElement()) 16871 composeInteger(t, "TestScript", "index", element.getIndexElement(), -1); 16872 if (element.hasProfile()) 16873 composeCoding(t, "TestScript", "profile", element.getProfile(), -1); 16874 } 16875 16876 protected void composeTestScriptTestScriptDestinationComponent(Complex parent, String parentType, String name, TestScript.TestScriptDestinationComponent element, int index) { 16877 if (element == null) 16878 return; 16879 Complex t; 16880 if (Utilities.noString(parentType)) 16881 t = parent; 16882 else { 16883 t = parent.predicate("fhir:"+parentType+'.'+name); 16884 } 16885 composeBackboneElement(t, "destination", name, element, index); 16886 if (element.hasIndexElement()) 16887 composeInteger(t, "TestScript", "index", element.getIndexElement(), -1); 16888 if (element.hasProfile()) 16889 composeCoding(t, "TestScript", "profile", element.getProfile(), -1); 16890 } 16891 16892 protected void composeTestScriptTestScriptMetadataComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataComponent element, int index) { 16893 if (element == null) 16894 return; 16895 Complex t; 16896 if (Utilities.noString(parentType)) 16897 t = parent; 16898 else { 16899 t = parent.predicate("fhir:"+parentType+'.'+name); 16900 } 16901 composeBackboneElement(t, "metadata", name, element, index); 16902 for (int i = 0; i < element.getLink().size(); i++) 16903 composeTestScriptTestScriptMetadataLinkComponent(t, "TestScript", "link", element.getLink().get(i), i); 16904 for (int i = 0; i < element.getCapability().size(); i++) 16905 composeTestScriptTestScriptMetadataCapabilityComponent(t, "TestScript", "capability", element.getCapability().get(i), i); 16906 } 16907 16908 protected void composeTestScriptTestScriptMetadataLinkComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataLinkComponent element, int index) { 16909 if (element == null) 16910 return; 16911 Complex t; 16912 if (Utilities.noString(parentType)) 16913 t = parent; 16914 else { 16915 t = parent.predicate("fhir:"+parentType+'.'+name); 16916 } 16917 composeBackboneElement(t, "link", name, element, index); 16918 if (element.hasUrlElement()) 16919 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 16920 if (element.hasDescriptionElement()) 16921 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 16922 } 16923 16924 protected void composeTestScriptTestScriptMetadataCapabilityComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataCapabilityComponent element, int index) { 16925 if (element == null) 16926 return; 16927 Complex t; 16928 if (Utilities.noString(parentType)) 16929 t = parent; 16930 else { 16931 t = parent.predicate("fhir:"+parentType+'.'+name); 16932 } 16933 composeBackboneElement(t, "capability", name, element, index); 16934 if (element.hasRequiredElement()) 16935 composeBoolean(t, "TestScript", "required", element.getRequiredElement(), -1); 16936 if (element.hasValidatedElement()) 16937 composeBoolean(t, "TestScript", "validated", element.getValidatedElement(), -1); 16938 if (element.hasDescriptionElement()) 16939 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 16940 for (int i = 0; i < element.getOrigin().size(); i++) 16941 composeInteger(t, "TestScript", "origin", element.getOrigin().get(i), i); 16942 if (element.hasDestinationElement()) 16943 composeInteger(t, "TestScript", "destination", element.getDestinationElement(), -1); 16944 for (int i = 0; i < element.getLink().size(); i++) 16945 composeUri(t, "TestScript", "link", element.getLink().get(i), i); 16946 if (element.hasCapabilitiesElement()) 16947 composeCanonical(t, "TestScript", "capabilities", element.getCapabilitiesElement(), -1); 16948 } 16949 16950 protected void composeTestScriptTestScriptFixtureComponent(Complex parent, String parentType, String name, TestScript.TestScriptFixtureComponent element, int index) { 16951 if (element == null) 16952 return; 16953 Complex t; 16954 if (Utilities.noString(parentType)) 16955 t = parent; 16956 else { 16957 t = parent.predicate("fhir:"+parentType+'.'+name); 16958 } 16959 composeBackboneElement(t, "fixture", name, element, index); 16960 if (element.hasAutocreateElement()) 16961 composeBoolean(t, "TestScript", "autocreate", element.getAutocreateElement(), -1); 16962 if (element.hasAutodeleteElement()) 16963 composeBoolean(t, "TestScript", "autodelete", element.getAutodeleteElement(), -1); 16964 if (element.hasResource()) 16965 composeReference(t, "TestScript", "resource", element.getResource(), -1); 16966 } 16967 16968 protected void composeTestScriptTestScriptVariableComponent(Complex parent, String parentType, String name, TestScript.TestScriptVariableComponent element, int index) { 16969 if (element == null) 16970 return; 16971 Complex t; 16972 if (Utilities.noString(parentType)) 16973 t = parent; 16974 else { 16975 t = parent.predicate("fhir:"+parentType+'.'+name); 16976 } 16977 composeBackboneElement(t, "variable", name, element, index); 16978 if (element.hasNameElement()) 16979 composeString(t, "TestScript", "name", element.getNameElement(), -1); 16980 if (element.hasDefaultValueElement()) 16981 composeString(t, "TestScript", "defaultValue", element.getDefaultValueElement(), -1); 16982 if (element.hasDescriptionElement()) 16983 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 16984 if (element.hasExpressionElement()) 16985 composeString(t, "TestScript", "expression", element.getExpressionElement(), -1); 16986 if (element.hasHeaderFieldElement()) 16987 composeString(t, "TestScript", "headerField", element.getHeaderFieldElement(), -1); 16988 if (element.hasHintElement()) 16989 composeString(t, "TestScript", "hint", element.getHintElement(), -1); 16990 if (element.hasPathElement()) 16991 composeString(t, "TestScript", "path", element.getPathElement(), -1); 16992 if (element.hasSourceIdElement()) 16993 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 16994 } 16995 16996 protected void composeTestScriptTestScriptSetupComponent(Complex parent, String parentType, String name, TestScript.TestScriptSetupComponent element, int index) { 16997 if (element == null) 16998 return; 16999 Complex t; 17000 if (Utilities.noString(parentType)) 17001 t = parent; 17002 else { 17003 t = parent.predicate("fhir:"+parentType+'.'+name); 17004 } 17005 composeBackboneElement(t, "setup", name, element, index); 17006 for (int i = 0; i < element.getAction().size(); i++) 17007 composeTestScriptSetupActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 17008 } 17009 17010 protected void composeTestScriptSetupActionComponent(Complex parent, String parentType, String name, TestScript.SetupActionComponent element, int index) { 17011 if (element == null) 17012 return; 17013 Complex t; 17014 if (Utilities.noString(parentType)) 17015 t = parent; 17016 else { 17017 t = parent.predicate("fhir:"+parentType+'.'+name); 17018 } 17019 composeBackboneElement(t, "action", name, element, index); 17020 if (element.hasOperation()) 17021 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 17022 if (element.hasAssert()) 17023 composeTestScriptSetupActionAssertComponent(t, "TestScript", "assert", element.getAssert(), -1); 17024 } 17025 17026 protected void composeTestScriptSetupActionOperationComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationComponent element, int index) { 17027 if (element == null) 17028 return; 17029 Complex t; 17030 if (Utilities.noString(parentType)) 17031 t = parent; 17032 else { 17033 t = parent.predicate("fhir:"+parentType+'.'+name); 17034 } 17035 composeBackboneElement(t, "operation", name, element, index); 17036 if (element.hasType()) 17037 composeCoding(t, "TestScript", "type", element.getType(), -1); 17038 if (element.hasResourceElement()) 17039 composeCode(t, "TestScript", "resource", element.getResourceElement(), -1); 17040 if (element.hasLabelElement()) 17041 composeString(t, "TestScript", "label", element.getLabelElement(), -1); 17042 if (element.hasDescriptionElement()) 17043 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 17044 if (element.hasAcceptElement()) 17045 composeCode(t, "TestScript", "accept", element.getAcceptElement(), -1); 17046 if (element.hasContentTypeElement()) 17047 composeCode(t, "TestScript", "contentType", element.getContentTypeElement(), -1); 17048 if (element.hasDestinationElement()) 17049 composeInteger(t, "TestScript", "destination", element.getDestinationElement(), -1); 17050 if (element.hasEncodeRequestUrlElement()) 17051 composeBoolean(t, "TestScript", "encodeRequestUrl", element.getEncodeRequestUrlElement(), -1); 17052 if (element.hasMethodElement()) 17053 composeEnum(t, "TestScript", "method", element.getMethodElement(), -1); 17054 if (element.hasOriginElement()) 17055 composeInteger(t, "TestScript", "origin", element.getOriginElement(), -1); 17056 if (element.hasParamsElement()) 17057 composeString(t, "TestScript", "params", element.getParamsElement(), -1); 17058 for (int i = 0; i < element.getRequestHeader().size(); i++) 17059 composeTestScriptSetupActionOperationRequestHeaderComponent(t, "TestScript", "requestHeader", element.getRequestHeader().get(i), i); 17060 if (element.hasRequestIdElement()) 17061 composeId(t, "TestScript", "requestId", element.getRequestIdElement(), -1); 17062 if (element.hasResponseIdElement()) 17063 composeId(t, "TestScript", "responseId", element.getResponseIdElement(), -1); 17064 if (element.hasSourceIdElement()) 17065 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 17066 if (element.hasTargetIdElement()) 17067 composeId(t, "TestScript", "targetId", element.getTargetIdElement(), -1); 17068 if (element.hasUrlElement()) 17069 composeString(t, "TestScript", "url", element.getUrlElement(), -1); 17070 } 17071 17072 protected void composeTestScriptSetupActionOperationRequestHeaderComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationRequestHeaderComponent element, int index) { 17073 if (element == null) 17074 return; 17075 Complex t; 17076 if (Utilities.noString(parentType)) 17077 t = parent; 17078 else { 17079 t = parent.predicate("fhir:"+parentType+'.'+name); 17080 } 17081 composeBackboneElement(t, "requestHeader", name, element, index); 17082 if (element.hasFieldElement()) 17083 composeString(t, "TestScript", "field", element.getFieldElement(), -1); 17084 if (element.hasValueElement()) 17085 composeString(t, "TestScript", "value", element.getValueElement(), -1); 17086 } 17087 17088 protected void composeTestScriptSetupActionAssertComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertComponent element, int index) { 17089 if (element == null) 17090 return; 17091 Complex t; 17092 if (Utilities.noString(parentType)) 17093 t = parent; 17094 else { 17095 t = parent.predicate("fhir:"+parentType+'.'+name); 17096 } 17097 composeBackboneElement(t, "assert", name, element, index); 17098 if (element.hasLabelElement()) 17099 composeString(t, "TestScript", "label", element.getLabelElement(), -1); 17100 if (element.hasDescriptionElement()) 17101 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 17102 if (element.hasDirectionElement()) 17103 composeEnum(t, "TestScript", "direction", element.getDirectionElement(), -1); 17104 if (element.hasCompareToSourceIdElement()) 17105 composeString(t, "TestScript", "compareToSourceId", element.getCompareToSourceIdElement(), -1); 17106 if (element.hasCompareToSourceExpressionElement()) 17107 composeString(t, "TestScript", "compareToSourceExpression", element.getCompareToSourceExpressionElement(), -1); 17108 if (element.hasCompareToSourcePathElement()) 17109 composeString(t, "TestScript", "compareToSourcePath", element.getCompareToSourcePathElement(), -1); 17110 if (element.hasContentTypeElement()) 17111 composeCode(t, "TestScript", "contentType", element.getContentTypeElement(), -1); 17112 if (element.hasExpressionElement()) 17113 composeString(t, "TestScript", "expression", element.getExpressionElement(), -1); 17114 if (element.hasHeaderFieldElement()) 17115 composeString(t, "TestScript", "headerField", element.getHeaderFieldElement(), -1); 17116 if (element.hasMinimumIdElement()) 17117 composeString(t, "TestScript", "minimumId", element.getMinimumIdElement(), -1); 17118 if (element.hasNavigationLinksElement()) 17119 composeBoolean(t, "TestScript", "navigationLinks", element.getNavigationLinksElement(), -1); 17120 if (element.hasOperatorElement()) 17121 composeEnum(t, "TestScript", "operator", element.getOperatorElement(), -1); 17122 if (element.hasPathElement()) 17123 composeString(t, "TestScript", "path", element.getPathElement(), -1); 17124 if (element.hasRequestMethodElement()) 17125 composeEnum(t, "TestScript", "requestMethod", element.getRequestMethodElement(), -1); 17126 if (element.hasRequestURLElement()) 17127 composeString(t, "TestScript", "requestURL", element.getRequestURLElement(), -1); 17128 if (element.hasResourceElement()) 17129 composeCode(t, "TestScript", "resource", element.getResourceElement(), -1); 17130 if (element.hasResponseElement()) 17131 composeEnum(t, "TestScript", "response", element.getResponseElement(), -1); 17132 if (element.hasResponseCodeElement()) 17133 composeString(t, "TestScript", "responseCode", element.getResponseCodeElement(), -1); 17134 if (element.hasSourceIdElement()) 17135 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 17136 if (element.hasValidateProfileIdElement()) 17137 composeId(t, "TestScript", "validateProfileId", element.getValidateProfileIdElement(), -1); 17138 if (element.hasValueElement()) 17139 composeString(t, "TestScript", "value", element.getValueElement(), -1); 17140 if (element.hasWarningOnlyElement()) 17141 composeBoolean(t, "TestScript", "warningOnly", element.getWarningOnlyElement(), -1); 17142 } 17143 17144 protected void composeTestScriptTestScriptTestComponent(Complex parent, String parentType, String name, TestScript.TestScriptTestComponent element, int index) { 17145 if (element == null) 17146 return; 17147 Complex t; 17148 if (Utilities.noString(parentType)) 17149 t = parent; 17150 else { 17151 t = parent.predicate("fhir:"+parentType+'.'+name); 17152 } 17153 composeBackboneElement(t, "test", name, element, index); 17154 if (element.hasNameElement()) 17155 composeString(t, "TestScript", "name", element.getNameElement(), -1); 17156 if (element.hasDescriptionElement()) 17157 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 17158 for (int i = 0; i < element.getAction().size(); i++) 17159 composeTestScriptTestActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 17160 } 17161 17162 protected void composeTestScriptTestActionComponent(Complex parent, String parentType, String name, TestScript.TestActionComponent element, int index) { 17163 if (element == null) 17164 return; 17165 Complex t; 17166 if (Utilities.noString(parentType)) 17167 t = parent; 17168 else { 17169 t = parent.predicate("fhir:"+parentType+'.'+name); 17170 } 17171 composeBackboneElement(t, "action", name, element, index); 17172 if (element.hasOperation()) 17173 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 17174 if (element.hasAssert()) 17175 composeTestScriptSetupActionAssertComponent(t, "TestScript", "assert", element.getAssert(), -1); 17176 } 17177 17178 protected void composeTestScriptTestScriptTeardownComponent(Complex parent, String parentType, String name, TestScript.TestScriptTeardownComponent element, int index) { 17179 if (element == null) 17180 return; 17181 Complex t; 17182 if (Utilities.noString(parentType)) 17183 t = parent; 17184 else { 17185 t = parent.predicate("fhir:"+parentType+'.'+name); 17186 } 17187 composeBackboneElement(t, "teardown", name, element, index); 17188 for (int i = 0; i < element.getAction().size(); i++) 17189 composeTestScriptTeardownActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 17190 } 17191 17192 protected void composeTestScriptTeardownActionComponent(Complex parent, String parentType, String name, TestScript.TeardownActionComponent element, int index) { 17193 if (element == null) 17194 return; 17195 Complex t; 17196 if (Utilities.noString(parentType)) 17197 t = parent; 17198 else { 17199 t = parent.predicate("fhir:"+parentType+'.'+name); 17200 } 17201 composeBackboneElement(t, "action", name, element, index); 17202 if (element.hasOperation()) 17203 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 17204 } 17205 17206 protected void composeValueSet(Complex parent, String parentType, String name, ValueSet element, int index) { 17207 if (element == null) 17208 return; 17209 Complex t; 17210 if (Utilities.noString(parentType)) 17211 t = parent; 17212 else { 17213 t = parent.predicate("fhir:"+parentType+'.'+name); 17214 } 17215 composeDomainResource(t, "ValueSet", name, element, index); 17216 if (element.hasUrlElement()) 17217 composeUri(t, "ValueSet", "url", element.getUrlElement(), -1); 17218 for (int i = 0; i < element.getIdentifier().size(); i++) 17219 composeIdentifier(t, "ValueSet", "identifier", element.getIdentifier().get(i), i); 17220 if (element.hasVersionElement()) 17221 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 17222 if (element.hasNameElement()) 17223 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 17224 if (element.hasTitleElement()) 17225 composeString(t, "ValueSet", "title", element.getTitleElement(), -1); 17226 if (element.hasStatusElement()) 17227 composeEnum(t, "ValueSet", "status", element.getStatusElement(), -1); 17228 if (element.hasExperimentalElement()) 17229 composeBoolean(t, "ValueSet", "experimental", element.getExperimentalElement(), -1); 17230 if (element.hasDateElement()) 17231 composeDateTime(t, "ValueSet", "date", element.getDateElement(), -1); 17232 if (element.hasPublisherElement()) 17233 composeString(t, "ValueSet", "publisher", element.getPublisherElement(), -1); 17234 for (int i = 0; i < element.getContact().size(); i++) 17235 composeContactDetail(t, "ValueSet", "contact", element.getContact().get(i), i); 17236 if (element.hasDescriptionElement()) 17237 composeMarkdown(t, "ValueSet", "description", element.getDescriptionElement(), -1); 17238 for (int i = 0; i < element.getUseContext().size(); i++) 17239 composeUsageContext(t, "ValueSet", "useContext", element.getUseContext().get(i), i); 17240 for (int i = 0; i < element.getJurisdiction().size(); i++) 17241 composeCodeableConcept(t, "ValueSet", "jurisdiction", element.getJurisdiction().get(i), i); 17242 if (element.hasImmutableElement()) 17243 composeBoolean(t, "ValueSet", "immutable", element.getImmutableElement(), -1); 17244 if (element.hasPurposeElement()) 17245 composeMarkdown(t, "ValueSet", "purpose", element.getPurposeElement(), -1); 17246 if (element.hasCopyrightElement()) 17247 composeMarkdown(t, "ValueSet", "copyright", element.getCopyrightElement(), -1); 17248 if (element.hasCompose()) 17249 composeValueSetValueSetComposeComponent(t, "ValueSet", "compose", element.getCompose(), -1); 17250 if (element.hasExpansion()) 17251 composeValueSetValueSetExpansionComponent(t, "ValueSet", "expansion", element.getExpansion(), -1); 17252 } 17253 17254 protected void composeValueSetValueSetComposeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetComposeComponent element, int index) { 17255 if (element == null) 17256 return; 17257 Complex t; 17258 if (Utilities.noString(parentType)) 17259 t = parent; 17260 else { 17261 t = parent.predicate("fhir:"+parentType+'.'+name); 17262 } 17263 composeBackboneElement(t, "compose", name, element, index); 17264 if (element.hasLockedDateElement()) 17265 composeDate(t, "ValueSet", "lockedDate", element.getLockedDateElement(), -1); 17266 if (element.hasInactiveElement()) 17267 composeBoolean(t, "ValueSet", "inactive", element.getInactiveElement(), -1); 17268 for (int i = 0; i < element.getInclude().size(); i++) 17269 composeValueSetConceptSetComponent(t, "ValueSet", "include", element.getInclude().get(i), i); 17270 for (int i = 0; i < element.getExclude().size(); i++) 17271 composeValueSetConceptSetComponent(t, "ValueSet", "exclude", element.getExclude().get(i), i); 17272 } 17273 17274 protected void composeValueSetConceptSetComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetComponent element, int index) { 17275 if (element == null) 17276 return; 17277 Complex t; 17278 if (Utilities.noString(parentType)) 17279 t = parent; 17280 else { 17281 t = parent.predicate("fhir:"+parentType+'.'+name); 17282 } 17283 composeBackboneElement(t, "include", name, element, index); 17284 if (element.hasSystemElement()) 17285 composeUri(t, "ValueSet", "system", element.getSystemElement(), -1); 17286 if (element.hasVersionElement()) 17287 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 17288 for (int i = 0; i < element.getConcept().size(); i++) 17289 composeValueSetConceptReferenceComponent(t, "ValueSet", "concept", element.getConcept().get(i), i); 17290 for (int i = 0; i < element.getFilter().size(); i++) 17291 composeValueSetConceptSetFilterComponent(t, "ValueSet", "filter", element.getFilter().get(i), i); 17292 for (int i = 0; i < element.getValueSet().size(); i++) 17293 composeCanonical(t, "ValueSet", "valueSet", element.getValueSet().get(i), i); 17294 } 17295 17296 protected void composeValueSetConceptReferenceComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceComponent element, int index) { 17297 if (element == null) 17298 return; 17299 Complex t; 17300 if (Utilities.noString(parentType)) 17301 t = parent; 17302 else { 17303 t = parent.predicate("fhir:"+parentType+'.'+name); 17304 } 17305 composeBackboneElement(t, "concept", name, element, index); 17306 if (element.hasCodeElement()) 17307 composeCode(t, "ValueSet", "code", element.getCodeElement(), -1); 17308 if (element.hasDisplayElement()) 17309 composeString(t, "ValueSet", "display", element.getDisplayElement(), -1); 17310 for (int i = 0; i < element.getDesignation().size(); i++) 17311 composeValueSetConceptReferenceDesignationComponent(t, "ValueSet", "designation", element.getDesignation().get(i), i); 17312 } 17313 17314 protected void composeValueSetConceptReferenceDesignationComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceDesignationComponent element, int index) { 17315 if (element == null) 17316 return; 17317 Complex t; 17318 if (Utilities.noString(parentType)) 17319 t = parent; 17320 else { 17321 t = parent.predicate("fhir:"+parentType+'.'+name); 17322 } 17323 composeBackboneElement(t, "designation", name, element, index); 17324 if (element.hasLanguageElement()) 17325 composeCode(t, "ValueSet", "language", element.getLanguageElement(), -1); 17326 if (element.hasUse()) 17327 composeCoding(t, "ValueSet", "use", element.getUse(), -1); 17328 if (element.hasValueElement()) 17329 composeString(t, "ValueSet", "value", element.getValueElement(), -1); 17330 } 17331 17332 protected void composeValueSetConceptSetFilterComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetFilterComponent element, int index) { 17333 if (element == null) 17334 return; 17335 Complex t; 17336 if (Utilities.noString(parentType)) 17337 t = parent; 17338 else { 17339 t = parent.predicate("fhir:"+parentType+'.'+name); 17340 } 17341 composeBackboneElement(t, "filter", name, element, index); 17342 if (element.hasPropertyElement()) 17343 composeCode(t, "ValueSet", "property", element.getPropertyElement(), -1); 17344 if (element.hasOpElement()) 17345 composeEnum(t, "ValueSet", "op", element.getOpElement(), -1); 17346 if (element.hasValueElement()) 17347 composeString(t, "ValueSet", "value", element.getValueElement(), -1); 17348 } 17349 17350 protected void composeValueSetValueSetExpansionComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionComponent element, int index) { 17351 if (element == null) 17352 return; 17353 Complex t; 17354 if (Utilities.noString(parentType)) 17355 t = parent; 17356 else { 17357 t = parent.predicate("fhir:"+parentType+'.'+name); 17358 } 17359 composeBackboneElement(t, "expansion", name, element, index); 17360 if (element.hasIdentifierElement()) 17361 composeUri(t, "ValueSet", "identifier", element.getIdentifierElement(), -1); 17362 if (element.hasTimestampElement()) 17363 composeDateTime(t, "ValueSet", "timestamp", element.getTimestampElement(), -1); 17364 if (element.hasTotalElement()) 17365 composeInteger(t, "ValueSet", "total", element.getTotalElement(), -1); 17366 if (element.hasOffsetElement()) 17367 composeInteger(t, "ValueSet", "offset", element.getOffsetElement(), -1); 17368 for (int i = 0; i < element.getParameter().size(); i++) 17369 composeValueSetValueSetExpansionParameterComponent(t, "ValueSet", "parameter", element.getParameter().get(i), i); 17370 for (int i = 0; i < element.getContains().size(); i++) 17371 composeValueSetValueSetExpansionContainsComponent(t, "ValueSet", "contains", element.getContains().get(i), i); 17372 } 17373 17374 protected void composeValueSetValueSetExpansionParameterComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionParameterComponent element, int index) { 17375 if (element == null) 17376 return; 17377 Complex t; 17378 if (Utilities.noString(parentType)) 17379 t = parent; 17380 else { 17381 t = parent.predicate("fhir:"+parentType+'.'+name); 17382 } 17383 composeBackboneElement(t, "parameter", name, element, index); 17384 if (element.hasNameElement()) 17385 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 17386 if (element.hasValue()) 17387 composeType(t, "ValueSet", "value", element.getValue(), -1); 17388 } 17389 17390 protected void composeValueSetValueSetExpansionContainsComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionContainsComponent element, int index) { 17391 if (element == null) 17392 return; 17393 Complex t; 17394 if (Utilities.noString(parentType)) 17395 t = parent; 17396 else { 17397 t = parent.predicate("fhir:"+parentType+'.'+name); 17398 } 17399 composeBackboneElement(t, "contains", name, element, index); 17400 if (element.hasSystemElement()) 17401 composeUri(t, "ValueSet", "system", element.getSystemElement(), -1); 17402 if (element.hasAbstractElement()) 17403 composeBoolean(t, "ValueSet", "abstract", element.getAbstractElement(), -1); 17404 if (element.hasInactiveElement()) 17405 composeBoolean(t, "ValueSet", "inactive", element.getInactiveElement(), -1); 17406 if (element.hasVersionElement()) 17407 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 17408 if (element.hasCodeElement()) 17409 composeCode(t, "ValueSet", "code", element.getCodeElement(), -1); 17410 if (element.hasDisplayElement()) 17411 composeString(t, "ValueSet", "display", element.getDisplayElement(), -1); 17412 for (int i = 0; i < element.getDesignation().size(); i++) 17413 composeValueSetConceptReferenceDesignationComponent(t, "ValueSet", "designation", element.getDesignation().get(i), i); 17414 for (int i = 0; i < element.getContains().size(); i++) 17415 composeValueSetValueSetExpansionContainsComponent(t, "ValueSet", "contains", element.getContains().get(i), i); 17416 } 17417 17418 protected void composeVerificationResult(Complex parent, String parentType, String name, VerificationResult element, int index) { 17419 if (element == null) 17420 return; 17421 Complex t; 17422 if (Utilities.noString(parentType)) 17423 t = parent; 17424 else { 17425 t = parent.predicate("fhir:"+parentType+'.'+name); 17426 } 17427 composeDomainResource(t, "VerificationResult", name, element, index); 17428 for (int i = 0; i < element.getTarget().size(); i++) 17429 composeReference(t, "VerificationResult", "target", element.getTarget().get(i), i); 17430 for (int i = 0; i < element.getTargetLocation().size(); i++) 17431 composeString(t, "VerificationResult", "targetLocation", element.getTargetLocation().get(i), i); 17432 if (element.hasNeed()) 17433 composeCodeableConcept(t, "VerificationResult", "need", element.getNeed(), -1); 17434 if (element.hasStatusElement()) 17435 composeEnum(t, "VerificationResult", "status", element.getStatusElement(), -1); 17436 if (element.hasStatusDateElement()) 17437 composeDateTime(t, "VerificationResult", "statusDate", element.getStatusDateElement(), -1); 17438 if (element.hasValidationType()) 17439 composeCodeableConcept(t, "VerificationResult", "validationType", element.getValidationType(), -1); 17440 for (int i = 0; i < element.getValidationProcess().size(); i++) 17441 composeCodeableConcept(t, "VerificationResult", "validationProcess", element.getValidationProcess().get(i), i); 17442 if (element.hasFrequency()) 17443 composeTiming(t, "VerificationResult", "frequency", element.getFrequency(), -1); 17444 if (element.hasLastPerformedElement()) 17445 composeDateTime(t, "VerificationResult", "lastPerformed", element.getLastPerformedElement(), -1); 17446 if (element.hasNextScheduledElement()) 17447 composeDate(t, "VerificationResult", "nextScheduled", element.getNextScheduledElement(), -1); 17448 if (element.hasFailureAction()) 17449 composeCodeableConcept(t, "VerificationResult", "failureAction", element.getFailureAction(), -1); 17450 for (int i = 0; i < element.getPrimarySource().size(); i++) 17451 composeVerificationResultVerificationResultPrimarySourceComponent(t, "VerificationResult", "primarySource", element.getPrimarySource().get(i), i); 17452 if (element.hasAttestation()) 17453 composeVerificationResultVerificationResultAttestationComponent(t, "VerificationResult", "attestation", element.getAttestation(), -1); 17454 for (int i = 0; i < element.getValidator().size(); i++) 17455 composeVerificationResultVerificationResultValidatorComponent(t, "VerificationResult", "validator", element.getValidator().get(i), i); 17456 } 17457 17458 protected void composeVerificationResultVerificationResultPrimarySourceComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultPrimarySourceComponent element, int index) { 17459 if (element == null) 17460 return; 17461 Complex t; 17462 if (Utilities.noString(parentType)) 17463 t = parent; 17464 else { 17465 t = parent.predicate("fhir:"+parentType+'.'+name); 17466 } 17467 composeBackboneElement(t, "primarySource", name, element, index); 17468 if (element.hasWho()) 17469 composeReference(t, "VerificationResult", "who", element.getWho(), -1); 17470 for (int i = 0; i < element.getType().size(); i++) 17471 composeCodeableConcept(t, "VerificationResult", "type", element.getType().get(i), i); 17472 for (int i = 0; i < element.getCommunicationMethod().size(); i++) 17473 composeCodeableConcept(t, "VerificationResult", "communicationMethod", element.getCommunicationMethod().get(i), i); 17474 if (element.hasValidationStatus()) 17475 composeCodeableConcept(t, "VerificationResult", "validationStatus", element.getValidationStatus(), -1); 17476 if (element.hasValidationDateElement()) 17477 composeDateTime(t, "VerificationResult", "validationDate", element.getValidationDateElement(), -1); 17478 if (element.hasCanPushUpdates()) 17479 composeCodeableConcept(t, "VerificationResult", "canPushUpdates", element.getCanPushUpdates(), -1); 17480 for (int i = 0; i < element.getPushTypeAvailable().size(); i++) 17481 composeCodeableConcept(t, "VerificationResult", "pushTypeAvailable", element.getPushTypeAvailable().get(i), i); 17482 } 17483 17484 protected void composeVerificationResultVerificationResultAttestationComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultAttestationComponent element, int index) { 17485 if (element == null) 17486 return; 17487 Complex t; 17488 if (Utilities.noString(parentType)) 17489 t = parent; 17490 else { 17491 t = parent.predicate("fhir:"+parentType+'.'+name); 17492 } 17493 composeBackboneElement(t, "attestation", name, element, index); 17494 if (element.hasWho()) 17495 composeReference(t, "VerificationResult", "who", element.getWho(), -1); 17496 if (element.hasOnBehalfOf()) 17497 composeReference(t, "VerificationResult", "onBehalfOf", element.getOnBehalfOf(), -1); 17498 if (element.hasCommunicationMethod()) 17499 composeCodeableConcept(t, "VerificationResult", "communicationMethod", element.getCommunicationMethod(), -1); 17500 if (element.hasDateElement()) 17501 composeDate(t, "VerificationResult", "date", element.getDateElement(), -1); 17502 if (element.hasSourceIdentityCertificateElement()) 17503 composeString(t, "VerificationResult", "sourceIdentityCertificate", element.getSourceIdentityCertificateElement(), -1); 17504 if (element.hasProxyIdentityCertificateElement()) 17505 composeString(t, "VerificationResult", "proxyIdentityCertificate", element.getProxyIdentityCertificateElement(), -1); 17506 if (element.hasProxySignature()) 17507 composeSignature(t, "VerificationResult", "proxySignature", element.getProxySignature(), -1); 17508 if (element.hasSourceSignature()) 17509 composeSignature(t, "VerificationResult", "sourceSignature", element.getSourceSignature(), -1); 17510 } 17511 17512 protected void composeVerificationResultVerificationResultValidatorComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultValidatorComponent element, int index) { 17513 if (element == null) 17514 return; 17515 Complex t; 17516 if (Utilities.noString(parentType)) 17517 t = parent; 17518 else { 17519 t = parent.predicate("fhir:"+parentType+'.'+name); 17520 } 17521 composeBackboneElement(t, "validator", name, element, index); 17522 if (element.hasOrganization()) 17523 composeReference(t, "VerificationResult", "organization", element.getOrganization(), -1); 17524 if (element.hasIdentityCertificateElement()) 17525 composeString(t, "VerificationResult", "identityCertificate", element.getIdentityCertificateElement(), -1); 17526 if (element.hasAttestationSignature()) 17527 composeSignature(t, "VerificationResult", "attestationSignature", element.getAttestationSignature(), -1); 17528 } 17529 17530 protected void composeVisionPrescription(Complex parent, String parentType, String name, VisionPrescription element, int index) { 17531 if (element == null) 17532 return; 17533 Complex t; 17534 if (Utilities.noString(parentType)) 17535 t = parent; 17536 else { 17537 t = parent.predicate("fhir:"+parentType+'.'+name); 17538 } 17539 composeDomainResource(t, "VisionPrescription", name, element, index); 17540 for (int i = 0; i < element.getIdentifier().size(); i++) 17541 composeIdentifier(t, "VisionPrescription", "identifier", element.getIdentifier().get(i), i); 17542 if (element.hasStatusElement()) 17543 composeEnum(t, "VisionPrescription", "status", element.getStatusElement(), -1); 17544 if (element.hasCreatedElement()) 17545 composeDateTime(t, "VisionPrescription", "created", element.getCreatedElement(), -1); 17546 if (element.hasPatient()) 17547 composeReference(t, "VisionPrescription", "patient", element.getPatient(), -1); 17548 if (element.hasEncounter()) 17549 composeReference(t, "VisionPrescription", "encounter", element.getEncounter(), -1); 17550 if (element.hasDateWrittenElement()) 17551 composeDateTime(t, "VisionPrescription", "dateWritten", element.getDateWrittenElement(), -1); 17552 if (element.hasPrescriber()) 17553 composeReference(t, "VisionPrescription", "prescriber", element.getPrescriber(), -1); 17554 for (int i = 0; i < element.getLensSpecification().size(); i++) 17555 composeVisionPrescriptionVisionPrescriptionLensSpecificationComponent(t, "VisionPrescription", "lensSpecification", element.getLensSpecification().get(i), i); 17556 } 17557 17558 protected void composeVisionPrescriptionVisionPrescriptionLensSpecificationComponent(Complex parent, String parentType, String name, VisionPrescription.VisionPrescriptionLensSpecificationComponent element, int index) { 17559 if (element == null) 17560 return; 17561 Complex t; 17562 if (Utilities.noString(parentType)) 17563 t = parent; 17564 else { 17565 t = parent.predicate("fhir:"+parentType+'.'+name); 17566 } 17567 composeBackboneElement(t, "lensSpecification", name, element, index); 17568 if (element.hasProduct()) 17569 composeCodeableConcept(t, "VisionPrescription", "product", element.getProduct(), -1); 17570 if (element.hasEyeElement()) 17571 composeEnum(t, "VisionPrescription", "eye", element.getEyeElement(), -1); 17572 if (element.hasSphereElement()) 17573 composeDecimal(t, "VisionPrescription", "sphere", element.getSphereElement(), -1); 17574 if (element.hasCylinderElement()) 17575 composeDecimal(t, "VisionPrescription", "cylinder", element.getCylinderElement(), -1); 17576 if (element.hasAxisElement()) 17577 composeInteger(t, "VisionPrescription", "axis", element.getAxisElement(), -1); 17578 for (int i = 0; i < element.getPrism().size(); i++) 17579 composeVisionPrescriptionPrismComponent(t, "VisionPrescription", "prism", element.getPrism().get(i), i); 17580 if (element.hasAddElement()) 17581 composeDecimal(t, "VisionPrescription", "add", element.getAddElement(), -1); 17582 if (element.hasPowerElement()) 17583 composeDecimal(t, "VisionPrescription", "power", element.getPowerElement(), -1); 17584 if (element.hasBackCurveElement()) 17585 composeDecimal(t, "VisionPrescription", "backCurve", element.getBackCurveElement(), -1); 17586 if (element.hasDiameterElement()) 17587 composeDecimal(t, "VisionPrescription", "diameter", element.getDiameterElement(), -1); 17588 if (element.hasDuration()) 17589 composeQuantity(t, "VisionPrescription", "duration", element.getDuration(), -1); 17590 if (element.hasColorElement()) 17591 composeString(t, "VisionPrescription", "color", element.getColorElement(), -1); 17592 if (element.hasBrandElement()) 17593 composeString(t, "VisionPrescription", "brand", element.getBrandElement(), -1); 17594 for (int i = 0; i < element.getNote().size(); i++) 17595 composeAnnotation(t, "VisionPrescription", "note", element.getNote().get(i), i); 17596 } 17597 17598 protected void composeVisionPrescriptionPrismComponent(Complex parent, String parentType, String name, VisionPrescription.PrismComponent element, int index) { 17599 if (element == null) 17600 return; 17601 Complex t; 17602 if (Utilities.noString(parentType)) 17603 t = parent; 17604 else { 17605 t = parent.predicate("fhir:"+parentType+'.'+name); 17606 } 17607 composeBackboneElement(t, "prism", name, element, index); 17608 if (element.hasAmountElement()) 17609 composeDecimal(t, "VisionPrescription", "amount", element.getAmountElement(), -1); 17610 if (element.hasBaseElement()) 17611 composeEnum(t, "VisionPrescription", "base", element.getBaseElement(), -1); 17612 } 17613 17614 @Override 17615 protected void composeResource(Complex parent, Resource resource) { 17616 if (resource instanceof Parameters) 17617 composeParameters(parent, null, "Parameters", (Parameters)resource, -1); 17618 else if (resource instanceof Account) 17619 composeAccount(parent, null, "Account", (Account)resource, -1); 17620 else if (resource instanceof ActivityDefinition) 17621 composeActivityDefinition(parent, null, "ActivityDefinition", (ActivityDefinition)resource, -1); 17622 else if (resource instanceof AdverseEvent) 17623 composeAdverseEvent(parent, null, "AdverseEvent", (AdverseEvent)resource, -1); 17624 else if (resource instanceof AllergyIntolerance) 17625 composeAllergyIntolerance(parent, null, "AllergyIntolerance", (AllergyIntolerance)resource, -1); 17626 else if (resource instanceof Appointment) 17627 composeAppointment(parent, null, "Appointment", (Appointment)resource, -1); 17628 else if (resource instanceof AppointmentResponse) 17629 composeAppointmentResponse(parent, null, "AppointmentResponse", (AppointmentResponse)resource, -1); 17630 else if (resource instanceof AuditEvent) 17631 composeAuditEvent(parent, null, "AuditEvent", (AuditEvent)resource, -1); 17632 else if (resource instanceof Basic) 17633 composeBasic(parent, null, "Basic", (Basic)resource, -1); 17634 else if (resource instanceof Binary) 17635 composeBinary(parent, null, "Binary", (Binary)resource, -1); 17636 else if (resource instanceof BiologicallyDerivedProduct) 17637 composeBiologicallyDerivedProduct(parent, null, "BiologicallyDerivedProduct", (BiologicallyDerivedProduct)resource, -1); 17638 else if (resource instanceof BodyStructure) 17639 composeBodyStructure(parent, null, "BodyStructure", (BodyStructure)resource, -1); 17640 else if (resource instanceof Bundle) 17641 composeBundle(parent, null, "Bundle", (Bundle)resource, -1); 17642 else if (resource instanceof CapabilityStatement) 17643 composeCapabilityStatement(parent, null, "CapabilityStatement", (CapabilityStatement)resource, -1); 17644 else if (resource instanceof CarePlan) 17645 composeCarePlan(parent, null, "CarePlan", (CarePlan)resource, -1); 17646 else if (resource instanceof CareTeam) 17647 composeCareTeam(parent, null, "CareTeam", (CareTeam)resource, -1); 17648 else if (resource instanceof CatalogEntry) 17649 composeCatalogEntry(parent, null, "CatalogEntry", (CatalogEntry)resource, -1); 17650 else if (resource instanceof ChargeItem) 17651 composeChargeItem(parent, null, "ChargeItem", (ChargeItem)resource, -1); 17652 else if (resource instanceof ChargeItemDefinition) 17653 composeChargeItemDefinition(parent, null, "ChargeItemDefinition", (ChargeItemDefinition)resource, -1); 17654 else if (resource instanceof Claim) 17655 composeClaim(parent, null, "Claim", (Claim)resource, -1); 17656 else if (resource instanceof ClaimResponse) 17657 composeClaimResponse(parent, null, "ClaimResponse", (ClaimResponse)resource, -1); 17658 else if (resource instanceof ClinicalImpression) 17659 composeClinicalImpression(parent, null, "ClinicalImpression", (ClinicalImpression)resource, -1); 17660 else if (resource instanceof CodeSystem) 17661 composeCodeSystem(parent, null, "CodeSystem", (CodeSystem)resource, -1); 17662 else if (resource instanceof Communication) 17663 composeCommunication(parent, null, "Communication", (Communication)resource, -1); 17664 else if (resource instanceof CommunicationRequest) 17665 composeCommunicationRequest(parent, null, "CommunicationRequest", (CommunicationRequest)resource, -1); 17666 else if (resource instanceof CompartmentDefinition) 17667 composeCompartmentDefinition(parent, null, "CompartmentDefinition", (CompartmentDefinition)resource, -1); 17668 else if (resource instanceof Composition) 17669 composeComposition(parent, null, "Composition", (Composition)resource, -1); 17670 else if (resource instanceof ConceptMap) 17671 composeConceptMap(parent, null, "ConceptMap", (ConceptMap)resource, -1); 17672 else if (resource instanceof Condition) 17673 composeCondition(parent, null, "Condition", (Condition)resource, -1); 17674 else if (resource instanceof Consent) 17675 composeConsent(parent, null, "Consent", (Consent)resource, -1); 17676 else if (resource instanceof Contract) 17677 composeContract(parent, null, "Contract", (Contract)resource, -1); 17678 else if (resource instanceof Coverage) 17679 composeCoverage(parent, null, "Coverage", (Coverage)resource, -1); 17680 else if (resource instanceof CoverageEligibilityRequest) 17681 composeCoverageEligibilityRequest(parent, null, "CoverageEligibilityRequest", (CoverageEligibilityRequest)resource, -1); 17682 else if (resource instanceof CoverageEligibilityResponse) 17683 composeCoverageEligibilityResponse(parent, null, "CoverageEligibilityResponse", (CoverageEligibilityResponse)resource, -1); 17684 else if (resource instanceof DetectedIssue) 17685 composeDetectedIssue(parent, null, "DetectedIssue", (DetectedIssue)resource, -1); 17686 else if (resource instanceof Device) 17687 composeDevice(parent, null, "Device", (Device)resource, -1); 17688 else if (resource instanceof DeviceDefinition) 17689 composeDeviceDefinition(parent, null, "DeviceDefinition", (DeviceDefinition)resource, -1); 17690 else if (resource instanceof DeviceMetric) 17691 composeDeviceMetric(parent, null, "DeviceMetric", (DeviceMetric)resource, -1); 17692 else if (resource instanceof DeviceRequest) 17693 composeDeviceRequest(parent, null, "DeviceRequest", (DeviceRequest)resource, -1); 17694 else if (resource instanceof DeviceUseStatement) 17695 composeDeviceUseStatement(parent, null, "DeviceUseStatement", (DeviceUseStatement)resource, -1); 17696 else if (resource instanceof DiagnosticReport) 17697 composeDiagnosticReport(parent, null, "DiagnosticReport", (DiagnosticReport)resource, -1); 17698 else if (resource instanceof DocumentManifest) 17699 composeDocumentManifest(parent, null, "DocumentManifest", (DocumentManifest)resource, -1); 17700 else if (resource instanceof DocumentReference) 17701 composeDocumentReference(parent, null, "DocumentReference", (DocumentReference)resource, -1); 17702 else if (resource instanceof EffectEvidenceSynthesis) 17703 composeEffectEvidenceSynthesis(parent, null, "EffectEvidenceSynthesis", (EffectEvidenceSynthesis)resource, -1); 17704 else if (resource instanceof Encounter) 17705 composeEncounter(parent, null, "Encounter", (Encounter)resource, -1); 17706 else if (resource instanceof Endpoint) 17707 composeEndpoint(parent, null, "Endpoint", (Endpoint)resource, -1); 17708 else if (resource instanceof EnrollmentRequest) 17709 composeEnrollmentRequest(parent, null, "EnrollmentRequest", (EnrollmentRequest)resource, -1); 17710 else if (resource instanceof EnrollmentResponse) 17711 composeEnrollmentResponse(parent, null, "EnrollmentResponse", (EnrollmentResponse)resource, -1); 17712 else if (resource instanceof EpisodeOfCare) 17713 composeEpisodeOfCare(parent, null, "EpisodeOfCare", (EpisodeOfCare)resource, -1); 17714 else if (resource instanceof EventDefinition) 17715 composeEventDefinition(parent, null, "EventDefinition", (EventDefinition)resource, -1); 17716 else if (resource instanceof Evidence) 17717 composeEvidence(parent, null, "Evidence", (Evidence)resource, -1); 17718 else if (resource instanceof EvidenceVariable) 17719 composeEvidenceVariable(parent, null, "EvidenceVariable", (EvidenceVariable)resource, -1); 17720 else if (resource instanceof ExampleScenario) 17721 composeExampleScenario(parent, null, "ExampleScenario", (ExampleScenario)resource, -1); 17722 else if (resource instanceof ExplanationOfBenefit) 17723 composeExplanationOfBenefit(parent, null, "ExplanationOfBenefit", (ExplanationOfBenefit)resource, -1); 17724 else if (resource instanceof FamilyMemberHistory) 17725 composeFamilyMemberHistory(parent, null, "FamilyMemberHistory", (FamilyMemberHistory)resource, -1); 17726 else if (resource instanceof Flag) 17727 composeFlag(parent, null, "Flag", (Flag)resource, -1); 17728 else if (resource instanceof Goal) 17729 composeGoal(parent, null, "Goal", (Goal)resource, -1); 17730 else if (resource instanceof GraphDefinition) 17731 composeGraphDefinition(parent, null, "GraphDefinition", (GraphDefinition)resource, -1); 17732 else if (resource instanceof Group) 17733 composeGroup(parent, null, "Group", (Group)resource, -1); 17734 else if (resource instanceof GuidanceResponse) 17735 composeGuidanceResponse(parent, null, "GuidanceResponse", (GuidanceResponse)resource, -1); 17736 else if (resource instanceof HealthcareService) 17737 composeHealthcareService(parent, null, "HealthcareService", (HealthcareService)resource, -1); 17738 else if (resource instanceof ImagingStudy) 17739 composeImagingStudy(parent, null, "ImagingStudy", (ImagingStudy)resource, -1); 17740 else if (resource instanceof Immunization) 17741 composeImmunization(parent, null, "Immunization", (Immunization)resource, -1); 17742 else if (resource instanceof ImmunizationEvaluation) 17743 composeImmunizationEvaluation(parent, null, "ImmunizationEvaluation", (ImmunizationEvaluation)resource, -1); 17744 else if (resource instanceof ImmunizationRecommendation) 17745 composeImmunizationRecommendation(parent, null, "ImmunizationRecommendation", (ImmunizationRecommendation)resource, -1); 17746 else if (resource instanceof ImplementationGuide) 17747 composeImplementationGuide(parent, null, "ImplementationGuide", (ImplementationGuide)resource, -1); 17748 else if (resource instanceof InsurancePlan) 17749 composeInsurancePlan(parent, null, "InsurancePlan", (InsurancePlan)resource, -1); 17750 else if (resource instanceof Invoice) 17751 composeInvoice(parent, null, "Invoice", (Invoice)resource, -1); 17752 else if (resource instanceof Library) 17753 composeLibrary(parent, null, "Library", (Library)resource, -1); 17754 else if (resource instanceof Linkage) 17755 composeLinkage(parent, null, "Linkage", (Linkage)resource, -1); 17756 else if (resource instanceof ListResource) 17757 composeListResource(parent, null, "ListResource", (ListResource)resource, -1); 17758 else if (resource instanceof Location) 17759 composeLocation(parent, null, "Location", (Location)resource, -1); 17760 else if (resource instanceof Measure) 17761 composeMeasure(parent, null, "Measure", (Measure)resource, -1); 17762 else if (resource instanceof MeasureReport) 17763 composeMeasureReport(parent, null, "MeasureReport", (MeasureReport)resource, -1); 17764 else if (resource instanceof Media) 17765 composeMedia(parent, null, "Media", (Media)resource, -1); 17766 else if (resource instanceof Medication) 17767 composeMedication(parent, null, "Medication", (Medication)resource, -1); 17768 else if (resource instanceof MedicationAdministration) 17769 composeMedicationAdministration(parent, null, "MedicationAdministration", (MedicationAdministration)resource, -1); 17770 else if (resource instanceof MedicationDispense) 17771 composeMedicationDispense(parent, null, "MedicationDispense", (MedicationDispense)resource, -1); 17772 else if (resource instanceof MedicationKnowledge) 17773 composeMedicationKnowledge(parent, null, "MedicationKnowledge", (MedicationKnowledge)resource, -1); 17774 else if (resource instanceof MedicationRequest) 17775 composeMedicationRequest(parent, null, "MedicationRequest", (MedicationRequest)resource, -1); 17776 else if (resource instanceof MedicationStatement) 17777 composeMedicationStatement(parent, null, "MedicationStatement", (MedicationStatement)resource, -1); 17778 else if (resource instanceof MedicinalProduct) 17779 composeMedicinalProduct(parent, null, "MedicinalProduct", (MedicinalProduct)resource, -1); 17780 else if (resource instanceof MedicinalProductAuthorization) 17781 composeMedicinalProductAuthorization(parent, null, "MedicinalProductAuthorization", (MedicinalProductAuthorization)resource, -1); 17782 else if (resource instanceof MedicinalProductContraindication) 17783 composeMedicinalProductContraindication(parent, null, "MedicinalProductContraindication", (MedicinalProductContraindication)resource, -1); 17784 else if (resource instanceof MedicinalProductIndication) 17785 composeMedicinalProductIndication(parent, null, "MedicinalProductIndication", (MedicinalProductIndication)resource, -1); 17786 else if (resource instanceof MedicinalProductIngredient) 17787 composeMedicinalProductIngredient(parent, null, "MedicinalProductIngredient", (MedicinalProductIngredient)resource, -1); 17788 else if (resource instanceof MedicinalProductInteraction) 17789 composeMedicinalProductInteraction(parent, null, "MedicinalProductInteraction", (MedicinalProductInteraction)resource, -1); 17790 else if (resource instanceof MedicinalProductManufactured) 17791 composeMedicinalProductManufactured(parent, null, "MedicinalProductManufactured", (MedicinalProductManufactured)resource, -1); 17792 else if (resource instanceof MedicinalProductPackaged) 17793 composeMedicinalProductPackaged(parent, null, "MedicinalProductPackaged", (MedicinalProductPackaged)resource, -1); 17794 else if (resource instanceof MedicinalProductPharmaceutical) 17795 composeMedicinalProductPharmaceutical(parent, null, "MedicinalProductPharmaceutical", (MedicinalProductPharmaceutical)resource, -1); 17796 else if (resource instanceof MedicinalProductUndesirableEffect) 17797 composeMedicinalProductUndesirableEffect(parent, null, "MedicinalProductUndesirableEffect", (MedicinalProductUndesirableEffect)resource, -1); 17798 else if (resource instanceof MessageDefinition) 17799 composeMessageDefinition(parent, null, "MessageDefinition", (MessageDefinition)resource, -1); 17800 else if (resource instanceof MessageHeader) 17801 composeMessageHeader(parent, null, "MessageHeader", (MessageHeader)resource, -1); 17802 else if (resource instanceof MolecularSequence) 17803 composeMolecularSequence(parent, null, "MolecularSequence", (MolecularSequence)resource, -1); 17804 else if (resource instanceof NamingSystem) 17805 composeNamingSystem(parent, null, "NamingSystem", (NamingSystem)resource, -1); 17806 else if (resource instanceof NutritionOrder) 17807 composeNutritionOrder(parent, null, "NutritionOrder", (NutritionOrder)resource, -1); 17808 else if (resource instanceof Observation) 17809 composeObservation(parent, null, "Observation", (Observation)resource, -1); 17810 else if (resource instanceof ObservationDefinition) 17811 composeObservationDefinition(parent, null, "ObservationDefinition", (ObservationDefinition)resource, -1); 17812 else if (resource instanceof OperationDefinition) 17813 composeOperationDefinition(parent, null, "OperationDefinition", (OperationDefinition)resource, -1); 17814 else if (resource instanceof OperationOutcome) 17815 composeOperationOutcome(parent, null, "OperationOutcome", (OperationOutcome)resource, -1); 17816 else if (resource instanceof Organization) 17817 composeOrganization(parent, null, "Organization", (Organization)resource, -1); 17818 else if (resource instanceof OrganizationAffiliation) 17819 composeOrganizationAffiliation(parent, null, "OrganizationAffiliation", (OrganizationAffiliation)resource, -1); 17820 else if (resource instanceof Patient) 17821 composePatient(parent, null, "Patient", (Patient)resource, -1); 17822 else if (resource instanceof PaymentNotice) 17823 composePaymentNotice(parent, null, "PaymentNotice", (PaymentNotice)resource, -1); 17824 else if (resource instanceof PaymentReconciliation) 17825 composePaymentReconciliation(parent, null, "PaymentReconciliation", (PaymentReconciliation)resource, -1); 17826 else if (resource instanceof Person) 17827 composePerson(parent, null, "Person", (Person)resource, -1); 17828 else if (resource instanceof PlanDefinition) 17829 composePlanDefinition(parent, null, "PlanDefinition", (PlanDefinition)resource, -1); 17830 else if (resource instanceof Practitioner) 17831 composePractitioner(parent, null, "Practitioner", (Practitioner)resource, -1); 17832 else if (resource instanceof PractitionerRole) 17833 composePractitionerRole(parent, null, "PractitionerRole", (PractitionerRole)resource, -1); 17834 else if (resource instanceof Procedure) 17835 composeProcedure(parent, null, "Procedure", (Procedure)resource, -1); 17836 else if (resource instanceof Provenance) 17837 composeProvenance(parent, null, "Provenance", (Provenance)resource, -1); 17838 else if (resource instanceof Questionnaire) 17839 composeQuestionnaire(parent, null, "Questionnaire", (Questionnaire)resource, -1); 17840 else if (resource instanceof QuestionnaireResponse) 17841 composeQuestionnaireResponse(parent, null, "QuestionnaireResponse", (QuestionnaireResponse)resource, -1); 17842 else if (resource instanceof RelatedPerson) 17843 composeRelatedPerson(parent, null, "RelatedPerson", (RelatedPerson)resource, -1); 17844 else if (resource instanceof RequestGroup) 17845 composeRequestGroup(parent, null, "RequestGroup", (RequestGroup)resource, -1); 17846 else if (resource instanceof ResearchDefinition) 17847 composeResearchDefinition(parent, null, "ResearchDefinition", (ResearchDefinition)resource, -1); 17848 else if (resource instanceof ResearchElementDefinition) 17849 composeResearchElementDefinition(parent, null, "ResearchElementDefinition", (ResearchElementDefinition)resource, -1); 17850 else if (resource instanceof ResearchStudy) 17851 composeResearchStudy(parent, null, "ResearchStudy", (ResearchStudy)resource, -1); 17852 else if (resource instanceof ResearchSubject) 17853 composeResearchSubject(parent, null, "ResearchSubject", (ResearchSubject)resource, -1); 17854 else if (resource instanceof RiskAssessment) 17855 composeRiskAssessment(parent, null, "RiskAssessment", (RiskAssessment)resource, -1); 17856 else if (resource instanceof RiskEvidenceSynthesis) 17857 composeRiskEvidenceSynthesis(parent, null, "RiskEvidenceSynthesis", (RiskEvidenceSynthesis)resource, -1); 17858 else if (resource instanceof Schedule) 17859 composeSchedule(parent, null, "Schedule", (Schedule)resource, -1); 17860 else if (resource instanceof SearchParameter) 17861 composeSearchParameter(parent, null, "SearchParameter", (SearchParameter)resource, -1); 17862 else if (resource instanceof ServiceRequest) 17863 composeServiceRequest(parent, null, "ServiceRequest", (ServiceRequest)resource, -1); 17864 else if (resource instanceof Slot) 17865 composeSlot(parent, null, "Slot", (Slot)resource, -1); 17866 else if (resource instanceof Specimen) 17867 composeSpecimen(parent, null, "Specimen", (Specimen)resource, -1); 17868 else if (resource instanceof SpecimenDefinition) 17869 composeSpecimenDefinition(parent, null, "SpecimenDefinition", (SpecimenDefinition)resource, -1); 17870 else if (resource instanceof StructureDefinition) 17871 composeStructureDefinition(parent, null, "StructureDefinition", (StructureDefinition)resource, -1); 17872 else if (resource instanceof StructureMap) 17873 composeStructureMap(parent, null, "StructureMap", (StructureMap)resource, -1); 17874 else if (resource instanceof Subscription) 17875 composeSubscription(parent, null, "Subscription", (Subscription)resource, -1); 17876 else if (resource instanceof Substance) 17877 composeSubstance(parent, null, "Substance", (Substance)resource, -1); 17878 else if (resource instanceof SubstanceNucleicAcid) 17879 composeSubstanceNucleicAcid(parent, null, "SubstanceNucleicAcid", (SubstanceNucleicAcid)resource, -1); 17880 else if (resource instanceof SubstancePolymer) 17881 composeSubstancePolymer(parent, null, "SubstancePolymer", (SubstancePolymer)resource, -1); 17882 else if (resource instanceof SubstanceProtein) 17883 composeSubstanceProtein(parent, null, "SubstanceProtein", (SubstanceProtein)resource, -1); 17884 else if (resource instanceof SubstanceReferenceInformation) 17885 composeSubstanceReferenceInformation(parent, null, "SubstanceReferenceInformation", (SubstanceReferenceInformation)resource, -1); 17886 else if (resource instanceof SubstanceSourceMaterial) 17887 composeSubstanceSourceMaterial(parent, null, "SubstanceSourceMaterial", (SubstanceSourceMaterial)resource, -1); 17888 else if (resource instanceof SubstanceSpecification) 17889 composeSubstanceSpecification(parent, null, "SubstanceSpecification", (SubstanceSpecification)resource, -1); 17890 else if (resource instanceof SupplyDelivery) 17891 composeSupplyDelivery(parent, null, "SupplyDelivery", (SupplyDelivery)resource, -1); 17892 else if (resource instanceof SupplyRequest) 17893 composeSupplyRequest(parent, null, "SupplyRequest", (SupplyRequest)resource, -1); 17894 else if (resource instanceof Task) 17895 composeTask(parent, null, "Task", (Task)resource, -1); 17896 else if (resource instanceof TerminologyCapabilities) 17897 composeTerminologyCapabilities(parent, null, "TerminologyCapabilities", (TerminologyCapabilities)resource, -1); 17898 else if (resource instanceof TestReport) 17899 composeTestReport(parent, null, "TestReport", (TestReport)resource, -1); 17900 else if (resource instanceof TestScript) 17901 composeTestScript(parent, null, "TestScript", (TestScript)resource, -1); 17902 else if (resource instanceof ValueSet) 17903 composeValueSet(parent, null, "ValueSet", (ValueSet)resource, -1); 17904 else if (resource instanceof VerificationResult) 17905 composeVerificationResult(parent, null, "VerificationResult", (VerificationResult)resource, -1); 17906 else if (resource instanceof VisionPrescription) 17907 composeVisionPrescription(parent, null, "VisionPrescription", (VisionPrescription)resource, -1); 17908 else 17909 throw new Error("Unhandled resource type "+resource.getClass().getName()); 17910 } 17911 17912 protected void composeType(Complex parent, String parentType, String name, Type value, int index) { 17913 if (value == null) 17914 return; 17915 else if (value instanceof DateType) 17916 composeDate(parent, parentType, name, (DateType)value, index); 17917 else if (value instanceof DateTimeType) 17918 composeDateTime(parent, parentType, name, (DateTimeType)value, index); 17919 else if (value instanceof CodeType) 17920 composeCode(parent, parentType, name, (CodeType)value, index); 17921 else if (value instanceof StringType) 17922 composeString(parent, parentType, name, (StringType)value, index); 17923 else if (value instanceof IntegerType) 17924 composeInteger(parent, parentType, name, (IntegerType)value, index); 17925 else if (value instanceof OidType) 17926 composeOid(parent, parentType, name, (OidType)value, index); 17927 else if (value instanceof CanonicalType) 17928 composeCanonical(parent, parentType, name, (CanonicalType)value, index); 17929 else if (value instanceof UriType) 17930 composeUri(parent, parentType, name, (UriType)value, index); 17931 else if (value instanceof UuidType) 17932 composeUuid(parent, parentType, name, (UuidType)value, index); 17933 else if (value instanceof UrlType) 17934 composeUrl(parent, parentType, name, (UrlType)value, index); 17935 else if (value instanceof InstantType) 17936 composeInstant(parent, parentType, name, (InstantType)value, index); 17937 else if (value instanceof BooleanType) 17938 composeBoolean(parent, parentType, name, (BooleanType)value, index); 17939 else if (value instanceof Base64BinaryType) 17940 composeBase64Binary(parent, parentType, name, (Base64BinaryType)value, index); 17941 else if (value instanceof UnsignedIntType) 17942 composeUnsignedInt(parent, parentType, name, (UnsignedIntType)value, index); 17943 else if (value instanceof MarkdownType) 17944 composeMarkdown(parent, parentType, name, (MarkdownType)value, index); 17945 else if (value instanceof TimeType) 17946 composeTime(parent, parentType, name, (TimeType)value, index); 17947 else if (value instanceof IdType) 17948 composeId(parent, parentType, name, (IdType)value, index); 17949 else if (value instanceof PositiveIntType) 17950 composePositiveInt(parent, parentType, name, (PositiveIntType)value, index); 17951 else if (value instanceof DecimalType) 17952 composeDecimal(parent, parentType, name, (DecimalType)value, index); 17953 else if (value instanceof Extension) 17954 composeExtension(parent, parentType, name, (Extension)value, index); 17955 else if (value instanceof Narrative) 17956 composeNarrative(parent, parentType, name, (Narrative)value, index); 17957 else if (value instanceof Meta) 17958 composeMeta(parent, parentType, name, (Meta)value, index); 17959 else if (value instanceof Address) 17960 composeAddress(parent, parentType, name, (Address)value, index); 17961 else if (value instanceof Contributor) 17962 composeContributor(parent, parentType, name, (Contributor)value, index); 17963 else if (value instanceof Attachment) 17964 composeAttachment(parent, parentType, name, (Attachment)value, index); 17965 else if (value instanceof Count) 17966 composeCount(parent, parentType, name, (Count)value, index); 17967 else if (value instanceof DataRequirement) 17968 composeDataRequirement(parent, parentType, name, (DataRequirement)value, index); 17969 else if (value instanceof Dosage) 17970 composeDosage(parent, parentType, name, (Dosage)value, index); 17971 else if (value instanceof Money) 17972 composeMoney(parent, parentType, name, (Money)value, index); 17973 else if (value instanceof HumanName) 17974 composeHumanName(parent, parentType, name, (HumanName)value, index); 17975 else if (value instanceof ContactPoint) 17976 composeContactPoint(parent, parentType, name, (ContactPoint)value, index); 17977 else if (value instanceof MarketingStatus) 17978 composeMarketingStatus(parent, parentType, name, (MarketingStatus)value, index); 17979 else if (value instanceof Identifier) 17980 composeIdentifier(parent, parentType, name, (Identifier)value, index); 17981 else if (value instanceof SubstanceAmount) 17982 composeSubstanceAmount(parent, parentType, name, (SubstanceAmount)value, index); 17983 else if (value instanceof Coding) 17984 composeCoding(parent, parentType, name, (Coding)value, index); 17985 else if (value instanceof SampledData) 17986 composeSampledData(parent, parentType, name, (SampledData)value, index); 17987 else if (value instanceof Population) 17988 composePopulation(parent, parentType, name, (Population)value, index); 17989 else if (value instanceof Ratio) 17990 composeRatio(parent, parentType, name, (Ratio)value, index); 17991 else if (value instanceof Distance) 17992 composeDistance(parent, parentType, name, (Distance)value, index); 17993 else if (value instanceof Age) 17994 composeAge(parent, parentType, name, (Age)value, index); 17995 else if (value instanceof Reference) 17996 composeReference(parent, parentType, name, (Reference)value, index); 17997 else if (value instanceof TriggerDefinition) 17998 composeTriggerDefinition(parent, parentType, name, (TriggerDefinition)value, index); 17999 else if (value instanceof Quantity) 18000 composeQuantity(parent, parentType, name, (Quantity)value, index); 18001 else if (value instanceof Period) 18002 composePeriod(parent, parentType, name, (Period)value, index); 18003 else if (value instanceof Duration) 18004 composeDuration(parent, parentType, name, (Duration)value, index); 18005 else if (value instanceof Range) 18006 composeRange(parent, parentType, name, (Range)value, index); 18007 else if (value instanceof RelatedArtifact) 18008 composeRelatedArtifact(parent, parentType, name, (RelatedArtifact)value, index); 18009 else if (value instanceof Annotation) 18010 composeAnnotation(parent, parentType, name, (Annotation)value, index); 18011 else if (value instanceof ProductShelfLife) 18012 composeProductShelfLife(parent, parentType, name, (ProductShelfLife)value, index); 18013 else if (value instanceof ContactDetail) 18014 composeContactDetail(parent, parentType, name, (ContactDetail)value, index); 18015 else if (value instanceof UsageContext) 18016 composeUsageContext(parent, parentType, name, (UsageContext)value, index); 18017 else if (value instanceof Expression) 18018 composeExpression(parent, parentType, name, (Expression)value, index); 18019 else if (value instanceof Signature) 18020 composeSignature(parent, parentType, name, (Signature)value, index); 18021 else if (value instanceof Timing) 18022 composeTiming(parent, parentType, name, (Timing)value, index); 18023 else if (value instanceof ProdCharacteristic) 18024 composeProdCharacteristic(parent, parentType, name, (ProdCharacteristic)value, index); 18025 else if (value instanceof CodeableConcept) 18026 composeCodeableConcept(parent, parentType, name, (CodeableConcept)value, index); 18027 else if (value instanceof ParameterDefinition) 18028 composeParameterDefinition(parent, parentType, name, (ParameterDefinition)value, index); 18029 else 18030 throw new Error("Unhandled type"); 18031 } 18032 18033} 18034